Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    *
    * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
    *
    * 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.  Sun designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Sun 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]"
   *
   * Contributor(s):
   *
   * The Original Software is NetBeans. The Initial Developer of the Original
   * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
   * Microsystems, Inc. All Rights Reserved.
   *
   * 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.
   */
  package org.netbeans.modules.cnd.makeproject.api.configurations;
  
  import java.io.File;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  import java.util.Vector;
  
  public class Folder implements FileChangeListenerChangeListener {
  
      public static final String DEFAULT_FOLDER_NAME = "f"// NOI18N
      public static final String DEFAULT_FOLDER_DISPLAY_NAME = getString("NewFolderName");
      private final String name;
      private String displayName;
      private final Folder parent;
      private ArrayList<Objectitems = null// Folder or Item
      private final Set<ChangeListenerchangeListenerList = new WeakSet<ChangeListener>(1);
      private final boolean projectFiles;
      private String id = null;
      private String root;
      private final static Logger log = Logger.getLogger("makeproject.folder"); // NOI18N
      private static boolean checkedLogging = checkLogging();
  
      public Folder(MakeConfigurationDescriptor configurationDescriptorFolder parentString nameString displayNameboolean projectFiles) {
          this. = configurationDescriptor;
          this. = parent;
          this. = name;
          this. = displayName;
          this. = projectFiles;
          this. = new ArrayList<Object>();
      }
  
      public void setRoot(String root) {
          this. = root;
     }
 
     public String getRoot() {
         return ;
     }
 
     public Folder getThis() {
         return this;
     }
 
     public void refreshDiskFolder() {
         if (.isLoggable(.)) {
             .finer("----------refreshDiskFolder " + getPath()); // NOI18N
         }
         String rootPath = getRootPath();
         String AbsRootPath = IpeUtils.toAbsolutePath(.getBaseDir(), rootPath);
 
         File folderFile = new File(AbsRootPath);
 
         // Folders to be removed
         if (!folderFile.exists() ||
             !folderFile.isDirectory() ||
             !VisibilityQuery.getDefault().isVisible(folderFile) ||
             getConfigurationDescriptor().getFolderVisibilityQuery().isVisible(folderFile)) {
             // Remove it plus all subfolders and items from project
             if (.isLoggable(.)) {
                 .fine("------------removing folder " + getPath() + " in " + getParent().getPath()); // NOI18N
             }
             getParent().removeFolder(this);
             return;
         }
         // Items to be removed
         for (Item item : getItemsAsArray()) {
             File file = item.getFile();
             if (!file.exists() ||
                 !file.isFile() ||
                 !VisibilityQuery.getDefault().isVisible(file) ||
                 !CndFileVisibilityQuery.getDefault().isVisible(file)) {
                 if (.isLoggable(.)) {
                     .fine("------------removing item " + item.getPath() + " in " + getPath()); // NOI18N
                 }
                 removeItem(item);
             }
         }
         // files/folders to be added
         File files[] = folderFile.listFiles();
         if (files == null) {
             return;
         }
         List<FilefileList = new ArrayList<File>();
         for (int i = 0; i < files.lengthi++) {
             if (!VisibilityQuery.getDefault().isVisible(files[i])) {
                 continue;
             }
             if (files[i].isFile() && !CndFileVisibilityQuery.getDefault().isVisible(files[i])) {
                 continue;
             }
             if (files[i].isDirectory() && getConfigurationDescriptor().getFolderVisibilityQuery().isVisible(files[i])) {
                 continue;
             }
             fileList.add(files[i]);
         }
         for (File file : fileList) {
             if (file.isDirectory()) {
                 if (findFolderByName(file.getName()) == null) {
                     if (.isLoggable(.)) {
                         .fine("------------adding folder " + file.getPath() + " in " + getPath()); // NOI18N
                     }
                     getConfigurationDescriptor().addSourceFilesFromFolder(thisfiletrue);
 
                 }
             } else {
                 String path = getRootPath() + '/' + file.getName();
                 if (path.startsWith("./")) { // NOI18N
                     path = path.substring(2);
                 }
                 if (findItemByPath(path) == null) {
                     if (.isLoggable(.)) {
                         .fine("------------adding item " + file.getPath() + " in " + getPath()); // NOI18N
                     }
                     addItem(new Item(path));
                 }
             }
         }
 
         // Repeast for all sub folders
         Vector<FoldersubFolders = getFolders();
         for (Folder f : subFolders) {
             f.refreshDiskFolder();
         }
     }
 
     public void attachListeners() {
         String rootPath = getRootPath();
         String AbsRootPath = IpeUtils.toAbsolutePath(.getBaseDir(), rootPath);
         File folderFile = new File(AbsRootPath);
 
         if (!folderFile.exists() || !folderFile.isDirectory()) {
             return;
         }
 
         if (isDiskFolder() && getRoot() != null) {
             VisibilityQuery.getDefault().addChangeListener(this);
             CndFileVisibilityQuery.getDefault().addChangeListener(this);
             if (.isLoggable(.)) {
                 .finer("-----------attachFilterListener " + getPath()); // NOI18N
             }
         }
 
         try {
             FileUtil.addFileChangeListener(thisfolderFile);
             if (.isLoggable(.)) {
                 .finer("-----------attachFileChangeListener " + getPath()); // NOI18N
             }
         } catch (IllegalArgumentException iae) {
             // Can happen if trying to attach twice...
             if (.isLoggable(.)) {
                 .finer("-----------attachFileChangeListener duplicate error" + getPath()); // NOI18N
             }
         }
 
         // Repeast for all sub folders
         Vector<FoldersubFolders = getFolders();
         for (Folder f : subFolders) {
             f.attachListeners();
         }
     }
 
     public void detachListener() {
         if (.isLoggable(.)) {
            .finer("-----------detachFileChangeListener " + getPath()); // NOI18N
         }
         FileUtil.removeFileChangeListener(this);
         if (isDiskFolder() && getRoot() != null) {
             VisibilityQuery.getDefault().removeChangeListener(this);
             CndFileVisibilityQuery.getDefault().removeChangeListener(this);
             if (.isLoggable(.)) {
                 .finer("-----------detachFilterListener " + getPath()); // NOI18N
             }
         }
 
     }
 
     public int size() {
         return .size();
     }
 
     public Folder getParent() {
         return ;
     }
 
     public Project getProject() {
         return getConfigurationDescriptor().getProject();
     }
 
     public String getName() {
         return ;
     }
 
     public String getSortName() {
         return ;
     }
 
     public String getPath() {
         StringBuilder builder2 = new StringBuilder(32);
         reversePath(thisbuilder2false);
         return builder2.toString();
     }
 
     public String getRootPath() {
         StringBuilder builder2 = new StringBuilder(32);
         reversePath(thisbuilder2true);
         String path = builder2.toString();
         return path;
     }
 
     private void reversePath(Folder folderStringBuilder builderboolean fromRoot) {
         Folder aParent = folder.getParent();
         if (aParent != null && aParent.getParent() != null) {
             reversePath(aParentbuilderfromRoot);
             builder.append('/'); // NOI18N
         }
         if (fromRoot && folder.getRoot() != null) {
             builder.append(folder.getRoot());
         } else {
             builder.append(folder.getName());
         }
     }
 
     public String getDisplayName() {
         return ;
     }
 
     public void setDisplayName(String displayName) {
         this. = displayName;
         getParent().reInsertElement(this);
     }
 
         return ;
     }
 
     public void setConfigurationDescriptor(MakeConfigurationDescriptor configurationDescriptor) {
         this. = configurationDescriptor;
     }
 
     public boolean isProjectFiles() {
         return ;
     }
 
     public boolean isDiskFolder() {
         Folder f = this;
         while (true) {
             if (f.getRoot() != null) {
                 return true;
             }
             f = f.getParent();
             if (f == null) {
                 break;
             }
         }
         return false;
     }
 
     public ArrayList<ObjectgetElements() {
         return ;
     }
 
     public void reInsertElement(Object element) {
         int index = .indexOf(element);
         if (index < 0) {
             return;
         }
         .remove(element);
         if (element instanceof Folder) {
             insertFolderElement((Folderelement);
         } else if (element instanceof Item) {
             insertItemElement((Itemelement);
         } else {
             assert false;
         }
         fireChangeEvent();
     }
 
     private void insertFolderElement(Folder element) {
         if (!element.isProjectFiles()) {
             // Insert last
             .add(element);
             return;
         }
         String name1 = element.getSortName();
         int indexAt = .size() - 1;
         while (indexAt >= 0) {
             Object o = .get(indexAt);
             if (!(o instanceof Folder)) {
                 indexAt--;
                 continue;
             }
             if (!((Foldero).isProjectFiles()) {
                 indexAt--;
                 continue;
             }
             String name2 = ((Foldero).getSortName();
             int compareRes = name1.compareToIgnoreCase(name2);
             if (compareRes < 0) {
                 indexAt--;
                 continue;
             }
             break;
         }
         .add(indexAt + 1, element);
     }
 
     public static void insertItemElementInList(ArrayList<ObjectlistItem element) {
         String name1 = (element).getSortName();
         int indexAt = list.size() - 1;
         while (indexAt >= 0) {
             Object o = list.get(indexAt);
             if (!(o instanceof Item)) {
                 //indexAt--;
                 break;
             }
             String name2 = ((Itemo).getSortName();
             int compareRes = name1.compareTo(name2);
             if (compareRes < 0) {
                 indexAt--;
                 continue;
             }
             break;
         }
         list.add(indexAt + 1, element);
     }
 
     private void insertItemElement(Item element) {
         insertItemElementInList(element);
     }
 
     public void addElement(Object element) { // FIXUP: shopuld be private
         // Always keep the vector sorted
         int indexAt = -1;
         if (element instanceof Item) {
             insertItemElement((Itemelement);
         } else if (element instanceof Folder) {
             insertFolderElement((Folderelement);
         } else {
             assert false;
         }
         fireChangeEvent();
     }
 
     public Item addItemAction(Item item) {
         if (addItem(item) == null) {
             return null// Nothing added
         }
         ArrayList<NativeFileItemlist = new ArrayList<NativeFileItem>(1);
         list.add(item);
         return item;
     }
 
     public Item addItem(Item item) {
         return addItem(itemtrue);
     }
 
     public Item addItem(Item itemboolean notify) {
         if (item == null) {
             return null;
         }
         // Check if already in project. Refresh if it's there.
         Item existingItem;
         if (isProjectFiles() && (existingItem = .findProjectItemByPath(item.getPath())) != null) {
             //System.err.println("Folder - addItem - item ignored, already added: " + item); // NOI18N  // FIXUP: correct?
             refresh(existingItem);
             return null// Nothing added
         }
         // Add it to the folder
         item.setFolder(this);
         addElement(item);
 
         // Add item to the dataObject's lookup
         if (isProjectFiles() && notify) {
             DataObject dao = item.getDataObject();
             NativeFileItemSet myNativeFileItemSet = (dao == null) ? null : dao.getCookie(NativeFileItemSet.class);
             if (myNativeFileItemSet != null) {
                 myNativeFileItemSet.add(item);
             } else {
                 if (.isLoggable(.)) {
                     .fine("can not add folder's " + this + " item " + item + " using " + dao); // NOI18N
                 }
             }
         }
 
         // Add it to project Items
         if (isProjectFiles()) {
             .addProjectItem(item);
             // Add configuration to all configurations
             if (.getConfs() == null) {
                 return item;
             }
             Configuration[] configurations = .getConfs().getConfs();
             for (int i = 0; i < configurations.lengthi++) {
                 FolderConfiguration folderConfiguration = getFolderConfiguration(configurations[i]);
                 configurations[i].addAuxObject(new ItemConfiguration(configurations[i], item));
             }
         }
 
         return item;
     }
 
     public void addFolder(Folder folder) {
         addElement(folder);
         if (isProjectFiles()) {
             // Add configuration to all configurations
             if (.getConfs() == null) {
                 return;
             }
             Configuration[] configurations = .getConfs().getConfs();
             for (int i = 0; i < configurations.lengthi++) {
                 folder.getFolderConfiguration(configurations[i]);
             }
         }
     }

    
Returns an unique id (String) used to retrive this object from the pool of aux objects
 
     public String getId() {
         if ( == null) {
              = "f-" + getPath(); // NOI18N
         }
         return ;
     }
 
     public FolderConfiguration getFolderConfiguration(Configuration configuration) {
         FolderConfiguration folderConfiguration = null;
         if (isProjectFiles()) {
             folderConfiguration = (FolderConfigurationconfiguration.getAuxObject(getId());
             if (folderConfiguration == null) {
                 CCompilerConfiguration parentCCompilerConfiguration;
                 CCCompilerConfiguration parentCCCompilerConfiguration;
                 FolderConfiguration parentFolderConfiguration = null;
                 if (getParent() != null) {
                     parentFolderConfiguration = getParent().getFolderConfiguration(configuration);
                 }
                 if (parentFolderConfiguration != null) {
                     parentCCompilerConfiguration = parentFolderConfiguration.getCCompilerConfiguration();
                     parentCCCompilerConfiguration = parentFolderConfiguration.getCCCompilerConfiguration();
                 } else {
                     parentCCompilerConfiguration = ((MakeConfigurationconfiguration).getCCompilerConfiguration();
                     parentCCCompilerConfiguration = ((MakeConfigurationconfiguration).getCCCompilerConfiguration();
                 }
                 folderConfiguration = new FolderConfiguration(configurationparentCCompilerConfigurationparentCCCompilerConfigurationthis);
                 configuration.addAuxObject(folderConfiguration);
             }
         }
         return folderConfiguration;
     }
 
     public Folder addNewFolder(boolean projectFiles) {
         String aNname;
         String aDisplayName;
         for (int i = 1;; i++) {
             aNname =  + i;
             aDisplayName =  + " " + i// NOI18N
             if (findFolderByName(aNname) == null) {
                 break;
             }
         }
         return addNewFolder(aNnameaDisplayNameprojectFiles); // NOI18N
     }
 
     public Folder addNewFolder(String nameString displayNameboolean projectFiles) {
         Folder newFolder = new Folder(getConfigurationDescriptor(), thisnamedisplayNameprojectFiles);
         addFolder(newFolder);
         return newFolder;
     }
 
     public boolean removeItemAction(Item item) {
         ArrayList<NativeFileItemlist = new ArrayList<NativeFileItem>(1);
         list.add(item);
         if (isProjectFiles()) {
             .fireFilesRemoved(list);
         }
         return removeItem(item);
     }
 
     public void renameItemAction(String oldPathItem newItem) {
         .fireFileRenamed(oldPathnewItem);
     }
 
     public boolean removeItem(Item item) {
         boolean ret = false;
         if (item == null) {
             return false;
         }
         // Remove it from folder
         ret = .remove(item);
         if (!ret) {
             return ret;
         }
 
         // Remove item from the dataObject's lookup
         if (isProjectFiles()) {
             DataObject dataObject = item.getDataObject();
             if (dataObject != null) {
                 NativeFileItemSet myNativeFileItemSet = dataObject.getCookie(NativeFileItemSet.class);
                 if (myNativeFileItemSet != null) {
                     myNativeFileItemSet.remove(item);
                 }
             }
         }
 
 //	item.setFolder(null);
         if (isProjectFiles()) {
             // Remove it from project Items
             .removeProjectItem(item);
             // Remove it form all configurations
             Configuration[] configurations = .getConfs().getConfs();
             for (int i = 0; i < configurations.lengthi++) {
                 configurations[i].removeAuxObject(item.getId()/*ItemConfiguration.getId(item.getPath())*/);
             }
         }
         item.setFolder(null);
         fireChangeEvent();
         return ret;
     }
 
     public boolean removeItemByPath(String path) {
         boolean ret = false;
         Item item = findItemByPath(path);
         return removeItem(item);
     }
 
     public boolean removeFolderAction(Folder folder) {
         return removeFolder(folder);
     }
 
     public boolean removeFolder(Folder folder) {
         boolean ret = false;
         if (folder != null) {
             if (folder.isDiskFolder()) {
                 folder.detachListener();
             }
             folder.removeAll();
             ret = .remove(folder);
             if (isProjectFiles()) {
                 // Remove it form all configurations
                 Configuration[] configurations = .getConfs().getConfs();
                 for (int i = 0; i < configurations.lengthi++) {
                     configurations[i].removeAuxObject(folder.getId());
                 }
             }
         }
         if (ret) {
             fireChangeEvent();
         }
         return ret;
     }

    
Remove all items and folders recursively
 
     public void removeAll() {
         Item[] itemsToRemove = getItemsAsArray();
         Folder[] foldersToRemove = getFoldersAsArray();
         for (int i = 0; i < itemsToRemove.lengthi++) {
             removeItem(itemsToRemove[i]);
         }
         for (int i = 0; i < foldersToRemove.lengthi++) {
             removeFolder(foldersToRemove[i]);
         }
     }
 
     public void reset() {
          = new ArrayList<Object>();
         fireChangeEvent();
     }
 
     public Item findItemByPath(String path) {
         if (path == null) {
             return null;
         }
         Item[] anItems = getItemsAsArray();
         for (int i = 0; i < anItems.lengthi++) {
             if (path.equals(anItems[i].getPath())) {
                 return anItems[i];
             }
         }
         return null;
     }
 
     public Item findItemByName(String name) {
         if (name == null) {
             return null;
         }
         Item[] anItems = getItemsAsArray();
         for (int i = 0; i < anItems.lengthi++) {
             if (name.equals(anItems[i].getName())) {
                 return anItems[i];
             }
         }
         return null;
     }
 
     public Folder findFolderByName(String name) {
         if (name == null) {
             return null;
         }
         Folder[] folders = getFoldersAsArray();
         for (int i = 0; i < folders.lengthi++) {
             if (name.equals(folders[i].getName())) {
                 return folders[i];
             }
         }
         return null;
     }
 
     public Folder findFolderByDisplayName(String name) {
         if (name == null) {
             return null;
         }
         Folder[] folders = getFoldersAsArray();
         for (int i = 0; i < folders.lengthi++) {
             if (name.equals(folders[i].getDisplayName())) {
                 return folders[i];
             }
         }
         return null;
     }
 
     public Folder findFolderByPath(String path) {
         int i = path.indexOf('/');
         if (i >= 0) {
             String aName = path.substring(0, i);
             Folder folder = findFolderByName(aName);
             if (folder == null) {
                 return null;
             }
             return folder.findFolderByPath(path.substring(i + 1));
         } else {
             return findFolderByName(path);
         }
     }
 
     public Item[] getItemsAsArray() {
         ArrayList<Itemfound = new ArrayList<Item>();
         Iterator iter = new ArrayList<Object>(getElements()).iterator();
         while (iter.hasNext()) {
             Object o = iter.next();
             if (o instanceof Item) {
                 found.add((Itemo);
             }
         }
         return found.toArray(new Item[found.size()]);
     }
 
     public List<NativeFileItemgetAllItemsAsList() {
         ArrayList<NativeFileItemfound = new ArrayList<NativeFileItem>();
         Iterator iter = new ArrayList<Object>(getElements()).iterator();
         while (iter.hasNext()) {
             Object o = iter.next();
             if (o instanceof Item) {
                 found.add((Itemo);
             }
             if (o instanceof Folder) {
                 List<NativeFileItemanItems = ((Foldero).getAllItemsAsList();
                 found.addAll(anItems);
             }
         }
         return found;
     }
 
     public Item[] getAllItemsAsArray() {
         List<NativeFileItemlist = getAllItemsAsList();
         return list.toArray(new Item[list.size()]);
     }
 
     /*
      * Returns a set of all files in this logical folder as FileObjetc's
      */
     public Set<FileObjectgetItemsAsFileObjectSet() {
         ArrayList<FileObjectfiles = new ArrayList<FileObject>();
         Iterator iter = new ArrayList<Object>(getElements()).iterator();
         while (iter.hasNext()) {
             Item item = (Itemiter.next();
             FileObject fo = item.getFileObject();
             if (fo != null) {
                 files.add(fo);
             }
         }
         return new LinkedHashSet<FileObject>(files);
     }
 
     /*
      * Returns a set of all files in this logical folder and subfolders as FileObjetc's
      */
     public Set<FileObjectgetAllItemsAsFileObjectSet(boolean projectFilesOnly) {
         ArrayList<FileObjectfiles = new ArrayList<FileObject>();
 
         if (!projectFilesOnly || isProjectFiles()) {
             Iterator iter = new ArrayList<Object>(getElements()).iterator();
             while (iter.hasNext()) {
                 Object item = iter.next();
                 if (item instanceof Item) {
                     FileObject fo = ((Itemitem).getFileObject();
                     if (fo != null) {
                         files.add(fo);
                     }
                 }
                 if (item instanceof Folder) {
                     files.addAll(((Folderitem).getAllItemsAsFileObjectSet(projectFilesOnly));
                 }
             }
         }
 
         return new LinkedHashSet<FileObject>(files);
     }
 
     /*
      * Returns a set of all files in this logical folder as FileObjetc's
      */
     public Set<DataObjectgetItemsAsDataObjectSet(String MIMETypeFilter) {
         ArrayList<DataObjectfiles = new ArrayList<DataObject>();
         Iterator iter = new ArrayList<Object>(getElements()).iterator();
         while (iter.hasNext()) {
             Item item = (Itemiter.next();
             DataObject da = item.getDataObject();
             if (da != null && (MIMETypeFilter == null || da.getPrimaryFile().getMIMEType().contains(MIMETypeFilter))) {
                 files.add(da);
             }
         }
         return new LinkedHashSet<DataObject>(files);
     }
 
     /*
      * Returns a set of all files in this logical folder and subfolders as FileObjetc's
      */
     public Set<DataObjectgetAllItemsAsDataObjectSet(boolean projectFilesOnlyString MIMETypeFilter) {
         ArrayList<DataObjectfiles = new ArrayList<DataObject>();
 
         if (!projectFilesOnly || isProjectFiles()) {
             Iterator iter = new ArrayList<Object>(getElements()).iterator();
             while (iter.hasNext()) {
                 Object item = iter.next();
                 if (item instanceof Item) {
                     DataObject da = ((Itemitem).getDataObject();
                     if (da != null && (MIMETypeFilter == null || da.getPrimaryFile().getMIMEType().contains(MIMETypeFilter))) {
                         files.add(da);
                     }
                 }
                 if (item instanceof Folder) {
                     files.addAll(((Folderitem).getAllItemsAsDataObjectSet(projectFilesOnlyMIMETypeFilter));
                 }
             }
         }
 
         return new LinkedHashSet<DataObject>(files);
     }
 
     /*
      * Returns a set of all logical folder in this folder as an array
      */
     public Folder[] getFoldersAsArray() {
         Vector<Folderfolders = getFolders();
         return folders.toArray(new Folder[folders.size()]);
     }
 
     /*
      * Returns a set of all logical folder in this folder
      */
     public Vector<FoldergetFolders() {
         Vector<Folderfolders = new Vector<Folder>();
         Iterator iter = new ArrayList<Object>(getElements()).iterator();
         while (iter.hasNext()) {
             Object item = iter.next();
             if (item instanceof Folder) {
                 folders.add((Folderitem);
             }
         }
         return folders;
     }
 
     /*
      * Returns a set of all logical folder and subfolders in this folder
      */
     public Vector<FoldergetAllFolders(boolean projectFilesOnly) {
         Vector<Folderfolders = new Vector<Folder>();
 
         if (!projectFilesOnly || isProjectFiles()) {
             Iterator iter = new ArrayList<Object>(getElements()).iterator();
             while (iter.hasNext()) {
                 Object item = iter.next();
                 if (item instanceof Folder) {
                     if (!projectFilesOnly || ((Folderitem).isProjectFiles()) {
                         folders.add((Folderitem);
                         folders.addAll(((Folderitem).getAllFolders(projectFilesOnly));
                     }
                 }
             }
         }
 
         return folders;
     }
 
     public String[] getFolderNamesAsArray() {
         Folder[] anItems = getFoldersAsArray();
         String[] names = new String[anItems.length];
         for (int i = 0; i < anItems.lengthi++) {
             names[i] = anItems[i].getName();
         }
         return names;
     }
 
     public void addChangeListener(ChangeListener cl) {
         synchronized () {
             .add(cl);
         }
     }
 
     public void removeChangeListener(ChangeListener cl) {
         synchronized () {
             .remove(cl);
         }
     }
 
     public void refresh() {
         fireChangeEvent(this);
     }
 
     public void refresh(Object source) {
         fireChangeEvent(source);
     }
 
     public void fireChangeEvent() {
         fireChangeEvent(this);
     }
 
     public void fireChangeEvent(Object source) {
         Iterator it;
 
         synchronized () {
             it = new HashSet<ChangeListener>().iterator();
         }
         ChangeEvent ev = new ChangeEvent(source);
         while (it.hasNext()) {
             ((ChangeListenerit.next()).stateChanged(ev);
         }
     }
 
     public void stateChanged(ChangeEvent e) {
         if (.isLoggable(.)) {
             .fine("------------stateChanged " + getThis().getPath()); // NOI18N
         }
         // Happens when filter has changed
         if (isDiskFolder()) {
             refreshDiskFolder();
         }
     }
 
     public void fileAttributeChanged(FileAttributeEvent fe) {
     }
 
     public void fileChanged(FileEvent fe) {
     }
 
     public void fileDataCreated(FileEvent fe) {
         boolean currentState = getConfigurationDescriptor().getModified();
         FileObject fileObject = fe.getFile();
         File file = FileUtil.toFile(fileObject);
         if (.isLoggable(.)) {
             .fine("------------fileDataCreated " + file + " in " + getThis().getPath()); // NOI18N
         }
         //if (true) return;
         if (!file.exists() || file.isDirectory()) {
             return// FIXUP: error
         }
         if (!AllSourceFileFilter.getInstance().accept(file)) {
             return;
         }
         String itemPath = file.getPath();
         itemPath = IpeUtils.toRelativePath(getConfigurationDescriptor().getBaseDir(), itemPath);
         itemPath = FilePathAdaptor.normalize(itemPath);
         Item item = new Item(itemPath);
         addItemAction(item);
         getConfigurationDescriptor().setModified(currentState);
     }
 
     public void fileFolderCreated(FileEvent fe) {
         boolean currentState = getConfigurationDescriptor().getModified();
         FileObject fileObject = fe.getFile();
         File file = FileUtil.toFile(fileObject);
         if (.isLoggable(.)) {
             .fine("------------fileFolderCreated " + file.getPath() + " in " + getThis().getPath()); // NOI18N
         }
         //if (true) return;
         if (!file.exists() || !file.isDirectory()) {
             assert false;
             return;
         }
         Folder top = getConfigurationDescriptor().addSourceFilesFromFolder(getThis(), filetrue);
         getConfigurationDescriptor().setModified(currentState);
     }
 
     public void fileDeleted(FileEvent fe) {
         boolean currentState = getConfigurationDescriptor().getModified();
         FileObject fileObject = fe.getFile();
         File file = FileUtil.toFile(fileObject);
         if (.isLoggable(.)) {
             .fine("------------fileDeleted " + file.getPath() + " in " + getThis().getPath()); // NOI18N
         }
         //if (true) return;
         String path = getRootPath() + '/' + file.getName();
         if (path.startsWith("./")) { // NOI18N
             path = path.substring(2);
         }
         // Try item first
         Item item = findItemByPath(path);
         if (item != null) {
             removeItemAction(item);
             getConfigurationDescriptor().