diff -r e1eef78d4555 masterfs/src/org/netbeans/modules/masterfs/filebasedfs/fileobjects/FileObjectKeeper.java
--- a/masterfs/src/org/netbeans/modules/masterfs/filebasedfs/fileobjects/FileObjectKeeper.java	Wed Apr 04 17:25:52 2012 +0200
+++ b/masterfs/src/org/netbeans/modules/masterfs/filebasedfs/fileobjects/FileObjectKeeper.java	Thu Apr 05 20:50:50 2012 +0200
@@ -43,6 +43,7 @@
 package org.netbeans.modules.masterfs.filebasedfs.fileobjects;
 
 import java.io.File;
+import java.io.FileFilter;
 import java.io.IOException;
 import java.util.Collection;
 import java.util.HashSet;
@@ -86,10 +87,16 @@
         LOG.log(Level.FINEST, "addRecursiveListener for {0} isEmpty: {1}", new Object[]{root, listeners.isEmpty()});
         if (listeners.isEmpty()) {
             Callable<?> stop = null;
-            if (fcl instanceof Callable && fcl.getClass().getName().equals("org.openide.filesystems.DeepListener")) { // NOI18N
+            final boolean deepClass = fcl.getClass().getName().equals("org.openide.filesystems.DeepListener"); // NOI18N
+            if (fcl instanceof Callable && deepClass) {
                 stop = (Callable<?>)fcl;
             }
-            listenToAll(stop);
+            FileFilter filter = null;
+            if (fcl instanceof FileFilter && deepClass) {
+                filter = (FileFilter)fcl;
+            }
+            
+            listenToAll(stop, filter);
         }
         listeners.add(fcl);
     }
@@ -180,7 +187,7 @@
         }
     }
 
