@Override public Enumeration<? extends FileObject> getChildren(boolean rec) { return fileObj.getChildren(rec); }
public FileObject[] getChildren() { return fileObj.getChildren(); }
private void addAll(FileObject folder) { if (kept != null) { kept.add(folder); Enumeration<? extends FileObject> en = folder.getChildren(true); while (en.hasMoreElements()) { FileObject fo = en.nextElement(); kept.add(fo); } } }
/** Finds all hidden files on given filesystem. The methods scans all files for * ones with hidden extension and returns enumeration of names of files * that are hidden. * * @param folder folder to start at * @param rec proceed recursivelly * @return enumeration of String with names of hidden files */ protected static Enumeration<String> hiddenFiles(FileObject folder, boolean rec) { Enumeration<? extends FileObject> allFiles = folder.getChildren(rec); class OnlyHidden implements Enumerations.Processor<FileObject, String> { public @Override String process(FileObject obj, Collection<FileObject> ignore) { String sf = obj.getPath(); if (sf.endsWith(MASK)) { return sf.substring(0, sf.length() - MASK.length()); } else { return null; } } } return Enumerations.filter(allFiles, new OnlyHidden()); }
/** Lists registered MIMEResolver instances in reverse order, * i.e. first are ones with lower priority (position attribute higher) * and last are ones with highest prority (position attribute lower). * @return list of all registered MIMEResolver instances in reverse order */ public static Collection<? extends FileObject> getOrderedResolvers() { // scan resolvers and order them to be able to assign extension to mime type from resolver with the lowest position FileObject[] resolvers = FileUtil.getConfigFile(MIME_RESOLVERS_PATH).getChildren(); TreeMap<Integer, FileObject> orderedResolvers = new TreeMap<Integer, FileObject>(Collections.reverseOrder()); for (FileObject mimeResolverFO : resolvers) { Integer position = (Integer) mimeResolverFO.getAttribute("position"); //NOI18N if (position == null) { position = Integer.MAX_VALUE; } while (orderedResolvers.containsKey(position)) { position--; } orderedResolvers.put(position, mimeResolverFO); } return orderedResolvers.values(); }
/** Enumerate the subfolders of this folder. * @param rec whether to recursively list subfolders * @return enumeration of type <code>FileObject</code> (satisfying {@link #isFolder}) */ public Enumeration<? extends FileObject> getFolders(boolean rec) { return Enumerations.filter(getChildren(rec), new OnlyFolders(true)); }
/** Enumerate all data files in this folder. * @param rec whether to recursively search subfolders * @return enumeration of type <code>FileObject</code> (satisfying {@link #isData}) */ public Enumeration<? extends FileObject> getData(boolean rec) { return Enumerations.filter(getChildren(rec), new OnlyFolders(false)); }
StringBuffer buff = new StringBuffer(150); StringBuffer lit = new StringBuffer(15); FileObject[] fobia = folder.getChildren(); String name;
/** Returns FileObject representing declarative user defined MIME resolver * or null if not yet created. * @return FileObject representing declarative user defined MIME resolver * or null if not yet created. */ public static FileObject getUserDefinedResolver() { FileObject resolversFolder = FileUtil.getConfigFile(MIME_RESOLVERS_PATH); if (resolversFolder != null) { FileObject[] resolvers = resolversFolder.getChildren(); for (FileObject resolverFO : resolvers) { if (resolverFO.getAttribute(USER_DEFINED_MIME_RESOLVER) != null) { return resolverFO; } } } return null; }
public static List<FileFilter> findRegisteredFileFilters() { List<FileFilter> filters = new LinkedList<FileFilter>(); FileObject root = FileUtil.getConfigFile( "Services/MIMEResolver"); //NOI18N Map<String, Set<FileObject>> filterNameToResolversMap = new HashMap<String, Set<FileObject>>(); for (FileObject child : root.getChildren()) { if (child.isFolder()) { continue; } int i = 0; String f; while ((f = (String) child.getAttribute("fileChooser." + i))//NOI18N != null) { Set<FileObject> set = filterNameToResolversMap.get(f); if (set == null) { set = new HashSet<FileObject>(); filterNameToResolversMap.put(f, set); } set.add(child); i++; } } for (Map.Entry<String, Set<FileObject>> e : filterNameToResolversMap.entrySet()) { filters.add(createFilter(e.getKey(), e.getValue())); } return sortFiltersByDescription(filters); }
FileObject[] arr = folder.getChildren(); Properties local = null;
void locateCurrent() { FileObject oldCurrent = current; currentF = FileUtil.normalizeFile(path); while (true) { current = FileUtil.toFileObject(currentF); if (current != null) { isOnTarget = path.equals(currentF); break; } currentF = currentF.getParentFile(); if (currentF == null) { // #47320: can happen on Windows in case the drive does not exist. // (Inside constructor for Holder.) In that case skip it. return; } } assert current != null; if (current != oldCurrent) { if (oldCurrent != null) { oldCurrent.removeFileChangeListener(this); } current.addFileChangeListener(this); current.getChildren(); //to get events about children } }
private static synchronized List<MIMEResolver> declarativeResolvers() { List<MIMEResolver> declmimes = new ArrayList<MIMEResolver>(); if (declarativeFolder == null) { declarativeFolder = FileUtil.getConfigFile("Services/MIMEResolver"); // NOI18N } if (declarativeFolder != null) { for (FileObject f : Ordering.getOrder(Arrays.asList(declarativeFolder.getChildren()), true)) { if (f.hasExt("xml")) { // NOI18N try { // For now, just assume it has the right DTD. Could check this if desired. declmimes.add(MIMEResolverImpl.forDescriptor(f)); // NOI18N } catch (IOException ex) { Exceptions.printStackTrace(ex); } } } declarativeFolder.removeFileChangeListener(weakDeclarativeFolderListener); declarativeFolder.addFileChangeListener(weakDeclarativeFolderListener); } return declmimes; }
delegates.add(lkp); if (fo != null) { for (FileObject f : fo.getChildren()) { if (f.isFolder()) { delegates.add(new OverFiles(f.getPath()));
return Collections.emptyList(); FileObject[] ch = writableFolder.getChildren(); int sl = systems.length;
if ((Utilities.isWindows() || (Utilities.getOperatingSystem() == Utilities.OS_OS2)) || Utilities.isMac()) { Enumeration<? extends FileObject> en = fo.getChildren(false);
return Enumerations.queue(Enumerations.array(getChildren()), new WithChildren());
/** Copies this file. This allows the filesystem to perform any additional * operation associated with the copy. But the default implementation is simple * copy of the file and its attributes * * @param target target folder to move this file to * @param name new basename of file * @param ext new extension of file (ignored for folders) * @return the newly created file object representing the moved file */ public FileObject copy(FileObject target, String name, String ext) throws IOException { if (isFolder()) { if (FileUtil.isParentOf(this, target)) { throw new FSException(NbBundle.getMessage(FileObject.class, "EXC_OperateChild", this, target)); // NOI18N } FileObject peer = target.createFolder(name); FileUtil.copyAttributes(this, peer); for (FileObject fo : getChildren()) { fo.copy(peer, fo.getName(), fo.getExt()); } return peer; } FileObject dest = FileUtil.copyFileImpl(this, target, name, ext); return dest; }
/** Copies content of one folder into another. * @param source source folder * @param target target folder * @exception IOException if it fails */ private static void copyContent(FileObject source, FileObject target) throws IOException { FileObject[] srcArr = source.getChildren(); copyAttrs(source, target); //added for (int i = 0; i < srcArr.length; i++) { FileObject child = srcArr[i]; if (MultiFileSystem.isMaskFile(child)) { continue; } if (target.getFileObject(child.getName(), child.getExt()) == null) { if (child.isData()) { FileObject fo = FileUtil.copyFile(child, target, child.getName(), child.getExt()); if (fo != null) { copyAttrs(child, fo); } } else { FileObject targetChild = target.createFolder(child.getName()); copyContent(child, targetChild); } } } }
private static FileObject findMatchingChild(String sourceFileName, Collection<FileObject> folders, boolean caseSensitive) { final Match matchSet = caseSensitive ? new CaseSensitiveMatch(sourceFileName) : new CaseInsensitiveMatch(sourceFileName); for (FileObject folder : folders) { for (FileObject child : folder.getChildren()) { if (matchSet.apply(child)) { return child; } } } return null; }