Java InstanceContent类代码示例

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
private void doTestNodesWithChangesInLookup (Class c) {
    InstanceContent ic = new InstanceContent();
    
    Node[] arr = new Node[] {
        new AbstractNode(Children.LEAF, new AbstractLookup(ic)),
        new AbstractNode(Children.LEAF, Lookup.EMPTY),
    };
    arr[0].setName("cookie-container-node");
    arr[1].setName("node-as-cookie");
    //doTestNodes(arr, AbstractNode.class);
    doTestNodes (arr, c, 2);
    
    ic.add (arr[1]);
    
    /* Huh? There should be both [0] and [1], how can you say which one will be returned?
    assertEquals ("Now the [1] is in lookup of [0]", arr[1], lookup.lookup (c));
     */
    Collection all = lookup.lookup(new Lookup.Template(c)).allInstances();
    assertEquals("Two nodes are in TC lookup", 2, all.size());
    assertEquals("They are the ones we expect", new HashSet(Arrays.asList(arr)), new HashSet(all));
    assertTrue("Lookup simple query gives one or the other", new HashSet(Arrays.asList(arr)).contains(lookup.lookup(c)));
    assertEquals("Have two lookup items", 2, lookup.lookup(new Lookup.Template(c)).allItems().size());

    doTestNodes (null, c, 2);
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
private FilterNode(Filter filter, InstanceContent content) {
    super(Children.LEAF, new AbstractLookup(content));
    content.add(filter);

    content.add(filter.getEditor());
    this.filter = filter;
    filter.getChangedEvent().addListener(new ChangedListener<Filter>() {

        @Override
        public void changed(Filter source) {
            update();
        }
    });

    update();

    Lookup.Template<FilterChain> tpl = new Lookup.Template<>(FilterChain.class);
    result = Utilities.actionsGlobalContext().lookup(tpl);
    result.addLookupListener(this);

    FilterTopComponent.findInstance().getFilterSettingsChangedEvent().addListener(this);
    resultChanged(null);

    setShortDescription("Double-click to open filter");
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
private FilterNode(Filter filter, InstanceContent content) {
    super(Children.LEAF, new AbstractLookup(content));
    content.add(filter);

    content.add(filter.getEditor());
    this.filter = filter;
    filter.getChangedEvent().addListener(new ChangedListener<Filter>() {

        @Override
        public void changed(Filter source) {
            update();
        }
    });

    update();

    Lookup.Template<FilterChain> tpl = new Lookup.Template<>(FilterChain.class);
    result = Utilities.actionsGlobalContext().lookup(tpl);
    result.addLookupListener(this);

    FilterTopComponent.findInstance().getFilterSettingsChangedEvent().addListener(this);
    resultChanged(null);
    
    setShortDescription("Double-click to open filter");
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
public void testLookupInitializedForCloneable() {
    InstanceContent ic = new InstanceContent();
    Lookup lookup = new AbstractLookup(ic);
    ic.add(10);

    CloneableTopComponent cmv = MultiViews.createCloneableMultiView("text/context", new LP(lookup));
    assertEquals("10 now", Integer.valueOf(10), cmv.getLookup().lookup(Integer.class));
    
    assertNotNull("MultiViewComponent created", cmv);
    TopComponent mvc = cmv.cloneTopComponent();
    
    assertNotNull("MultiViewComponent cloned", mvc);
    MultiViewHandler handler = MultiViews.findMultiViewHandler(mvc);
    assertNotNull("Handler found", handler);
    
    assertEquals("10 now", Integer.valueOf(10), mvc.getLookup().lookup(Integer.class));
    ic.remove(10);
    ic.add(1);
    assertEquals("1 now", Integer.valueOf(1), mvc.getLookup().lookup(Integer.class));
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
private void checkInstanceInGetLookup (Object obj, InstanceContent ic, Node node, boolean shouldBeThere) {
    Listener listener = new Listener ();
    Lookup.Result res = node.getLookup().lookupResult(obj.getClass());
    Collection ignore = res.allItems ();
    res.addLookupListener(listener);

    ic.add (obj);
    if (shouldBeThere) {
        listener.assertEvents ("One change in node's lookup", -1, 1);
        assertEquals ("Can access object in content via lookup", obj, node.getLookup ().lookup (obj.getClass ()));
    } else {
        assertNull ("Cannot access object in content via lookup", node.getLookup ().lookup (obj.getClass ()));
    }
        
    
    ic.remove (obj);
    if (shouldBeThere) {
        listener.assertEvents ("One change in node's lookup", -1, 1);
    }
    assertNull ("Cookie is removed", node.getLookup ().lookup (obj.getClass ()));
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
@Override
public void handleRename(DataFolder folder, String newName) {
    InstanceContent ic = new InstanceContent();
    ic.add(folder.getNodeDelegate());
    ExplorerContext d = new ExplorerContext();
    d.setNewName(newName);
    ic.add(d);
    final Lookup l = new AbstractLookup(ic);
    if (ActionsImplementationFactory.canRename(l)) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                Action a = RefactoringActionsFactory.renameAction().createContextAwareInstance(l);
                a.actionPerformed(RefactoringActionsFactory.DEFAULT_EVENT);
            }
        });
    } else {
        FileObject fo = folder.getPrimaryFile();
        try {
            folder.rename(newName);
        } catch (IOException ioe) {
            ErrorManager.getDefault().notify(ioe);
        }
    }
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
public void testSurviveFocusChange() throws Exception {
    InstanceContent ic = new InstanceContent();
    Lookup lkp = new AbstractLookup(ic);

    Action clone = ((ContextAwareAction) Actions.forID("cat", "survive")).createContextAwareInstance(lkp);
    L listener = new L();
    clone.addPropertyChangeListener(listener);

    assertFalse("Disabled", clone.isEnabled());
    Object val = Integer.valueOf(1);
    ic.add(val);
    assertTrue("Enabled now", clone.isEnabled());
    assertEquals("One change", 1, listener.cnt);
    ic.remove(val);
    assertTrue("Still Enabled", clone.isEnabled());

    Survival.value = 0;
    clone.actionPerformed(new ActionEvent(this, 0, ""));
    assertEquals("Added one", 1, Survival.value);
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
public void testChangeOfDefaultLookupAppliedToRPTask() throws Exception {
    Lookup prev = Lookup.getDefault();
    final Lookup my = new AbstractLookup(new InstanceContent());
    final Thread myThread = Thread.currentThread();
    final RequestProcessor.Task[] task = { null };
    final boolean[] ok = { false };
    
    Lookups.executeWith(my, new Runnable() {
        @Override
        public void run() {
            assertSame("Default lookup has been changed", my, Lookup.getDefault());

            if (task[0] == null) {
                assertSame("We are being executed in the same thread", myThread, Thread.currentThread());
                // once again in the RP
                task[0] = RequestProcessor.getDefault().post(this, 500);
            } else {
                ok[0] = true;
            }
        }
    });
    assertNotNull("In my lookup code executed OK", task[0]);
    assertEquals("Current lookup back to normal", prev, Lookup.getDefault());
    task[0].waitFinished();
    assertTrue("Even RP task had the right lookup", ok[0]);
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
public void testCopyLikeProblem() throws Exception {
    FileObject fo = folder.getFileObject("testCopyLike.instance");

    Object obj = fo.getAttribute("instanceCreate");
    if (!(obj instanceof Action)) {
        fail("Shall create an action: " + obj);
    }

    InstanceContent ic = new InstanceContent();
    AbstractLookup l = new AbstractLookup(ic);
    ActionMap map = new ActionMap();
    map.put("copy-to-clipboard", new MyAction());
    ic.add(map);

    CntListener list = new CntListener();
    Action clone = ((ContextAwareAction)obj).createContextAwareInstance(l);
    clone.addPropertyChangeListener(list);
    assertTrue("Enabled", clone.isEnabled());

    ic.remove(map);
    assertFalse("Disabled", clone.isEnabled());
    list.assertCnt("one change", 1);
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
public void testOwnContextAction() throws Exception {
    MultiContext.cnt = 0;
    
    FileObject fo = FileUtil.getConfigFile(
        "actions/support/test/testOwnContext.instance"
    );
    assertNotNull("File found", fo);
    Object obj = fo.getAttribute("instanceCreate");
    assertNotNull("Attribute present", obj);
    assertTrue("It is action", obj instanceof Action);
    assertFalse("It is not context aware action: " + obj, obj instanceof ContextAwareAction);
    Action a = (Action)obj;

    InstanceContent ic = contextI;
    ic.add(10);

    assertEquals("Number lover!", a.getValue(Action.NAME));
    a.actionPerformed(new ActionEvent(this, 300, ""));
    assertEquals("Global Action not called", 10, MultiContext.cnt);

    ic.remove(10);
    a.actionPerformed(new ActionEvent(this, 200, ""));
    assertEquals("Global Action stays same", 10, MultiContext.cnt);
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
private PhotoNode(String photo, InstanceContent ic) {
    super(Children.LEAF, new AbstractLookup(ic));
    final String name = new File(photo).getName();
    setName(name);
    setDisplayName(name);
    setShortDescription(photo);

    ic.add((OpenCookie) () -> {
        TopComponent tc = findTopComponent(photo);
        if (tc == null) {
            tc = new PhotoViewerTopComponent(photo);
            tc.open();
        }
        tc.requestActive();
    });
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
private CompilationNode(final Folder folder, Children children, InstanceContent content) {
    super(children, new AbstractLookup(content));
    this.setDisplayName(folder.getName());

    if (folder instanceof Group) {
        content.add(new OpenCookie() {

            @Override
            public void open() {
                final List<InputGraph> graphs = ((Group) folder).getGraphs();
                if (graphs.isEmpty()) {
                    JOptionPane.showMessageDialog(null, "Cannot open compilation, because there was no snapshots recorded!");
                } else {
                    Lookup.getDefault().lookup(GraphViewer.class).view(graphs.get(0));
                }
            }
        });
    }
    content.add(folder);
    folder.getChangedEvent().addListener(this);
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
public void testActionStatusUpdatedOnLookupChange() throws Exception {
    final InstanceContent content = new InstanceContent();
    Lookup lkp = new AbstractLookup( content );
    final SaveAsCapable saveAsImpl = new SaveAsCapable() {
        public void saveAs(FileObject folder, String name) throws IOException {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    };
    
    TopComponent tc = new TopComponent( lkp );
    editorMode.dockInto( tc );
    tc.open();
    tc.requestActive();
    assertTrue(Arrays.asList(WindowManager.getDefault().getOpenedTopComponents(editorMode)).contains(tc));
    
    ContextAwareAction action = SaveAsAction.create();
    assertFalse( "action is disabled for editor windows without SaveAsCapable in their Lookup", action.isEnabled() );
    
    Action a = action.createContextAwareInstance( tc.getLookup() );
    
    content.add( saveAsImpl );
    assertTrue( "action is enabled for editor windows with SaveAsCapable in their Lookup", a.isEnabled() );
    content.remove( saveAsImpl );
    assertFalse( "action is disabled for editor windows without SaveAsCapable in their Lookup", a.isEnabled() );
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
private FolderNode(final Folder folder, FolderChildren children, InstanceContent content) {
    super(children, new AbstractLookup(content));
    this.content = content;
    this.children = children;
    if (folder instanceof FolderElement) {
        final FolderElement folderElement = (FolderElement) folder;
        this.setDisplayName(folderElement.getName());
        content.add(new RemoveCookie() {
            @Override
            public void remove() {
                folderElement.getParent().removeElement(folderElement);
            }
        });
    }
}
 

import org.openide.util.lookup.InstanceContent; //导入依赖的package包/类
public CustomMethodNode(CustomSaasMethod method, InstanceContent content) {
    super(Children.LEAF, new AbstractLookup(content));
    this.method = method;
    content.add(method);
    transferable = ExTransferable.create(
        new SaasTransferable<SaasMethod>(method, SaasTransferable.CUSTOM_METHOD_FLAVORS));
}