/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.nodes;

import java.awt.Image;

import java.lang.Thread;

import java.util.Collections;

import java.util.List;

import org.openide.util.NbBundle;

import org.openide.util.RequestProcessor;

import org.openide.util.Utilities;

/**

 * Children object which creates its keys on a background thread.  To use,

 * implement AsynchChildren.Provider and pass that to the constructor.

 *

 * @author Tim Boudreau

 */

public final class AsynchChildren extends Children.Keys <Object> {

    private final Provider provider;

    private final RequestProcessor.Task task;

    private static final RequestProcessor PROC = new RequestProcessor("Asynch " //NOI18N

             + "children creator", Thread.NORM_PRIORITY, true); //NOI18N

    private final R r = new R();

    /**

     * Create a new AsyncChildren instance with the passed provider object

     * which will manufacture key objects and nodes.

     * @param provider An object which can provide a list of keys and make

     *        Nodes for them

     */ 

    public AsynchChildren(Provider provider) {

        this.provider = provider;

        task = PROC.create(r, true);

    }

    protected void addNotify() {

        if (task.isFinished() || r.cancelled) {

            r.cancelled = false;

            setKeys (new Object[] { new WaitNode() });

            task.schedule(0);

        }

    }

    @SuppressWarnings("unchecked")    

    protected void removeNotify() {

        r.cancelled = true;

        task.cancel();

        setKeys (Collections.EMPTY_LIST);

    }

    /**

     * Notify this AsynchChildren that it should reconstruct its children,

     * calling <code>provider.asynchCreateKeys()</code> and setting the

     * keys to that.  Call this method if the list of child objects is known

     * or likely to have changed.

     * @param immediate If true, the keys are updated synchronously from the

     *  calling thread.  Set this to true only if you know that updating

     *  the keys will <i>not</i> be an expensive or time-consuming operation.

     */ 

    @SuppressWarnings("unchecked") //NOI18N

    public void update(boolean immediate) {

        if (immediate) {

            setKeys (provider.asynchCreateKeys());

        } else {

            task.schedule (0);

        }

    }

    public Node[] getNodes(boolean optimalResult) {

        if (optimalResult) {

            task.waitFinished();

        }

        return super.getNodes();

    }

    @SuppressWarnings("unchecked")

    protected Node[] createNodes(Object key) {

        if (key instanceof WaitNode) {

            return new Node[] { (Node) key };

        } else {

            return provider.createNodes (key);

        }

    }

    /**

     * Factory for keys and child nodes for an instance of AsynchChildren.

     */ 

    public static interface Provider <T extends Object> {

        /**

         * Create Nodes for a given key object (one from the <code>List</code>

         * returned by asynchCreateKeys()).

         * @param key An object from the list returned by 

         *        <code>asynchCreateKeys()</code>

         * @return zero or more Nodes to represent this key

         */

        public Node[] createNodes (T key);

        /**

         * Create a list of keys which can be individually passed to

         * createNodes() to create child Nodes.  Implementations of

         * this method should regularly check Thread.interrupted(), and

         * if it returns true (meaning the parent Node was collapsed or

         * destroyed), stop creating keys immediately and return

         * null.  This method is guaranteed <i>not</i> to be called on the

         * AWT event thread.

         * 

         * @return A <code>List</code> of objects to use as keys, or null 

         *         if cancelled

         */ 

        public List <T> asynchCreateKeys();

    }

    private final class R implements Runnable {

        volatile boolean cancelled = false;

        @SuppressWarnings("unchecked")

        public void run() {

            if (Thread.interrupted()) {

                doSetKeys (Collections.EMPTY_LIST);

                return;

            }

            List <Object> keys = provider.asynchCreateKeys();

            if (keys == null || Thread.interrupted()) {

                keys = Collections.EMPTY_LIST;

            }

            doSetKeys (keys);

        }

        private void doSetKeys (List <Object> keys) {

            setKeys (keys);

            justComputeNodes();

        }

    }

    //We need a type that no Children class will use as a key

    private static final class WaitNode extends AbstractNode {

        public WaitNode () {

            super (Children.LEAF);

            setDisplayName (NbBundle.getMessage (WaitNode.class, "LBL_WAIT")); //NOI18N

        }

        public Image getIcon (int type) {

            return Utilities.loadImage ("org/openide/nodes/wait.gif"); //NOI18N

        }

    }

}

LBL_WAIT=Please Wait...

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.nodes;

import java.awt.EventQueue;

import java.beans.*;

import java.util.*;

import junit.framework.TestCase;

import org.openide.nodes.*;

import org.openide.util.NbBundle;

/** Test for AsynchChildren

 * 

 * @author Tim Boudreau

 */

public class AsynchChildrenTest extends TestCase {

    public AsynchChildrenTest(String name) {

        super(name);

    }

    private ProviderImpl provider;

    private AsynchChildren kids;

    private Node n;

    public void setUp() throws Exception {

        provider = new ProviderImpl();

        kids = new AsynchChildren (provider);

        n = new AbstractNode (kids);

    }

    public void testGetNodesWaits() throws Exception {

        System.out.println("testGetNodesWaits");

        kids.addNotify();

        Node[] n = new Node[0];

        for (int i = 0; i < 5 && n.length != 4; i++) {

            n = kids.getNodes(true);

            java.lang.Thread.currentThread().sleep(400);

        }

        assertEquals (4, n.length);

    }

    public void testInitialNodeIsWaitNode() throws Exception {

        System.out.println("testInitialNodeIsWaitNode");

        Runnable r = new Runnable() {

            public void run() {

                provider.wait = true;

                kids.addNotify();

                Node[] n = kids.getNodes (false);

                assertEquals (1, n.length);

                assertEquals (NbBundle.getMessage(AsynchChildren.class, "LBL_WAIT"),

                        n[0].getDisplayName());

                provider.wait = false;

                for (int i = 0; i < 5 && n.length != 4; i++) {

                    try {

                        n = kids.getNodes(true);

                        java.lang.Thread.currentThread().sleep(200);

                    } catch (InterruptedException ex) {

                    }

                }

                assertTrue (n.length == 4);

            }

        };

        EventQueue.invokeAndWait (r);

    }

    public void testCancel() throws Exception {

        System.out.println("testCancel");

        Runnable r = new Runnable() {

            public void run() {

                provider.wait = true;

                kids.addNotify();

                kids.removeNotify();

                provider.wait = false;

                Node[] n = new Node[0];

                for (int i = 0; i < 5 && n.length != 0; i++) {

                    try {

                        n = kids.getNodes(true);

                        java.lang.Thread.currentThread().sleep(200);

                    } catch (InterruptedException ex) {

                    }

                }

                assertEquals (0, n.length);            

            }

        };

        EventQueue.invokeAndWait (r);

    }

     static final class ProviderImpl implements AsynchChildren.Provider <String> {

        boolean wait = false;

        public Node[] createNodes(String key) {

            AbstractNode nd = new AbstractNode (Children.LEAF);

            nd.setDisplayName (key);

            return new Node[] { nd };

        }

        public List asynchCreateKeys() {

            while (wait) {

                try {

                    Thread.currentThread().sleep (200);

                } catch (Exception e) {

                }

            }

            if (Thread.interrupted()) {

                return null;

            }

            List <String> result = new ArrayList <String> ();

            result.add ("A");

            result.add ("B");

            result.add ("C");

            result.add ("D");

            return result;

        }

    }

}