Attachment #72285 for bug #150747

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 150747
Collapse All | Expand All

Lines 61-76 Link Here

(-)a/favorites/src/org/netbeans/modules/favorites/Favorites.java (-25 / +55 lines)
61	import org.openide.filesystems.FileStateInvalidException;	61	import org.openide.filesystems.FileStateInvalidException;
62	import org.openide.filesystems.FileUtil;	62	import org.openide.filesystems.FileUtil;
63	import org.openide.filesystems.Repository;	63	import org.openide.filesystems.Repository;
		64	import org.openide.loaders.ChangeableDataFilter;
		65	import org.openide.loaders.DataFilter;
64	import org.openide.loaders.DataFolder;	66	import org.openide.loaders.DataFolder;
65	import org.openide.loaders.DataObject;	67	import org.openide.loaders.DataObject;
66	import org.openide.loaders.DataShadow;	68	import org.openide.loaders.DataShadow;
67	import org.openide.nodes.FilterNode;	69	import org.openide.nodes.FilterNode;
68	import org.openide.nodes.Index;	70	import org.openide.nodes.Index;
69	import org.openide.nodes.Node;	71	import org.openide.nodes.Node;
		72	import org.openide.util.ChangeSupport;
70	import org.openide.util.Exceptions;	73	import org.openide.util.Exceptions;
71	import org.openide.util.ImageUtilities;	74	import org.openide.util.ImageUtilities;
72	import org.openide.util.NbBundle;	75	import org.openide.util.NbBundle;
73	import org.openide.util.Utilities;
74	import org.openide.util.datatransfer.PasteType;	76	import org.openide.util.datatransfer.PasteType;
75		77
76	/**	78	/**
Lines 287-329 Link Here
287	}	289	}
288	}	290	}
289		291
290	private static class Chldrn extends FilterNode.Children	292
291	implements ChangeListener, Runnable {	293
		294	static class VisQ
		295	implements DataFilter.Lowlevel, ChangeableDataFilter, ChangeListener {
		296	public static final VisQ DEFAULT = new VisQ();
		297
292	private ChangeListener weak;	298	private ChangeListener weak;
293	private boolean hideHidden;	299	private ChangeSupport support = new ChangeSupport(this);
294	/** Creates new Chldrn. */	300
295	public Chldrn (Node node, boolean hideHidden) {	301	VisQ() {
296	super (node);
297	this.hideHidden = hideHidden;
298
299	weak = org.openide.util.WeakListeners.change(this, VisibilityQuery.getDefault());	302	weak = org.openide.util.WeakListeners.change(this, VisibilityQuery.getDefault());
300	VisibilityQuery.getDefault().addChangeListener(weak);	303	VisibilityQuery.getDefault().addChangeListener(weak);
301	}	304	}
302		305
		306	public boolean acceptFileObject(FileObject fo) {
		307	return VisibilityQuery.getDefault().isVisible(fo);
		308	}
		309
		310	public boolean acceptDataObject(DataObject obj) {
		311	return VisibilityQuery.getDefault().isVisible(obj.getPrimaryFile());
		312	}
		313
		314	public void addChangeListener(ChangeListener listener) {
		315	support.addChangeListener(listener);
		316	}
		317
		318	public void removeChangeListener(ChangeListener listener) {
		319	support.removeChangeListener(listener);
		320	}
		321
		322	public void stateChanged(ChangeEvent e) {
		323	support.fireChange();
		324	}
		325	} // end of VisQ
		326
		327	private static class Chldrn extends FilterNode.Children {
		328	private boolean hideHidden;
		329	/** Creates new Chldrn. */
		330	public Chldrn(Node node, boolean hideHidden) {
		331	super (node);
		332	this.hideHidden = hideHidden;
		333	}
		334
303	@Override	335	@Override
304	protected Node[] createNodes(Node node) {	336	protected Node[] createNodes(Node node) {
		337	org.openide.nodes.Children ch = Children.LEAF;
		338	DataObject obj = node.getLookup().lookup(DataObject.class);
305	if (hideHidden) {	339	if (hideHidden) {
306	DataObject obj = node.getCookie(DataObject.class);
307	if (obj != null && !VisibilityQuery.getDefault().isVisible(obj.getPrimaryFile())) {	340	if (obj != null && !VisibilityQuery.getDefault().isVisible(obj.getPrimaryFile())) {
308	return null;	341	return null;
309	}	342	}
310	}	343	}
		344
		345	DataFolder folder = node.getLookup().lookup(DataFolder.class);
		346	if (folder != null) {
		347	ch = new Chldrn(new FilterNode(node, folder.createNodeChildren(new VisQ())), true);
		348	} else {
		349	if (node.isLeaf()) {
		350	ch = org.openide.nodes.Children.LEAF;
		351	} else {
		352	ch = new Chldrn(node, true);
		353	}
		354	}
311		355
312	return new Node[] { new ProjectFilterNode (	356	return new Node[] { new ProjectFilterNode (node, ch) };
313	node,
314	(node.isLeaf ()) ? org.openide.nodes.Children.LEAF : new Chldrn (node, true)
315	)};
316	}
317
318	public void stateChanged(ChangeEvent e) {
319	MUTEX.postWriteRequest(this);
320	}
321
322	public void run() {
323	Node[] arr = original.getChildren().getNodes();
324	for (int i = 0; i < arr.length; i++) {
325	refreshKey(arr[i]);
326	}
327	}	357	}
328	} // end of Chldrn	358	} // end of Chldrn
329		359

