private void diskChange(FileEvent fe) {
    boolean writing = false;
    if (fe != null) {
        synchronized (saveActions) {
            for (AtomicAction a : saveActions) {
                if (fe.firedFrom(a)) {
                    writing = true;
                    break;
                }
            }
        }
    }
    if (!writing) {
        loaded = false;
        reloadedStackTrace = new Throwable("noticed disk change here");
    }
    fireChange();
    if (!writing) {
        helper.fireExternalChange(path);
    }
}
 

/**
 * Test of delete method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
 */
public void testDelete() throws IOException {
    File f = testFile;
    
    FileObject testFo = FileBasedFileSystem.getFileObject(testFile);
    assertNotNull(testFo);
    
    final List<FileEvent> l = new ArrayList<FileEvent>();
    FileChangeListener fcl = new FileChangeAdapter () {
        @Override
        public void fileDeleted(FileEvent fe) {
            l.add(fe);
        }            
    };
    FileObject fo = FileUtil.createData(testFo, "delete/the/whole/structure/in/depth/todelete.txt");
    fo.addFileChangeListener(fcl);
    
    FileObject toDelete = testFo.getFileObject("delete");        
    assertNotNull(toDelete);
    toDelete.addFileChangeListener(fcl);

    FileObject toGC = testFo.getFileObject("delete/the/whole/structure");
    assertNotNull(toGC);
    Reference<FileObject> toGCRef = new WeakReference<FileObject>(toGC);
    toGC.addFileChangeListener(fcl);
    toGC = null;
    
    assertGC("", toGCRef);
    toDelete.delete();
    assertEquals(0,testFo.getChildren().length);
    toDelete = testFo.getFileObject("delete");        
    assertNull(toDelete);        
    assertEquals(2, l.size());
}
 

@Override
public void fileChanged(FileEvent fe) {
    FileObject file = fe.getFile();
    if (!isVisible(file)) {
        return;
    }
    browserReload(file);
    processChange(file);
}
 

private RemotePlatformProvider(@NonNull final XMLDataObject store) {
    Parameters.notNull("store", store); //NOI18N
    this.store = store;
    this.store.getPrimaryFile().addFileChangeListener(new FileChangeAdapter(){
        @Override
        public void fileDeleted(@NonNull final FileEvent fe) {
            final String systemName = fe.getFile().getName();
            try {
                ProjectManager.mutex().writeAccess( new Mutex.ExceptionAction<Void> () {
                    @Override
                    public Void run () throws IOException {
                        final String propPrefix =  String.format("platforms.%s.", systemName);   //NOI18N
                        boolean changed = false;
                        final EditableProperties props = PropertyUtils.getGlobalProperties();
                        for (Iterator<String> it = props.keySet().iterator(); it.hasNext(); ) {
                            final String key = it.next ();
                            if (key.startsWith(propPrefix)) {
                                it.remove();
                                changed =true;
                            }
                        }
                        if (changed) {
                            PropertyUtils.putGlobalProperties(props);
                        }
                        return null;
                    }
                });
            } catch (MutexException e) {
                Exceptions.printStackTrace(e);
            }
            ConnectionMethod.Authentification.clear(systemName);
        }
    });
    final InstanceContent c = new InstanceContent();
    c.add(Node.class, this);
    c.add(this);
    this.lkp = new AbstractLookup(c);
    task = RP.create(this);
}
 

private void handleInvalidDataObject(DataObject invalidDO) {
    invalidDO.removePropertyChangeListener(wlistener);
    if (fobj.isValid()) {
        // file object still exists try to find new data object
        try {
            dobj = DataObject.find(fobj);
            dobj.addPropertyChangeListener(wlistener);
            flisten.fileChanged(new FileEvent(fobj));
        } catch (IOException ex) {
            // should not occur
            LOG.log(Level.SEVERE, ex.getMessage(), ex);
        }
    }
}
 

public void fileChanged(FileEvent e) {
    FileObject fo = e.getFile();
    if (isTarget(fo)) {
        fo.refresh(true);
        targetChanged(fo);
    }
}
 

private boolean isCandidateForProcessing(FileEvent event) {
  FileObject file = event.getFile();

  boolean applyRules = false;
  boolean isntFolder = !file.isFolder();
  boolean isUnexpected = !event.isExpected();
  boolean isntSkipped = !SmartSkip.skipDirectory(file);

  if (isUnexpected && isntFolder && isntSkipped) {
    applyRules = true;
  }

  return applyRules;
}
 

@Override
public void fileDeleted(FileEvent fe) {
    final ClasspathInfo info = ClasspathInfo.create(
        ClassPath.EMPTY,
        ClassPath.EMPTY,
        sources);
    final Set<ElementHandle<ModuleElement>> mods = info.getClassIndex().getDeclaredModules(
            "", //NOI18N
            ClassIndex.NameKind.PREFIX,
            EnumSet.of(ClassIndex.SearchScope.SOURCE));
    if (mods.isEmpty()) {
        resetOutsideWriteAccess(null, PROP_RESOURCES);
    }
}
 