-    private void listenToAll(Callable<?> stop) {
+    private void listenToAll(Callable<?> stop, FileFilter filter) {
         assert Thread.holdsLock(this);
         assert kept == null : "Already listening to " + kept + " now requested for " + root;
         kept = new HashSet<FolderObj>();
@@ -200,6 +207,9 @@
             LOG.log(Level.FINEST, "listenToAll, check {0} for stop {1}", new Object[] { fo, stop });
             if (fo instanceof FolderObj) {
                 FolderObj obj = (FolderObj) fo;
+                if (filter != null && !filter.accept(obj.getFileName().getFile())) {
+                    continue;
+                }
                 Object shallStop = null;
                 if (stop != null) {
                     try {
diff -r e1eef78d4555 masterfs/test/unit/src/org/netbeans/modules/masterfs/filebasedfs/FileUtilAddRecursiveListenerFilterTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/masterfs/test/unit/src/org/netbeans/modules/masterfs/filebasedfs/FileUtilAddRecursiveListenerFilterTest.java	Thu Apr 05 20:50:50 2012 +0200
@@ -0,0 +1,165 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2010 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+ * Other names may be trademarks of their respective owners.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, 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-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License.  When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ *
+ * Contributor(s):
+ *
+ * Portions Copyrighted 2010 Sun Microsystems, Inc.
+ */
+
+package org.netbeans.modules.masterfs.filebasedfs;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.netbeans.junit.NbTestCase;
+import org.openide.filesystems.FileAttributeEvent;
+import org.openide.filesystems.FileChangeListener;
+import org.openide.filesystems.FileEvent;
+import org.openide.filesystems.FileObject;
+import org.openide.filesystems.FileRenameEvent;
+import org.openide.filesystems.FileUtil;
+
+/**
+ *
+ * @author Jaroslav Tulach <jtulach@netbeans.org>
+ */
+public class FileUtilAddRecursiveListenerFilterTest extends NbTestCase
+implements FileChangeListener {
+    private FileObject root;
+    private List<FileEvent> events = new ArrayList<FileEvent>();
+    @SuppressWarnings("NonConstantLogger")
+    private Logger LOG;
+
+    public FileUtilAddRecursiveListenerFilterTest(String n) {
+        super(n);
+    }
+
+    @Override
+    protected Level logLevel() {
+        return Level.FINEST;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        clearWorkDir();
+        
+        LOG = Logger.getLogger("test." + getName());
+        
+        root = FileUtil.toFileObject(getWorkDir());
+        assertNotNull("Root found", root);
+
+        for (int i = 0; i < 10; i++) {
+            if (i % 2 == 0) {
+                root.createData("" + i, "txt");
+            } else {
+                root.createFolder("" + i);
+            }
+        }
+    }
+
+    public void testAddListenerGetsFiveCallbacks() throws IOException {
+        class AtMostFive implements FileFilter {
+            @Override
+            public boolean accept(File pathname) {
+                assertTrue("It is folder", pathname.isDirectory());
+                int number = Integer.parseInt(pathname.getName());
+                return number <= 5;
+            }
+            
+        }
+        
+        FileUtil.addRecursiveListener(this, getWorkDir(), new AtMostFive(), null);
+
+        File fifthChild = new File(new File(getWorkDir(), "5"), "new.5.txt");
+        assertTrue(fifthChild.createNewFile());
+        FileUtil.refreshFor(getWorkDir());
+        assertEquals("One event delivered: " + events, 1, events.size());
+        
+        File seventhChild = new File(new File(getWorkDir(), "7"), "new.7.txt");
+        assertTrue(seventhChild.createNewFile());
+        FileUtil.refreshFor(getWorkDir());
+        assertEquals("No other even delivered: " + events, 1, events.size());
+    }
+
+    @Override
+    public void fileFolderCreated(FileEvent fe) {
+        LOG.log(Level.INFO, "fileFolderCreated: {0}", fe.getFile());
+        LOG.log(Level.INFO, "Thread dump", new Exception());
+        events.add(fe);
+    }
+
+    @Override
+    public void fileDataCreated(FileEvent fe) {
+        LOG.log(Level.INFO, "fileDataCreated: {0}", fe.getFile());
+        LOG.log(Level.INFO, "Thread dump", new Exception());
+        events.add(fe);
+    }
+
+    @Override
+    public void fileChanged(FileEvent fe) {
+        LOG.log(Level.INFO, "fileChanged: {0}", fe.getFile());
+        LOG.log(Level.INFO, "Thread dump", new Exception());
+        events.add(fe);
+    }
+
+    @Override
+    public void fileDeleted(FileEvent fe) {
+        LOG.log(Level.INFO, "fileDeleted: {0}", fe.getFile());
+        LOG.log(Level.INFO, "Thread dump", new Exception());
+        events.add(fe);
+    }
+
+    @Override
+    public void fileRenamed(FileRenameEvent fe) {
+        LOG.log(Level.INFO, "fileRenamed: {0}", fe.getFile());
+        LOG.log(Level.INFO, "Thread dump", new Exception());
+        events.add(fe);
+    }
+
+    @Override
+    public void fileAttributeChanged(FileAttributeEvent fe) {
+        LOG.log(Level.INFO, "fileAttributeChanged: {0}", fe.getFile());
+        LOG.log(Level.INFO, "Thread dump", new Exception());
+        events.add(fe);
+    }
+
+}
diff -r e1eef78d4555 openide.filesystems/src/org/openide/filesystems/DeepListener.java
--- a/openide.filesystems/src/org/openide/filesystems/DeepListener.java	Wed Apr 04 17:25:52 2012 +0200
+++ b/openide.filesystems/src/org/openide/filesystems/DeepListener.java	Thu Apr 05 20:50:50 2012 +0200
@@ -43,6 +43,7 @@
 package org.openide.filesystems;
 
 import java.io.File;
+import java.io.FileFilter;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -59,18 +60,20 @@
  * @author Jaroslav Tulach <jtulach@netbeans.org>
  */
 final class DeepListener extends WeakReference<FileChangeListener>
-implements FileChangeListener, Runnable, Callable<Boolean> {
+implements FileChangeListener, Runnable, Callable<Boolean>, FileFilter {
     private static final Logger LOG = Logger.getLogger(DeepListener.class.getName());
     private final File path;
     private FileObject watching;
     private boolean removed;
     private final Callable<Boolean> stop;
+    private final FileFilter filter;
     private static List<DeepListener> keep = new ArrayList<DeepListener>();
 
-    DeepListener(FileChangeListener listener, File path, Callable<Boolean> stop) {
+    DeepListener(FileChangeListener listener, File path, FileFilter ff, Callable<Boolean> stop) {
         super(listener, Utilities.activeReferenceQueue());
         this.path = path;
         this.stop = stop;
+        this.filter = ff;
         keep.add(this);
     }
     
@@ -227,4 +230,9 @@
     public Boolean call() throws Exception {
         return stop != null ? stop.call() : null;
     }
+
+    @Override
+    public boolean accept(File pathname) {
+        return filter == null || filter.accept(pathname);
+    }
 }
diff -r e1eef78d4555 openide.filesystems/src/org/openide/filesystems/FileUtil.java
--- a/openide.filesystems/src/org/openide/filesystems/FileUtil.java	Wed Apr 04 17:25:52 2012 +0200
+++ b/openide.filesystems/src/org/openide/filesystems/FileUtil.java	Thu Apr 05 20:50:50 2012 +0200
@@ -331,9 +331,7 @@
      * @since org.openide.filesystems 7.28
      */
     public static void addRecursiveListener(FileChangeListener listener, File path) {
-        final DeepListener deep = new DeepListener(listener, path, null);
-        deep.init();
-        addFileChangeListener(deep, path);
+        addRecursiveListener(listener, path, null, null);
     }
 
     /**
@@ -380,7 +378,17 @@
      * @since org.openide.filesystems 7.37
      */
     public static void addRecursiveListener(FileChangeListener listener, File path, Callable<Boolean> stop) {
-        final DeepListener deep = new DeepListener(listener, path, stop);
+        addRecursiveListener(listener, path, null, stop);
+    }
+
+    /** XXX: Only for java.io.File, but that is probably OK for NetBeans IDE 7.2
+     * XXX: Copy javadoc
+     * 
+     * @param recurseInto a file filter that may return <code>false</code> when
+     *   a folder should not be traversed into and external changes in it ignored
+     */
+    public static void addRecursiveListener(FileChangeListener listener, File path, FileFilter recurseInto, Callable<Boolean> stop) {
+        final DeepListener deep = new DeepListener(listener, path, recurseInto, stop);
         deep.init();
         addFileChangeListener(deep, path);
     }
@@ -395,7 +403,7 @@
      * @since org.openide.filesystems 7.28
      */
     public static void removeRecursiveListener(FileChangeListener listener, File path) {
-        final DeepListener deep = new DeepListener(listener, path, null);
+        final DeepListener deep = new DeepListener(listener, path, null, null);
         // no need to deep.init()
         DeepListener dl = (DeepListener)removeFileChangeListenerImpl(deep, path);
         dl.run();