initialize (true, false);

        refRP.post(new ChildrenRefreshRunnable(false));

--

    /** Creates a key for given data object.

    /** Lazy initialization of the please wait node */

    * This method is here to create something different then data object,

    private static Node getPleaseWaitNode() {

    * because the data object should be finalized when not needed and

        boolean created = false;

    * that is why it should not be used as a key.

        synchronized (PLEASE_WAIT_KEY) {

    *

            if (pleaseWaitNode == null) {

    * @param obj data object

                pleaseWaitNode = new AbstractNode(Children.LEAF);

    * @return key representing the data object.

                created = true;

    */

            }

    static Object createKey (DataObject obj) {

        }

        return new Pair (obj.getPrimaryFile ());

        if (created) {

    }

            pleaseWaitNode.setName("wait"); // NOI18N

            pleaseWaitNode.setDisplayName(

    /** This method takes the key created by createKey and converts it

                NbBundle.getBundle(FolderChildren.class).getString("LBL_Wait")

    * into primary file.

            );

    *

            ((AbstractNode)pleaseWaitNode).setIconBase("org/openide/resources/wait"); //NOI18N

    * @param key the key

        }

    * @return primary file of the key

        return pleaseWaitNode;       

    */

    private static FileObject getFile (Object key) {

        return ((Pair)key).primaryFile;

--

--

        FileObject fo = getFile (key);

        FileObject fo = ((Pair)key).primaryFile;

--

    /** Improves the searching capability to wait till all children

    public Node[] getNodes(boolean optimalResult) {

    * are found and then searching thru them.

        if (optimalResult) {

    */

            Task t = refRP.post(new ChildrenRefreshRunnable(false));

    public Node findChild (final String name) {

            t.waitFinished();

        // start the initialization

            return getNodes();

        Node[] forget = getNodes (); // DO NOT DELETE

        // waits till the list of children is created

        // JST: the folowing code is replacement for

        // initialize (false, false).waitFinished ()

        // 

        // the orgiginal code caused deadlocks when called with readAccess,

        // because the refreshChildren (which we wait for to be finished)

        // method calls setKeys and they require write request

        //

        // this code could probably be replaced by 

        // Children.MUTEX.isReadAccess, if such call would be added to Mutex

        class Jst implements Runnable {

            public boolean checkReadOrWrite;

            public boolean inReadAccess = true;

            public boolean inWriteAccess = true;

            public void run () {

                if (checkReadOrWrite) {

                    inReadAccess = false;

                } else {

                    inWriteAccess = false;

                }

            }

        }

        Jst t = new Jst ();

        // the code will run either immediatally or after we leave readAccess

        // section

        Children.MUTEX.postWriteRequest(t);

        t.checkReadOrWrite = true;

        Children.MUTEX.postReadRequest(t);

        if (!t.inReadAccess && !t.inWriteAccess) {

            // if we are not in readAccess we can safely wait till

            // refreshChildren finishes and sets new keys for the 

            initialize (name == null, false).waitFinished ();

            refreshTask.waitFinished ();

--

        return super.getNodes(optimalResult);

        // do the regular child lookup

        Node node = super.findChild (name);

        return node;

--

--

        initialize (true, true);

        // set the please wait node

--

        setKeys (java.util.Collections.singleton(PLEASE_WAIT_KEY));

        initTask = t = folder.computeChildrenList (add);

        // the parameter true means to set the children to empty

        t.addTaskListener (add);

        // we don't call the setKeys directly here because

        // there can be a task spawned by refreshChildren - so

        if (waitFirst) {

        // we want to clear the children after that task is finished

            add.waitFirst ();

        refRP.post(new ChildrenRefreshRunnable(true));

        }

        return t;

--

    /** time delay between two inserts of nodes */

    /**

    private static final int TIME_DELAY = 1024;

     * Instances of this class are posted to the request processor refRP

     * (FolderChildren_refresher). We do this because we do not want

    /** Private req processor for Addition's refresh tasks */

     * to call setKeys synchronously.

    private static RequestProcessor refRP = 

     */

        new RequestProcessor("FolderChildren_refresher");

    private final class ChildrenRefreshRunnable implements Runnable {

        /** if set to true we just clear the children */

    /** Support for incremental adding of new nodes.

        private boolean clear;

    *

    * <P>

        /** Remember the parameter. */

    * There is a deadlock warning:

        ChildrenRefreshRunnable(boolean clear) {

    * <OL>

            this.clear = clear;

    *   <LI>A thread waiting in the waitFirst method can have MUTEX.readAccess

    *   <LI>Thread running run () needs access to MUTEX.writeAccess (because of setKeys)

    *   <LI>Be sure that the thread leaves waitFirst before writeAccess is needed

    * </OL>

    */

    private class Addition

    implements TaskListener, FolderListListener, Runnable {

        static final long serialVersionUID =-4194617547214845940L;

        /** last time of addition */

        private long time = System.currentTimeMillis () + TIME_DELAY;

        /** delay */

        private int delay = TIME_DELAY;

        /** update the nodes during processing or only at the end */

        private boolean processingUpdate;

        /** a keys to be later refreshed */

        private List refKeys;

        // fix of #27025. We have to keep reference to all data objects

        // for the whole lifetime of this object otherwise it can happen

        // that a data object is GCed between calling refreshKeys and

        // createNodes

        private List dataObjects = new ArrayList();

        /** processing of DataFolder.computeChildrenList finished */

        private boolean processingFinished;

        /** a task that is used to request refreshing of keys */

        private RequestProcessor.Task refTask = refRP.create(this); // NOI18N

        /** @param processingUpdate update the nodes during

        *  processing or only at the end 

        */

        public Addition (boolean processingUpdate) {

            this.processingUpdate = processingUpdate;

        }

        /** Another object has been recognized.

         * @param obj the object recognized

         * @param arr array where the implementation should add the

         *    object

         */

        public void process(DataObject obj, java.util.List arr) {

            if (!filter.acceptDataObject (obj)) {

                return;

            }

            // first accepted object is notified to the waiting thread in

            boolean first = arr.isEmpty ();

            arr.add (obj);

            // see comment for the variable dataObjects

            dataObjects.add (obj);

            if (!processingUpdate) {

                // if we should not notify during processing update

                // skip the rest

                return;

            }

            if (first) {

                synchronized (this) {

                    this.notify ();

                    refreshKeys (arr);

                }

                return;

            }

            if (System.currentTimeMillis () > time) {

                if (!arr.isEmpty ()) {

                    // add the nodes

                    synchronized (this) {

                        refreshKeys (arr);

                    }

                    delay *= 2;

                }

                time = System.currentTimeMillis () + delay;

            }

        }

        /** All objects has been recognized.

         * @param arr list of DataObjects

         */

        public void finished(java.util.List arr) {

            synchronized (this) {

                this.notify ();

                this.processingFinished = true;

                // change the order because initialize method has already finished

                refreshKeys (arr);

            }

        }

        /** Getter for first map.

        */

        public synchronized void waitFirst () {

            try {

                this.wait (50);

            } catch (InterruptedException e) {

                throw new IllegalStateException();

            }

--

        /** calls setKeys with the folder children 

        /** Called when a task finishes running.

         * or with empty collection if clear set to true.

         * @param task the finished task

--

            List toSet;

            if (clear) {

            synchronized (this) { // 1

                setKeys (java.util.Collections.EMPTY_SET);

                toSet = refKeys;

                return;

                refKeys = null;

            }

            if (toSet != null) {

                // toSet can be null if 

                //   1. a task blocks on synchronized(this) // 1

                //   2. refreshKeys calls refKey = <newvalue> + refTask.schedule

                //   3. a task uses the new value, but is already planned =>

                //   4. it will be run next time with toSet == null

                if (FolderChildren.this.err != null) FolderChildren.this.err.log("setKeys: " + toSet);

                FolderChildren.this.setKeys(toSet);

--

            synchronized (this) {

            DataObject []ch = folder.getChildren();

                if (processingFinished) {

            Object []keys = new Object[ch.length];

                    if (FolderChildren.this.refreshTask == refTask) {

            for (int i = 0; i < keys.length; i++) {

                        if (err != null) err.log("fix for #30153 applied ");

                keys[i] = new Pair(ch[i].getPrimaryFile());

                        FolderChildren.this.refreshTask = Task.EMPTY;

//                        refTask.cancel();

                    }

                }

--

--

    */

     * It serves as a key for the given data object.

--

     * It is here to create something different then data object,

     * because the data object should be finalized when not needed and

     * that is why it should not be used as a key.

     */