protected void register(String eventKind, FileEvent fe) {
    String src = stripPrefix(((FileObject) fe.getSource()).getPath());
    String obj = stripPrefix(fe.getFile().getPath());
    String exp = checkExpected ? ("exp=" + Boolean.toString(fe.isExpected())) : "";
    String extra = "";
    if (fe instanceof FileRenameEvent) {
        FileRenameEvent fre = (FileRenameEvent) fe;
        extra = "oldName="+fre.getName()+" oldExt="+fre.getExt();
    }
    out.printf("%-20s: %-20s SRC %-20s OBJ %-20s %s %s\n", listenerName, eventKind, src, obj, exp, extra);
}
 

@Override
public void fileChanged(FileEvent fe) {
    checkPreprocessors(fe.getFile());
    try {
        if (!handleResource(fe)) {
            handleCopyFileToDestDir(fe.getFile());
        }
    } catch (IOException e) {
        LOGGER.log(Level.INFO, null, e);
    }
}
 

@Override
        public void fileChanged(FileEvent fileEvent) {
                if (lastTime < fileEvent.getTime()) {
                    lastTime = System.currentTimeMillis();
//                    System.out.println("fired based on " + fileEvent.getFile() + fileEvent.getTime());
                    NbMavenProject.fireMavenProjectReload(NbMavenProjectImpl.this);
                }
        }
 

private void changed(FileEvent fe) {
    //System.err.println("changed on disk in " + Thread.currentThread().getName() + " for " + this);
    //Thread.dumpStack();
    synchronized (this) {
        if (fe.firedFrom(this)) {
            //System.err.println("(my own change)");
            return;
        }
        problem = null;
        dirty = false;
        root = null;
    }
    pcs.firePropertyChange(PROP_DOCUMENT_ROOT, null, null);
}
 

private void fileDeletedImpl(final FileEvent fe) {
    Project owning = getOwningMavenProject(fe.getFile());
    if (owning == null) {
        return;
    }
    try {
        handleDeleteFileInDestDir(fe.getFile(), null, owning);
    } catch (IOException ex) {
        LOG.log(Level.INFO, null, ex);
    }
}
 

public void fileDeleted(FileEvent fe) {
    changed();
}
 

@Override
public void fileDataCreated(FileEvent fe) {
    invalidate();
}
 

@Override
public void fileChanged(FileEvent fe) {
    showWaitNode();
    RequestProcessor.getDefault().post(POMInheritancePanel.this);
}
 

@Override
public void fileFolderCreated(FileEvent fe) {
    fireChange();
}
 

@Override
public void fileDataCreated(FileEvent fe) {
    reset();
}
 

@Override
public void fileDataCreated(FileEvent fe) {
    fireChange();
}
 

public void fileDeleted(FileEvent fe) {
    change(fe);
}
 

@Override
public void fileChanged(FileEvent fe) {
}
 

@Override
public void fileFolderCreated(FileEvent event) {
  super.fileFolderCreated(event);
  LOG.log(Level.FINE, "[EC for {0}] Created folder: {1}", new Object[]{editorConfigFileObject.getPath(), event.getFile().getPath()});
  //TODO search for editor-configs and attach listeners
}
 

@Override
public void fileDataCreated(FileEvent fe) {
    reset();
}
 

@Override
public void fileFolderCreated(FileEvent fe) {
    //Not important
}
 

@Override
public void fileDeleted(FileEvent fe) {}
 

@Override
public void fileFolderCreated(FileEvent fe) {
    invalidate();
}
 

public void fileChanged(FileEvent fe) {
    change(fe);
}
 

@Override
public void fileChanged(FileEvent fe) {
    assert (fe.getSource() == destinationsFO);
    destinationServiceModel = null;
}
 

public @Override void fileDeleted(FileEvent fe) {
    refreshKeys();
}
 

public void testSaveOnPropertyChange() throws Exception {
    DatabaseConnection dbconn = new DatabaseConnection("a", "b", "c", "d", "e", (String) null);
    FileObject fo = DatabaseConnectionConvertor.create(dbconn).getPrimaryFile();
    
    class FCL extends FileChangeAdapter {
        
        private final CountDownLatch latch = new CountDownLatch(1);
        
        @Override
        public void fileChanged(FileEvent fe) {
            latch.countDown();
        }
        
        public void await() throws InterruptedException {
            latch.await();
        }
    }
    
    FCL fcl = new FCL();
    fo.addFileChangeListener(fcl);
    
    dbconn.setDriver("org.bar.BarDriver");
    dbconn.setDriverName("bar_driver");
    dbconn.setDatabase("jdbc:bar:localhost");
    dbconn.setSchema("schema");
    dbconn.setUser("user");
    dbconn.setPassword("password");
    dbconn.setRememberPassword(true);
    
    fcl.await();
    
    ErrorHandlerImpl errHandler = new ErrorHandlerImpl();
    Document doc = null;
    InputStream input = fo.getInputStream();
    try {
        doc = XMLUtil.parse(new InputSource(input), true, true, errHandler, EntityCatalog.getDefault());
    } finally {
        input.close();
    }
    
    assertFalse("Error while parsing XML", errHandler.error);
    errHandler = new ErrorHandlerImpl();
    Document goldenDoc = null;
    input = getClass().getResourceAsStream("bar-connection.xml");
    try {
        goldenDoc = XMLUtil.parse(new InputSource(input), true, true, errHandler, EntityCatalog.getDefault());
    } finally {
        input.close();
    }
    
    assertTrue(DOMCompare.compareDocuments(doc, goldenDoc));
    assertFalse("Error while parsing XML", errHandler.error);
}