Lines 85-90 Link Here

(-)a/favorites/test/unit/src/org/netbeans/modules/favorites/VisibilityQueryWorksTest.java (-1 / +6 lines)
85	/** If execution fails we wrap the exception with	85	/** If execution fails we wrap the exception with
86	* new log message.	86	* new log message.
87	*/	87	*/
		88	@Override
88	protected void runTest () throws Throwable {	89	protected void runTest () throws Throwable {
89	try {	90	try {
90	super.runTest ();	91	super.runTest ();
Lines 96-101 Link Here
96	}	97	}
97		98
98		99
		100	@Override
99	protected void setUp () throws Exception {	101	protected void setUp () throws Exception {
100	clearWorkDir();	102	clearWorkDir();
101		103
Lines 193-199 Link Here
193	VQI vqi = (VQI) Lookup.getDefault().lookup(VQI.class);	195	VQI vqi = (VQI) Lookup.getDefault().lookup(VQI.class);
194	vqi.showAll = true;	196	vqi.showAll = true;
195	vqi.fire();	197	vqi.fire();
196		198
		199	// initialize the children
		200	Node some = f.getChildren().findChild(null);
		201	assertNotNull("Some node needs to be found", some);
197	arr = f.getChildren().getNodes(true);	202	arr = f.getChildren().getNodes(true);
198	assertNodeForDataObject("hidden object is now there", hiddenDO, true, arr);	203	assertNodeForDataObject("hidden object is now there", hiddenDO, true, arr);
199	assertEquals("One child at all", 1, arr.length);	204	assertEquals("One child at all", 1, arr.length);

Lines 1-6 Link Here

(-)a/openide.loaders/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.openide.loaders	2	OpenIDE-Module: org.openide.loaders
3	OpenIDE-Module-Specification-Version: 7.2	3	OpenIDE-Module-Specification-Version: 7.3
4	OpenIDE-Module-Localizing-Bundle: org/openide/loaders/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/openide/loaders/Bundle.properties
5	OpenIDE-Module-Recommends: org.netbeans.modules.templates.v1_0	5	OpenIDE-Module-Recommends: org.netbeans.modules.templates.v1_0
6	AutoUpdate-Essential-Module: true	6	AutoUpdate-Essential-Module: true

Lines 41-46 Link Here

(-)a/openide.loaders/src/org/openide/loaders/DataFilter.java (+15 lines)
41		41
42	package org.openide.loaders;	42	package org.openide.loaders;
43		43
		44	import org.openide.filesystems.FileObject;
		45
44		46
45	/** Allows certain data objects to be excluded from being displayed.	47	/** Allows certain data objects to be excluded from being displayed.
46	* @see RepositoryNodeFactory	48	* @see RepositoryNodeFactory
Lines 61-64 Link Here
61	/** @deprecated Only public by accident. */	63	/** @deprecated Only public by accident. */
62	@Deprecated	64	@Deprecated
63	/* public static final */ long serialVersionUID = 0L;	65	/* public static final */ long serialVersionUID = 0L;
		66
		67	/** Additional interface that can be implemented by the {@link DataFilter}
		68	* implementors to do low level filtering based on the file objects.
		69	*/
		70	public interface Lowlevel extends DataFilter {
		71	/** Should this fileobject be considered for displaying?
		72	*
		73	* @param fo the file object
		74	* @return <CODE>true</CODE> if the object should be displayed,
		75	* <CODE>false</CODE> otherwise
		76	*/
		77	public boolean acceptFileObject(FileObject fo);
		78	}
64	}	79	}

Lines 152-157 Link Here

(-)a/openide.loaders/src/org/openide/loaders/FolderChildren.java (+6 lines)
152	Arrays.sort(arr, order);	152	Arrays.sort(arr, order);
153	List<FolderChildrenPair> positioned = new ArrayList<FolderChildrenPair>(arr.length);	153	List<FolderChildrenPair> positioned = new ArrayList<FolderChildrenPair>(arr.length);
154	for (FileObject fo : FileUtil.getOrder(Arrays.asList(arr), false)) {	154	for (FileObject fo : FileUtil.getOrder(Arrays.asList(arr), false)) {
		155	if (filter instanceof DataFilter.Lowlevel) {
		156	DataFilter.Lowlevel f =(DataFilter.Lowlevel)filter;
		157	if (!f.acceptFileObject(fo)) {
		158	continue;
		159	}
		160	}
155	positioned.add(new FolderChildrenPair(fo));	161	positioned.add(new FolderChildrenPair(fo));
156	}	162	}
157		163




import java.io.IOException;
import java.util.*;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.event.ChangeEvent;

import org.netbeans.junit.NbTestCase;
import org.netbeans.junit.NbTestSuite;
import org.netbeans.junit.RandomlyFails;
import org.netbeans.spi.queries.VisibilityQueryImplementation;
import org.openide.filesystems.*;

import org.openide.loaders.DefaultDataObjectTest.JspLoader;
import org.openide.loaders.MultiDataObject.Entry;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Node;
import org.openide.nodes.Children;
import org.openide.nodes.FilterNode;
import org.openide.nodes.NodeEvent;
import org.openide.nodes.NodeListener;
import org.openide.nodes.NodeMemberEvent;


    public static Test suite() {
        Test t = null;
//        t = new FolderChildrenTest("testALotOfHiddenEntries");
        if (t == null) {
            t = new NbTestSuite(FolderChildrenTest.class);
        }

        assertNodes( arr, new String[] { "A" } );
    }

    public void testALotOfHiddenEntries() throws Exception {
        FileSystem fs = Repository.getDefault ().getDefaultFileSystem();
        FileObject folder = FileUtil.createFolder(fs.getRoot(), "aLotOf");
        List<FileObject> arr = new ArrayList<FileObject>();
        final int FILES = 1000;
        for (int i = 0; i < FILES; i++) {
            arr.add(FileUtil.createData(folder, "" + i + ".dat"));
        }

        DataFolder df = DataFolder.findFolder(folder);

        VisQ visq = new VisQ();

        FilterNode fn = new FilterNode(new FilterNode(new AbstractNode(df.createNodeChildren(visq))));
        class L implements NodeListener {
            int cnt;

            public void childrenAdded(NodeMemberEvent ev) {
                cnt++;
            }

            public void childrenRemoved(NodeMemberEvent ev) {
                cnt++;
            }

            public void childrenReordered(NodeReorderEvent ev) {
                cnt++;
            }

            public void nodeDestroyed(NodeEvent ev) {
                cnt++;
            }

            public void propertyChange(PropertyChangeEvent evt) {
                cnt++;
            }
        }
        L listener = new L();
        fn.addNodeListener(listener);

        List<Node> nodes = new ArrayList<Node>();
        int cnt = fn.getChildren().getNodesCount(true);
        List<Node> snapshot = fn.getChildren().snapshot();
        assertEquals("Count as expected", cnt, snapshot.size());
        for (int i = 0; i < cnt; i++) {
            nodes.add(snapshot.get(i));
        }
        assertEquals("No events delivered", 0, listener.cnt);
        assertEquals("Size is half cut", FILES / 2, fn.getChildren().getNodesCount(true));
    }

    public static final class VisQ implements VisibilityQueryImplementation, DataFilter.Lowlevel {
        public boolean isVisible(FileObject file) {
            try {
                int number = Integer.parseInt(file.getName());
                return number % 2 == 0;
            } catch (NumberFormatException numberFormatException) {
                return true;
            }
        }

        public void addChangeListener(ChangeListener l) {
        }

        public void removeChangeListener(ChangeListener l) {
        }

        public boolean acceptDataObject(DataObject obj) {
            return isVisible(obj.getPrimaryFile());
        }

        public boolean acceptFileObject(FileObject obj) {
            return isVisible(obj);
        }

    }


    public static final class Pool extends DataLoaderPool {
        private static Class<? extends DataLoader> loader;


Return to bug 150747

Lines 47-52 Link Here

(-)a/openide.loaders/test/unit/src/org/openide/loaders/FolderChildrenTest.java (-1 / +83 lines)
47	import java.io.IOException;	47	import java.io.IOException;
48	import java.util.*;	48	import java.util.*;
49	import java.lang.ref.WeakReference;	49	import java.lang.ref.WeakReference;
		50	import java.util.ArrayList;
50	import java.util.logging.Level;	51	import java.util.logging.Level;
51	import java.util.logging.Logger;	52	import java.util.logging.Logger;
52	import javax.swing.event.ChangeEvent;	53	import javax.swing.event.ChangeEvent;
Lines 58-69 Link Here
58	import org.netbeans.junit.NbTestCase;	59	import org.netbeans.junit.NbTestCase;
59	import org.netbeans.junit.NbTestSuite;	60	import org.netbeans.junit.NbTestSuite;
60	import org.netbeans.junit.RandomlyFails;	61	import org.netbeans.junit.RandomlyFails;
		62	import org.netbeans.spi.queries.VisibilityQueryImplementation;
61	import org.openide.filesystems.*;	63	import org.openide.filesystems.*;
62		64
63	import org.openide.loaders.DefaultDataObjectTest.JspLoader;	65	import org.openide.loaders.DefaultDataObjectTest.JspLoader;
64	import org.openide.loaders.MultiDataObject.Entry;	66	import org.openide.loaders.MultiDataObject.Entry;
		67	import org.openide.nodes.AbstractNode;
65	import org.openide.nodes.Node;	68	import org.openide.nodes.Node;
66	import org.openide.nodes.Children;	69	import org.openide.nodes.Children;
		70	import org.openide.nodes.FilterNode;
67	import org.openide.nodes.NodeEvent;	71	import org.openide.nodes.NodeEvent;
68	import org.openide.nodes.NodeListener;	72	import org.openide.nodes.NodeListener;
69	import org.openide.nodes.NodeMemberEvent;	73	import org.openide.nodes.NodeMemberEvent;
Lines 95-101 Link Here
95		99
96	public static Test suite() {	100	public static Test suite() {
97	Test t = null;	101	Test t = null;
98	// t = new FolderChildrenTest("testDeadlockWithChildrenMutex");	102	// t = new FolderChildrenTest("testALotOfHiddenEntries");
99	if (t == null) {	103	if (t == null) {
100	t = new NbTestSuite(FolderChildrenTest.class);	104	t = new NbTestSuite(FolderChildrenTest.class);
101	}	105	}
Lines 732-737 Link Here
732	assertNodes( arr, new String[] { "A" } );	736	assertNodes( arr, new String[] { "A" } );
733	}	737	}
734		738
		739	public void testALotOfHiddenEntries() throws Exception {
		740	FileSystem fs = Repository.getDefault ().getDefaultFileSystem();
		741	FileObject folder = FileUtil.createFolder(fs.getRoot(), "aLotOf");
		742	List<FileObject> arr = new ArrayList<FileObject>();
		743	final int FILES = 1000;
		744	for (int i = 0; i < FILES; i++) {
		745	arr.add(FileUtil.createData(folder, "" + i + ".dat"));
		746	}
		747
		748	DataFolder df = DataFolder.findFolder(folder);
		749
		750	VisQ visq = new VisQ();
		751
		752	FilterNode fn = new FilterNode(new FilterNode(new AbstractNode(df.createNodeChildren(visq))));
		753	class L implements NodeListener {
		754	int cnt;
		755
		756	public void childrenAdded(NodeMemberEvent ev) {
		757	cnt++;
		758	}
		759
		760	public void childrenRemoved(NodeMemberEvent ev) {
		761	cnt++;
		762	}
		763
		764	public void childrenReordered(NodeReorderEvent ev) {
		765	cnt++;
		766	}
		767
		768	public void nodeDestroyed(NodeEvent ev) {
		769	cnt++;
		770	}
		771
		772	public void propertyChange(PropertyChangeEvent evt) {
		773	cnt++;
		774	}
		775	}
		776	L listener = new L();
		777	fn.addNodeListener(listener);
		778
		779	List<Node> nodes = new ArrayList<Node>();
		780	int cnt = fn.getChildren().getNodesCount(true);
		781	List<Node> snapshot = fn.getChildren().snapshot();
		782	assertEquals("Count as expected", cnt, snapshot.size());
		783	for (int i = 0; i < cnt; i++) {
		784	nodes.add(snapshot.get(i));
		785	}
		786	assertEquals("No events delivered", 0, listener.cnt);
		787	assertEquals("Size is half cut", FILES / 2, fn.getChildren().getNodesCount(true));
		788	}
		789
		790	public static final class VisQ implements VisibilityQueryImplementation, DataFilter.Lowlevel {
		791	public boolean isVisible(FileObject file) {
		792	try {
		793	int number = Integer.parseInt(file.getName());
		794	return number % 2 == 0;
		795	} catch (NumberFormatException numberFormatException) {
		796	return true;
		797	}
		798	}
		799
		800	public void addChangeListener(ChangeListener l) {
		801	}
		802
803	public void removeChangeListener(ChangeListener l) {
804	}
805
806	public boolean acceptDataObject(DataObject obj) {
807	return isVisible(obj.getPrimaryFile());
808	}
809
810	public boolean acceptFileObject(FileObject obj) {
811	return isVisible(obj);
812	}
813
814	}
815
816
735	public static final class Pool extends DataLoaderPool {	817	public static final class Pool extends DataLoaderPool {
736	private static Class<? extends DataLoader> loader;	818	private static Class<? extends DataLoader> loader;
737		819