Refine search
/** * Creates a lookup that contains an array of objects specified via the * parameter. The resulting lookup is fixed in the following sense: it * contains only fixed set of objects passed in by the array parameter. * Its contents never changes so registering listeners on such lookup * does not have any observable effect (the listeners are never called). * * @param objectsToLookup list of objects to include * @return Fully initialized lookup object ready to use * @throws NullPointerException if the supplied argument is null * @since 2.21 * */ public static Lookup fixed(Object... objectsToLookup) { if (objectsToLookup == null) { throw new NullPointerException(); } if (objectsToLookup.length == 0) { return Lookup.EMPTY; } if (objectsToLookup.length == 1) { return singleton(objectsToLookup[0]); } return new SimpleLookup(Arrays.asList(objectsToLookup)); }
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); } }
Lookup misl = Lookups.metaInfServices(l); defaultLookup = misl.lookup(Lookup.class); LOG.log(Level.FINER, "Searching for {0} in {1} yields {2}", new Object[]{Lookup.class, misl, defaultLookup}); if (defaultLookup != null) { Lookup.Provider prov = misl.lookup(Lookup.Provider.class); LOG.log(Level.FINER, "Searching for {0} in {1} yields {2}", new Object[]{Lookup.Provider.class, misl, defaultLookup}); if (prov != null) { defaultLookup = Lookups.proxy(prov); LOG.log(Level.FINE, "Default lookup initialized {0}", defaultLookup); return defaultLookup;
public void init(ClassLoader loader, Lookup metaInfLookup, boolean addPath) { // Had no such line, use simple impl. // It does however need to have ClassLoader available or many things will break. // Use the thread context classloader in effect now. Lookup clLookup = Lookups.singleton(loader); List<Lookup> arr = new ArrayList<Lookup>(); arr.add(metaInfLookup); arr.add(clLookup); String paths = System.getProperty("org.openide.util.Lookup.paths"); // NOI18N if (addPath && paths != null) { LOG.log(Level.FINE, "Adding search paths {0}", paths); for (String p : paths.split(":")) { // NOI18N arr.add(Lookups.forPath(p)); } } LOG.log(Level.FINER, "Setting DefLookup delegates {0}", arr); setLookups(arr.toArray(new Lookup[0])); } }
public Lookup createAdditionalLookup(Lookup baseContext) { Project project = baseContext.lookup(Project.class); if (project == null) { assert false : "Unable to derive Project"; return Lookup.EMPTY; } ComplibProjectOpenedHook projectOpenedHook = new ComplibProjectOpenedHook(project); return Lookups.fixed(projectOpenedHook); } }
public ViewerFilterNode (Node delegate, Object ... extraObjects) { super(delegate, Children.LEAF /*FIXME*/, new ProxyLookup(delegate.getLookup(), Lookups.fixed(extraObjects))); }
public CookieAdjustingFilter(Node n) { super(n, null, new org.openide.util.lookup.ProxyLookup (new org.openide.util.Lookup[] { n.getLookup (), org.openide.util.lookup.Lookups.singleton(InstanceDataObject.this) })); }
@Override @Nonnull public Lookup filter (final @Nonnull Lookup lookup) { final ProfiledDisplay display = lookup.lookup(ProfiledDisplay.class); return (display == null) ? lookup // e.g. the root node : new ProxyLookup(Lookups.fixed(new DisplayActionProvider(display)), lookup); } };
treeTableView1.setTreePreferredWidth(200); node.addPropertyChangeListener(this); ClassLoader l = Lookup.getDefault().lookup(ClassLoader.class); if (l == null) { l = Thread.currentThread().getContextClassLoader(); selectedLookup = org.openide.util.lookup.Lookups.proxy(this);
Lookup misl = Lookups.metaInfServices(l); defaultLookup = (Lookup)misl.lookup(Lookup.class); if (defaultLookup != null) { return defaultLookup; Lookup.Provider prov = (Lookup.Provider)misl.lookup(Lookup.Provider.class); if (prov != null) { defaultLookup = Lookups.proxy(prov); return defaultLookup; Lookup clLookup = Lookups.singleton(l); defaultLookup = new ProxyLookup(new Lookup[] {misl, clLookup}); return defaultLookup;
@Override public Action[] getActions (boolean ignored) { Card card = getLookup().lookup(Card.class); JavacardPlatform platform = card.getPlatform(); String kind = platform.getPlatformKind(); String path = "org-netbeans-modules-javacard-spi/kinds/" + kind + "/Actions/"; //NOI18N return Lookups.forPath(path).lookupAll(Action.class).toArray(new Action[0]); }
private void init(Lookup masterLookup) { if (initialized) return; initialized = true; Lookup lookup = Lookups.forPath("RubyOptionsDialog"); // NOI18N Iterator<? extends AdvancedOption> it = lookup.lookup(new Lookup.Template<AdvancedOption> (AdvancedOption.class)). allInstances().iterator(); while (it.hasNext()) { AdvancedOption option = it.next(); String category = option.getDisplayName(); categoriesOrdered.add(category); categoryToOption.put(category, option); OptionsPanelController controller = option.create(); categoryToController.put(category, controller); JPanel panel = new JPanel(); //panel.setBorder(BorderFactory.createTitledBorder(category)); panel.setLayout(new BorderLayout()); panel.add(controller.getComponent(masterLookup)); categoryToPanel.put(category, panel); } }
private NamedOption findOption(String name) { for (String category: Arrays.asList(HIGHLIGTING_CATEGORY, HINTS_CATEGORY, MAKE_PROJECT_CATEGORY, OTHER_CATEGORY)) { for (NamedOption option : Lookups.forPath(category).lookupAll(NamedOption.class)) { if (name.equals(option.getName())) { return option; } } } for (NamedOption option : Lookup.getDefault().lookupAll(NamedOption.class)) { if (name.equals(option.getName())) { return option; } } throw new IllegalArgumentException("Not found option " + name); //NOI18N } }
@Nonnull public static Lookup createLookupWith (final @Nonnull Lookup lookup, final @Nonnull Object ... objects) { return new ProxyLookup(Lookups.fixed(objects), lookup); }
private void performAction(Node node) { final Project project = getProject(node); if (project != null) { ActionProvider ap = project.getLookup().lookup(ActionProvider.class); if (ap != null) { ap.invokeAction(ActionProvider.COMMAND_COMPILE_SINGLE, Lookups.singleton(node)); return; } } performAction(node, project); }
public static Lookup normalizeLookup(Lookup l) { if (!l.lookupAll(Project.class).isEmpty()) { return Lookups.fixed(l.lookupAll(Project.class).toArray(new Object[0])); } Collection<? extends FileObject> files = toAnalyze(l); if (!files.isEmpty()) { return Lookups.fixed(files.toArray(new Object[0])); } return null; }
public UnoccupiedPartFieldsNode(Node node) throws DataObjectNotFoundException { super(node // the origional node , new FilterNode.Children(node) // children , new ProxyLookup(node.getLookup() // lookup from the origional node , Lookups.singleton(new SimpleLayer(node.getDisplayName()))) // lookup with layer ); }
@Override public Lookup getLookup() { // FIXME why is the platform written in such strange way ? J2eePlatform platform = Deployment.getDefault().getJ2eePlatform(instance.getUrl()); if (platform == null) { // can happen when J2EE is activated and J2SE is not !?@# return Lookups.singleton(instance.getInstanceProperties()); } else { return new ProxyLookup(Lookups.fixed(platform, instance.getInstanceProperties()), Lookups.proxy(platform)); } }
@Override @NonNull public DynamicLookup getLookup() { DynamicLookup dynLkp = underConstruction.get(); return dynLkp; dynLkp = new DynamicLookup(Lookups.singleton(this)); try { underConstruction.set(dynLkp); final Lookup preLkp = Lookups.fixed(new OpenHook(), this); final Lookup convertorLkp = this.result.getLookup(); if (convertorLkp == null) { for (ProjectConvertorServiceFactory f : services.allInstances()) { postServices.addAll(f.createServices(this, result)); final Lookup postLkp = Lookups.fixed(postServices.toArray()); dynLkp.setBaseLookups(preLkp, convertorLkp, postLkp); synchronized (this) {