Java Children.Array方法代码示例

import org.openide.nodes.Children; //导入方法依赖的package包/类
protected void setUp () {        
    System.setProperty("org.openide.util.Lookup", Lkp.class.getName()); // no lookup
    
    
    p = new ExplorerPanel ();
    em = p.getExplorerManager ();
    
    TreeView tv = new BeanTreeView ();
    p.add (tv);
    Children ch = new Children.Array ();
    nodes = new Node[10];
    for (int i = 0; i < 10; i++) {
        nodes[i] = new AbstractNode (Children.LEAF);
        nodes[i].setName ("Node" + i);
    }
    ch.add (nodes);
    Node root = new AbstractNode (ch);
    em.setRootContext (root);
    
    // check synchronixzation before
    assertArrays ("INIT: getSelectedNodes equals getActivatedNodes.",
        em.getSelectedNodes (), p.getActivatedNodes ());
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
@Messages("LBL_TemplatesPanel_PleaseWait=Please wait...")
private void postInitComponents () {        
    Mnemonics.setLocalizedText(jLabel1, this.firer.getCategoriesName());
    Mnemonics.setLocalizedText(jLabel2, this.firer.getTemplatesName());
    this.description.setEditorKit(new HTMLEditorKit());
    description.putClientProperty( JEditorPane.HONOR_DISPLAY_PROPERTIES, Boolean.TRUE );

    // please wait node, see issue 52900
    pleaseWait = new AbstractNode (Children.LEAF) {
        @Override
        public Image getIcon (int ignore) {
            return PLEASE_WAIT_ICON;
        }
    };
    pleaseWait.setName(LBL_TemplatesPanel_PleaseWait());
    Children ch = new Children.Array ();
    ch.add (new Node[] {pleaseWait});
    final Node root = new AbstractNode (ch);
    SwingUtilities.invokeLater (new Runnable () {
        @Override public void run() {
            ((ExplorerProviderPanel)categoriesPanel).setRootNode (root);
        }
    });
    ((ExplorerProviderPanel)projectsPanel).addDefaultActionListener( firer );
    description.addHyperlinkListener(new ClickHyperlinks());
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
private Node getRootNode(FileObject fileInProject, Filter filter) {
    Children children = new Children.Array();
    children.add(createPackageRootNodes(fileInProject, choosingFolder, filter));
    AbstractNode root = new AbstractNode(children);
    root.setIconBaseWithExtension("org/netbeans/modules/form/editors2/iconResourceRoot.gif"); // NOI18N
    root.setDisplayName(NbBundle.getMessage(ClassPathFileChooser.class, "CTL_ClassPathName")); // NOI18N
    // ProjectUtils.getInformation(prj).getDisplayName()
    return root;
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
private MyNode(boolean addChildren) {
    super(new Children.Array());
    setName("my2");
    setDisplayName("disp2");
    setShortDescription("short2");
    setIconBaseWithExtension("org/netbeans/core/ide/TestIcon2.png");

    if (addChildren) {
        getChildren().add(new Node[] { new MyNode(false), new MyNode(false) });
    }
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
private AbstractNode getWaitRoot() {
    return new AbstractNode(new Children.Array() {
        @Override
        protected Collection<Node> initCollection() {
            return Collections.singleton((Node) new WaitNode());
        }
    });
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
protected void setUp() throws Exception {
    Children kids = new Children.Array();
    nodes = new Node[] {
        new NoHelpNode(),
        new WithHelpNode("foo"),
        new WithHelpNode("bar"),
        new WithHelpNode("foo"),
    };
    kids.add(nodes);
    root = new AbstractNode(kids);
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
private static Node[] createCategories() {
    Node[] categories = new Node[ CATEGORY_COUNT ];
    
    for( int i=0; i<categories.length; i++ ) {
        Children items = new Children.Array();
        items.add( createItems() );
        categories[i] = new CategoryNode( items, i );
    }
    return categories;
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
private static Children createChildren(final PackageData data, CustomScopePanel panel) {
    Children childs = new Children.Array();
    for (ClassData classData : data.getClasses()) {
        childs.add(new Node[]{new ClassNode(classData, panel)});
    }
    return childs;
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
/**
 * Sets the given <code>rootNode</code> as the root
 * of this view and adds its associated section node 
 * panel as a section for this.
 */
public void setRootNode(SectionNode rootNode) {
    this.rootNode = rootNode;
    Children root = new Children.Array();
    root.add(new Node[]{rootNode});
    AbstractNode mainNode = new AbstractNode(root);
    mainNode.setDisplayName(rootNode.getDisplayName());
    mainNode.setIconBaseWithExtension(rootNode.getIconBase() + ".gif"); //NOI18N
    setRoot(mainNode);
    addSection(rootNode.getSectionNodePanel());
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
public void testIndexOfProvidesResultsEvenIfTheVisualizerIsComputedViaDifferentMeans() throws Exception {
    AbstractNode a = new AbstractNode(new Children.Array());
    AbstractNode m = new AbstractNode(Children.LEAF);
    a.getChildren().add(new Node[] { Node.EMPTY.cloneNode(), m, Node.EMPTY.cloneNode() });
    
    TreeNode ta = Visualizer.findVisualizer(a);
    TreeNode tm = Visualizer.findVisualizer(m);
    
    assertEquals("Index is 1", 1, ta.getIndex(tm));
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
public void testLeafNodeReallyNotDisplayed() throws Throwable {
    final AbstractNode root = new AbstractNode(new Children.Array());
    root.setName("test root");
    
    
    
    root.getChildren().add(new Node[] {
        createLeaf("kuk"),
        createLeaf("huk"),
    });
    
    class AWTTst implements Runnable {
        public void run() {
            Panel p = new Panel();
            p.getExplorerManager().setRootContext(root);

            ContextTreeView ctv = new ContextTreeView();
            p.add(BorderLayout.CENTER, ctv);

            JFrame f = new JFrame();
            f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);
            f.getContentPane().add(BorderLayout.CENTER, p);
            f.setVisible(true);

            final JTree tree = ctv.tree;
    
            // wait a while till the frame is realized and ctv.addNotify called
            Object r = tree.getModel().getRoot();
            assertEquals("There is root", Visualizer.findVisualizer(root), r);
            
            int cnt = tree.getModel().getChildCount(r);
            if (cnt != 0) {
                fail("Should be zero " + cnt + " but there was:  " +
                        tree.getModel().getChild(r, 0) + " and " +
                        tree.getModel().getChild(r, 1)
                        );
            }
            assertEquals("No children as they are leaves", 0, cnt);

            Node n = Visualizer.findNode(r);
            n.setName("Try Rename!");
        }
    }
    AWTTst awt = new AWTTst();
    try {
        SwingUtilities.invokeAndWait(awt);
    } catch (InvocationTargetException ex) {
        throw ex.getTargetException();
    }
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
@Override
public void setUp () {
    TestNode[] childrenNodes = new TestNode[3];
    for (int i = 0; i < childrenNodes.length; i ++) {
        TestNode[] leafNodes = new TestNode[100];
        for (int j = 0; j < leafNodes.length; j ++) {
            leafNodes[j] = new TestNode ("[" + (100 * i + j) + "]");
        }
        Children.Array leafs = new Children.Array ();
        leafs.add (leafNodes);
        //childrenNodes [i] = new TestNode (leafs, "[" + (i * 100) + "-" + ((i + 1) *100 - 1) + "]");
        switch (i) {
            case 0:
                childrenNodes[i] = new TestNode (leafs, "[1-index from 0 to 99]");
                break;
            case 1:
                childrenNodes[i] = new TestNode (leafs, "[10-index from 100 to 199]");
                break;
            case 2:
                childrenNodes[i] = new TestNode (leafs, "[2-index from 200 to 299]");
                break;
            default:
                fail ("Unexcepted value " + i);
        }
    }

    Children.Array children = new Children.Array ();
    children.add (childrenNodes);

    rootNode = new TestNode (children, "[0 - 1000]");

    component = new OutlineViewComponent (rootNode);
    view = component.getOutlineView ();
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
public void testEnable() {
    OpenLocalExplorerAction action = new OpenLocalExplorerAction();
    Node leaf = new AbstractNode(Children.LEAF);
    Node parent = new AbstractNode(new Children.Array());
    assertFalse(action.enable(null));
    assertFalse(action.enable(new Node[0]));
    assertTrue(action.enable(new Node[] {parent}));
    assertFalse(action.enable(new Node[] {leaf}));
    assertFalse(action.enable(new Node[] {parent, parent}));
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
public void testStructureFullOfFormFiles() throws Exception {
    if ((
        Utilities.getOperatingSystem() & 
        (Utilities.OS_SOLARIS | Utilities.OS_SUNOS)
    ) != 0) {
        LOG.log(Level.CONFIG, "Giving up, this test fails too randomly on Solaris");
        return;
    }
    
    Children ch = new Children.Array();
    Node root = new AbstractNode(ch);
    root.setName(getName());

    ch.add(nodeWith("A", "-A", "-B", "B"));
    ch.add(nodeWith("X", "Y", "Z"));

    final Node first = ch.getNodes()[0];

    LOG.log(Level.INFO, "Nodes are ready: {0}", root);
    final ExplorerManager em = testWindow.getExplorerManager();
    em.setRootContext(root);
    LOG.info("setRootContext done");
    em.setSelectedNodes(new Node[] { first });
    LOG.log(Level.INFO, "setSelectedNodes to {0}", first);
    LOG.log(Level.INFO, "Verify setSelectedNodes: {0}", Arrays.asList(em.getSelectedNodes()));

    EventQueue.invokeAndWait(new Runnable() {
        @Override
        public void run() {
            TreePath path = treeView.tree.getSelectionPath();
            LOG.log(Level.INFO, "getSelectionPath {0}", path);
            LOG.log(Level.INFO, "getSelectedNodes {0}", Arrays.toString(em.getSelectedNodes()));
            assertNotNull("Something is selected", path);
            Node node = Visualizer.findNode(path.getLastPathComponent());
            assertEquals("It is the first node", first, node);
        }
    });
    
    sendAction("expand");
    sendAction("selectNext");

    assertEquals("Explored context is N0", first, em.getExploredContext());
    assertEquals("Selected node is A", 1, em.getSelectedNodes().length);
    assertEquals("Selected node is A", "A", em.getSelectedNodes()[0].getName());

    sendAction(enter);

    Keys keys = (Keys)first.getChildren();
    assertEquals("One invocation", 1, keys.actionPerformed);
    assertFalse("No write access", keys.writeAccess);
    assertFalse("No read access", keys.readAccess);
}
 

import org.openide.nodes.Children; //导入方法依赖的package包/类
private static Node createNode(String name, boolean leaf) {
    AbstractNode n = new AbstractNode(leaf ? Children.LEAF : new Children.Array());
    n.setName(name);
    return n;
}