Attachment #146650 for bug #243683

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 243683
Collapse All | Expand All

Lines 49-54 Link Here

(-)a/apisupport.project/src/org/netbeans/modules/apisupport/project/api/LayerHandle.java (-2 / +31 lines)
49	import java.io.InputStream;	49	import java.io.InputStream;
50	import java.io.OutputStream;	50	import java.io.OutputStream;
51	import java.lang.ref.WeakReference;	51	import java.lang.ref.WeakReference;
		52	import java.lang.reflect.InvocationTargetException;
		53	import java.lang.reflect.Method;
52	import java.util.ArrayList;	54	import java.util.ArrayList;
53	import java.util.List;	55	import java.util.List;
54	import java.util.Map;	56	import java.util.Map;
Lines 71-76 Link Here
71	import org.openide.filesystems.FileUtil;	73	import org.openide.filesystems.FileUtil;
72	import org.openide.filesystems.MultiFileSystem;	74	import org.openide.filesystems.MultiFileSystem;
73	import org.openide.filesystems.XMLFileSystem;	75	import org.openide.filesystems.XMLFileSystem;
		76	import org.openide.util.Exceptions;
74	import org.openide.util.Parameters;	77	import org.openide.util.Parameters;
75	import org.openide.util.Utilities;	78	import org.openide.util.Utilities;
76	import org.openide.util.actions.SystemAction;	79	import org.openide.util.actions.SystemAction;
Lines 301-306 Link Here
301	public @Override void fileAttributeChanged(FileAttributeEvent fe) {}	304	public @Override void fileAttributeChanged(FileAttributeEvent fe) {}
302	}	305	}
303		306
		307	private static final SystemAction[] NO_ACTIONS = new SystemAction[0];
		308
		309	/**
		310	* Extracts actions from a FileSystem that implements the old contract.
		311	*
		312	* @param fs the filesystem
		313	* @return FD actions, or an empty array.
		314	*/
		315	private static SystemAction[] getFSActions(FileSystem fs) {
		316	try {
		317	Method m = fs.getClass().getMethod("getActions");
		318	return (SystemAction[])m.invoke(fs);
		319	} catch (NoSuchMethodException ex) {
		320	// OK, no such method exists
		321	} catch (SecurityException ex) {
		322	Exceptions.printStackTrace(ex);
		323	} catch (IllegalAccessException ex) {
		324	Exceptions.printStackTrace(ex);
		325	} catch (IllegalArgumentException ex) {
		326	Exceptions.printStackTrace(ex);
		327	} catch (InvocationTargetException ex) {
		328	Exceptions.printStackTrace(ex);
		329	}
		330	return NO_ACTIONS;
		331	}
		332
304	private final class SingleLayer extends FileSystem implements FileChangeListener {	333	private final class SingleLayer extends FileSystem implements FileChangeListener {
305	private final FileSystem explicit;	334	private final FileSystem explicit;
306	SingleLayer(FileSystem explicit) {	335	SingleLayer(FileSystem explicit) {
Lines 348-356 Link Here
348	return this.explicit!=null?this.explicit.findResource(name):null;	377	return this.explicit!=null?this.explicit.findResource(name):null;
349	}	378	}
350		379
351	@Override	380	// @Override
352	public SystemAction[] getActions() {	381	public SystemAction[] getActions() {
353	return this.explicit!=null?this.explicit.getActions():null;	382	return this.explicit!=null?getFSActions(this.explicit):null;
354	}	383	}
355	}	384	}
356		385

Lines 239-245 Link Here

(-)a/apisupport.project/src/org/netbeans/modules/apisupport/project/layers/LayerNode.java (-1 / +1 lines)
239	public String getDisplayName() {	239	public String getDisplayName() {
240	return FileUtil.getFileDisplayName(layer);	240	return FileUtil.getFileDisplayName(layer);
241	}	241	}
242	@Override	242
243	public SystemAction[] getActions(Set<FileObject> foSet) {	243	public SystemAction[] getActions(Set<FileObject> foSet) {
244	return new SystemAction[] {	244	return new SystemAction[] {
245	SystemAction.get(PickNameAction.class),	245	SystemAction.get(PickNameAction.class),

Lines 189-198 Link Here

(-)a/cnd.apt/test/unit/src/org/netbeans/modules/cnd/apt/support/APTConditionResolverTest.java (-5 lines)
189	public FileObject findResource(String name) {	189	public FileObject findResource(String name) {
190	throw new UnsupportedOperationException();	190	throw new UnsupportedOperationException();
191	}	191	}
192
193	@Override
194	public org.openide.util.actions.SystemAction[] getActions() {
195	throw new UnsupportedOperationException();
196	}
197	}	192	}
198	}	193	}

Lines 263-271 Link Here

(-)a/cnd.apt/test/unit/src/org/netbeans/modules/cnd/apt/support/GuardDetectorTestCase.java (-4 lines)
263	throw new UnsupportedOperationException("Not supported yet.");	263	throw new UnsupportedOperationException("Not supported yet.");
264	}	264	}
265		265
266	@Override
267	public SystemAction[] getActions() {
268	throw new UnsupportedOperationException("Not supported yet.");
269	}
270	}	266	}
271	}	267	}

Lines 138-148 Link Here

(-)a/cnd.folding/test/unit/src/org/netbeans/modules/cnd/folding/APTFoldingProviderTestCase.java (-5 lines)
138	public FileObject findResource(String name) {	138	public FileObject findResource(String name) {
139	throw new UnsupportedOperationException();	139	throw new UnsupportedOperationException();
140	}	140	}
141
142	@Override
143	public org.openide.util.actions.SystemAction[] getActions() {
144	throw new UnsupportedOperationException();
145	}
146	}	141	}
147		142
148	}	143	}

Lines 24-30 Link Here

(-)a/core.osgi/nbproject/project.xml (-1 / +9 lines)
24	<build-prerequisite/>	24	<build-prerequisite/>
25	<compile-dependency/>	25	<compile-dependency/>
26	<run-dependency>	26	<run-dependency>
27	<specification-version>7.36</specification-version>	27	<specification-version>9.0</specification-version>
		28	</run-dependency>
		29	</dependency>
		30	<dependency>
		31	<code-name-base>org.openide.filesystems.compat8</code-name-base>
		32	<build-prerequisite/>
		33	<compile-dependency/>
		34	<run-dependency>
		35	<specification-version>9.0</specification-version>
28	</run-dependency>	36	</run-dependency>
29	</dependency>	37	</dependency>
30	<dependency>	38	<dependency>




        home = fss.length > 1 ? (ModuleLayeredFileSystem) fss[1] : null;
        
        setSystemName(SYSTEM_NAME);
        setHidden(true);
        addFileChangeListener(this);
    }


        return super.createLocksOn (name);
    }
    
    /** This filesystem cannot be removed from pool, it is persistent.
    */
    @Deprecated
    public @Override boolean isPersistent() {
        return true;
    }

    /** Initializes and creates new repository. This repository's system fs is
    * based on the content of ${HOME_DIR}/system and ${USER_DIR}/system directories
    *

Lines 135-145 Link Here

(-)a/dlight.libs.common/src/org/netbeans/modules/dlight/libs/common/InvalidFileObjectSupport.java (-5 lines)
135	}	135	}
136		136
137	@Override	137	@Override
138	public SystemAction[] getActions() {
139	return new SystemAction[0];
140	}
141
142	@Override
143	public String getDisplayName() {	138	public String getDisplayName() {
144	return "Dummy"; //NOI18N	139	return "Dummy"; //NOI18N
145	}	140	}




    }
    

    @Override
    public SystemAction[] getActions() {
        return NO_SYSTEM_ACTIONS;
    }

    public void addPendingFile(RemoteFileObjectBase fo) {
        remoteFileSupport.addPendingFile(fo);
        fireProblemListeners(fo.getPath());

        }
    }

//    @Override -- overrides at runtime
    public final SystemAction[] getActions(final Set<FileObject> foSet) {
        SystemAction[] result = status.getActions (foSet);
        SystemAction refreshAction = isManualRefresh() ? null :  FileSystemRefreshAction.get(FileSystemRefreshAction.class);                 




        throw new IOException("Cannot create temporary file"); // NOI18N
    }

    @Override
    public SystemAction[] getActions() {
        return new SystemAction[] {};
    }

    @Override
    public final SystemAction[] getActions(final Set<FileObject> foSet) {
        SystemAction[] some = status.getActions (foSet);
        if (some != null) {

Lines 1898-1903 Link Here

(-)a/nbbuild/build.xml (+4 lines)
1898	<equals arg1="${code.name.base.dashes}" arg2="org-netbeans-libs-asm" />	1898	<equals arg1="${code.name.base.dashes}" arg2="org-netbeans-libs-asm" />
1899	</condition>	1899	</condition>
1900		1900
		1901	<condition property="module" value="tmp/netbeans/lib/org-netbeans-libs-asm.jar">
		1902	<equals arg1="${code.name.base.dashes}" arg2="org-netbeans-libs-asm" />
		1903	</condition>
		1904
1901	<condition property="module" value="tmp/netbeans/core/org-netbeans-upgrader.jar">	1905	<condition property="module" value="tmp/netbeans/core/org-netbeans-upgrader.jar">
1902	<equals arg1="${code.name.base.dashes}" arg2="org-netbeans-upgrader" />	1906	<equals arg1="${code.name.base.dashes}" arg2="org-netbeans-upgrader" />
1903	</condition>	1907	</condition>

Lines 228-234 Link Here

(-)a/nbbuild/cluster.properties (+3 lines)
228	openide.compat,\	228	openide.compat,\
229	openide.dialogs,\	229	openide.dialogs,\
230	openide.execution,\	230	openide.execution,\
		231	openide.execution.compat8,\
231	openide.explorer,\	232	openide.explorer,\
		233	openide.filesystems.compat8,\
		234	openide.filesystems.nb,\
232	openide.io,\	235	openide.io,\
233	openide.loaders,\	236	openide.loaders,\
234	openide.modules,\	237	openide.modules,\

Lines 224-226 Link Here

(-)a/nbbuild/javadoctools/links.xml (+1 lines)
224	<link href="${javadoc.docs.org-netbeans-core-multitabs}" offline="true" packagelistloc="${netbeans.javadoc.dir}/org-netbeans-core-multitabs"/>	224	<link href="${javadoc.docs.org-netbeans-core-multitabs}" offline="true" packagelistloc="${netbeans.javadoc.dir}/org-netbeans-core-multitabs"/>
225	<link href="${javadoc.docs.org-openide-util-base}" offline="true" packagelistloc="${netbeans.javadoc.dir}/org-openide-util-base"/>	225	<link href="${javadoc.docs.org-openide-util-base}" offline="true" packagelistloc="${netbeans.javadoc.dir}/org-openide-util-base"/>
226	<link href="${javadoc.docs.org-openide-filesystems-compat8}" offline="true" packagelistloc="${netbeans.javadoc.dir}/org-openide-filesystems-compat8"/>	226	<link href="${javadoc.docs.org-openide-filesystems-compat8}" offline="true" packagelistloc="${netbeans.javadoc.dir}/org-openide-filesystems-compat8"/>
		227	<link href="${javadoc.docs.org-openide-filesystems-compat8}" offline="true" packagelistloc="${netbeans.javadoc.dir}/org-openide-filesystems-compat8"/>

Lines 222-224 Link Here

(-)a/nbbuild/javadoctools/properties.xml (+1 lines)
222	<property name="javadoc.docs.org-netbeans-core-multitabs" value="${javadoc.web.root}/org-netbeans-core-multitabs"/>	222	<property name="javadoc.docs.org-netbeans-core-multitabs" value="${javadoc.web.root}/org-netbeans-core-multitabs"/>
223	<property name="javadoc.docs.org-openide-util-base" value="${javadoc.web.root}/org-openide-util-base"/>	223	<property name="javadoc.docs.org-openide-util-base" value="${javadoc.web.root}/org-openide-util-base"/>
224	<property name="javadoc.docs.org-openide-filesystems-compat8" value="${javadoc.web.root}/org-openide-filesystems-compat8"/>	224	<property name="javadoc.docs.org-openide-filesystems-compat8" value="${javadoc.web.root}/org-openide-filesystems-compat8"/>
		225	<property name="javadoc.docs.org-openide-filesystems-compat8" value="${javadoc.web.root}/org-openide-filesystems-compat8"/>

Lines 222-224 Link Here

(-)a/nbbuild/javadoctools/replaces.xml (+1 lines)
222	<replacefilter token="@org-netbeans-core-multitabs@" value="${javadoc.docs.org-netbeans-core-multitabs}"/>	222	<replacefilter token="@org-netbeans-core-multitabs@" value="${javadoc.docs.org-netbeans-core-multitabs}"/>
223	<replacefilter token="@org-openide-util-base@" value="${javadoc.docs.org-openide-util-base}"/>	223	<replacefilter token="@org-openide-util-base@" value="${javadoc.docs.org-openide-util-base}"/>
224	<replacefilter token="@org-openide-filesystems-compat8@" value="${javadoc.docs.org-openide-filesystems-compat8}"/>	224	<replacefilter token="@org-openide-filesystems-compat8@" value="${javadoc.docs.org-openide-filesystems-compat8}"/>
		225	<replacefilter token="@org-openide-filesystems-compat8@" value="${javadoc.docs.org-openide-filesystems-compat8}"/>




                <module codenamebase="org.openide.util" spec="9.0"/>
                <module codenamebase="org.openide.util.base" spec="9.0"/>
            </replace>

            <replace codenamebase="org.openide.filesystems" addcompiletime="true">
                <module codenamebase="org.openide.filesystems" spec="9.0"/>
                <module codenamebase="org.openide.filesystems.nb" spec="9.0"/>
                <module codenamebase="org.openide.filesystems.compat8" spec="9.0"/>
            </replace>
            <replace codenamebase="org.openide.execution" addcompiletime="true">
                <module codenamebase="org.openide.execution" spec="9.0"/>
                <module codenamebase="org.openide.execution.compat8" spec="9.0"/>
            </replace>
            <fileset dir="nbproject" >
                <include name="project.xml" />
            </fileset>

Line 0 Link Here

(-)a/openide.execution.compat8/build.xml (+5 lines)
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<project basedir="." default="netbeans" name="openide.execution.compat8">
	3	<description>Builds, tests, and runs the project org.openide.execution.compat8</description>
	4	<import file="../nbbuild/templates/projectized.xml"/>
	5	</project>

Line 0 Link Here

(-)a/openide.execution.compat8/manifest.mf (+6 lines)
	1	Manifest-Version: 1.0
	2	OpenIDE-Module: org.openide.execution.compat8
	3	OpenIDE-Module-Localizing-Bundle: org/openide/execution/compat8/Bundle.properties
	4	OpenIDE-Module-Specification-Version: 9.0
	5	OpenIDE-Module-Fragment-Host: org.openide.execution
	6

Line 0 Link Here

(-)a/openide.execution.compat8/nbproject/project.properties (+2 lines)
	1	javac.source=1.6
	2	javac.compilerargs=-Xlint -Xlint:-serial




<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.netbeans.org/ns/project/1">
    <type>org.netbeans.modules.apisupport.project</type>
    <configuration>
        <data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
            <code-name-base>org.openide.execution.compat8</code-name-base>
            <module-dependencies>
                <dependency>
                    <code-name-base>org.openide.execution</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.filesystems</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.filesystems.compat8</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
            </module-dependencies>
            <public-packages>
                <package>org.openide.execution</package>
            </public-packages>
        </data>
    </configuration>
</project>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.openide.execution;

import java.util.Enumeration;
import java.util.LinkedList;
import org.openide.filesystems.EnvironmentNotSupportedException;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileSystem$Environment;
import org.openide.filesystems.FileSystemCapability;
import org.openide.filesystems.FileSystemCompat;

/**
 * Backward binary compatibility support for deprecated/obsolete features
 * @author sdedic
 */
public class NbClassPathCompat {
    
    /** Method to obtain class path for the current state of the repository.
    * The classpath should be scanned for all occured exception caused
    * by file systems that cannot be converted to class path by a call to
    * method getExceptions().
    *
    *
    * @return class path for all reachable systems in the repository
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/api.html">ClassPath API</a> instead.
    */
    @Deprecated
    public static NbClassPath createRepositoryPath () {
        Thread.dumpStack();
        return createRepositoryPath (FileSystemCapability.ALL);
    }

    /** Method to obtain class path for the current state of the repository.
    * The classpath should be scanned for all occured exception caused
    * by file systems that cannot be converted to class path by a call to
    * method getExceptions().
    *
    *
    * @param cap the capability that must be satisfied by the file system
    *    added to the class path
    * @return class path for all reachable systems in the repository
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/api.html">ClassPath API</a> instead.
    */
    @Deprecated
    public static NbClassPath createRepositoryPath (FileSystemCapability cap) {
        Thread.dumpStack();
        final LinkedList res = new LinkedList ();


        final class Env extends FileSystem$Environment {
            /* method of interface Environment */
            public void addClassPath(String element) {
                res.add (element);
            }
        }


        Env env = new Env ();
        Enumeration en = cap.fileSystems ();
        while (en.hasMoreElements ()) {
            try {
                FileSystem fs = (FileSystem)en.nextElement ();
                FileSystemCompat.compat(fs).prepareEnvironment((FileSystem$Environment)env);
            } catch (EnvironmentNotSupportedException ex) {
                // store the exception
                res.add (ex);
            }
        }

        // return it
        return new NbClassPath (res.toArray ());
    }

}

Line 0 Link Here

(-)a/openide.execution.compat8/src/org/openide/execution/compat8/Bundle.properties (+8 lines)
	1	OpenIDE-Module-Name=Execution API 8.0 Compatibility
	2	OpenIDE-Module-Display-Category=Infrastructure
	3	OpenIDE-Module-Short-Description=Compatibility support for clients compiled against Execution API \
	4	ver. 8.0 and earlier.
	5	OpenIDE-Module-Long-Description=\
	6	The module provides deprecated and obsolete classes/methods removed from the \
	7	official APIs for binary compatibility of old Execution API clients.
	8

Lines 1-6 Link Here

(-)a/openide.execution/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.openide.execution	2	OpenIDE-Module: org.openide.execution
3	OpenIDE-Module-Specification-Version: 1.36	3	OpenIDE-Module-Specification-Version: 9.0
4	OpenIDE-Module-Localizing-Bundle: org/openide/execution/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/openide/execution/Bundle.properties
5	OpenIDE-Module-Recommends: org.openide.execution.ExecutionEngine	5	OpenIDE-Module-Recommends: org.openide.execution.ExecutionEngine
6	AutoUpdate-Essential-Module: true	6	AutoUpdate-Essential-Module: true




            </implies>
        </transformation>
    </transformationgroup>
    <transformationgroup>
        <description>Removal of FileSystemCapability</description>
        <transformation>
            <trigger-dependency type="older">
                <module-dependency codenamebase="org.openide.execution" spec="9.0"/>
            </trigger-dependency>
            <implies>
                <result>
                    <module-dependency codenamebase="org.openide.execution.compat8" spec="9.0"/>
                </result>
            </implies>
        </transformation>
    </transformationgroup>

</transformations>

Lines 54-60 Link Here

(-)a/openide.execution/nbproject/project.xml (-1 / +1 lines)
54	<build-prerequisite/>	54	<build-prerequisite/>
55	<compile-dependency/>	55	<compile-dependency/>
56	<run-dependency>	56	<run-dependency>
57	<specification-version>7.57</specification-version>	57	<specification-version>9.0</specification-version>
58	</run-dependency>	58	</run-dependency>
59	</dependency>	59	</dependency>
60	<dependency>	60	<dependency>

Lines 59-65 Link Here

(-)a/openide.execution/src/org/openide/execution/NbClassLoader.java (-1 lines)
59	import java.util.logging.Logger;	59	import java.util.logging.Logger;
60	import org.openide.filesystems.FileObject;	60	import org.openide.filesystems.FileObject;
61	import org.openide.filesystems.FileSystem;	61	import org.openide.filesystems.FileSystem;
62	import org.openide.filesystems.FileSystemCapability;
63	import org.openide.filesystems.FileUtil;	62	import org.openide.filesystems.FileUtil;
64	import org.openide.filesystems.URLMapper;	63	import org.openide.filesystems.URLMapper;
65	import org.openide.util.Exceptions;	64	import org.openide.util.Exceptions;




    /** Private constructor
    * @param arr array of String and Exceptions
    */
    NbClassPath (Object[] arr) {
        this.items = arr;
    }


        }
    }

    /** Method to obtain class path for the current state of the repository.
    * The classpath should be scanned for all occured exception caused
    * by file systems that cannot be converted to class path by a call to
    * method getExceptions().
    *
    *
    * @return class path for all reachable systems in the repository
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/api.html">ClassPath API</a> instead.
    */
    public static NbClassPath createRepositoryPath () {
        Thread.dumpStack();
        return createRepositoryPath (FileSystemCapability.ALL);
    }

    /** Method to obtain class path for the current state of the repository.
    * The classpath should be scanned for all occured exception caused
    * by file systems that cannot be converted to class path by a call to
    * method getExceptions().
    *
    *
    * @param cap the capability that must be satisfied by the file system
    *    added to the class path
    * @return class path for all reachable systems in the repository
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/api.html">ClassPath API</a> instead.
    */
    public static NbClassPath createRepositoryPath (FileSystemCapability cap) {
        Thread.dumpStack();
        final LinkedList res = new LinkedList ();


        final class Env extends FileSystem.Environment {
            /* method of interface Environment */
            public void addClassPath(String element) {
                res.add (element);
            }
        }


        Env env = new Env ();
        Enumeration en = cap.fileSystems ();
        while (en.hasMoreElements ()) {
            try {
                FileSystem fs = (FileSystem)en.nextElement ();
                fs.prepareEnvironment(env);
            } catch (EnvironmentNotSupportedException ex) {
                // store the exception
                res.add (ex);
            }
        }

        // return it
        return new NbClassPath (res.toArray ());
    }

    /** Creates class path describing additional libraries needed by the system.
     * Never use this class path as part of a user project!
     * For more information consult the <a href="../doc-files/classpath.html">Module Class Path</a> document.




<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE api-answers PUBLIC "-//NetBeans//DTD Arch Answers//EN" "../nbbuild/antsrc/org/netbeans/nbbuild/Arch.dtd" [
  <!ENTITY api-questions SYSTEM "../nbbuild/antsrc/org/netbeans/nbbuild/Arch-api-questions.xml">
]>

<api-answers
  question-version="1.29"
  author="sdedic@netbeans.org"
>

  &api-questions;

 <answer id="arch-overall">
  <p>
   This module contains no public API. It only serves to provide binary backward compatibility
    for modules compiled against FileSystems API 8.x and earlier.
  </p>
 </answer>

 <answer id="arch-quality">
  <p>
    Tests to ensure FileSystems 8.x features should be provided.
  </p>
 </answer>

 <answer id="arch-time">
  <p>
   Already done.
  </p>
 </answer>

 <answer id="arch-usecases">
  <p>
   Allows to run modules compiled against FileSystems 8.0 APIs
  </p>
 </answer>

 <answer id="arch-what">
  <p>
   Preservation of compatibility
  </p>
 </answer>

 <answer id="arch-where">
  <defaultanswer generate='here' />
 </answer>

 <answer id="compat-deprecation">
  <p>
   APIs that relate to <a href="@TOP@/org/openide/filesystems/FileSystemCapability.html">FileSystemCapability</a> and 
   <a href="@TOP@/org/openide/filesystems/FileSystem$Environment.html">FileSystem.Environment</a> are removed from the main API
   and provided here only for binary compatibility.
  </p>
 </answer>

 <answer id="compat-i18n">
  <p>
   yes
  </p>
 </answer>

 <answer id="compat-standards">
  <p>
   no
  </p>
 </answer>



 <answer id="compat-version">
  <p>
   yes
  </p>
 </answer>

 <answer id="dep-jre">
  <p>
   no dependency
  </p>
 </answer>

 <answer id="dep-jrejdk">
  <p>
   JRE
  </p>
 </answer>

 <answer id="dep-nb">
  <defaultanswer generate='here' />
 </answer>

 <answer id="dep-non-nb">
  <p>
   None
  </p>
 </answer>

 <answer id="dep-platform">
  <p>
   All
  </p>
 </answer>

 <answer id="deploy-dependencies">
  <p>
   None
  </p>
 </answer>

 <answer id="deploy-jar">
  <p>
   No.
  </p>
 </answer>

<!--
        <question id="deploy-nbm" when="impl">
            Can you deploy an NBM via the Update Center?
            <hint>
            If not why?
            </hint>
        </question>
-->
 <answer id="deploy-nbm">
  <p>
   Yes
  </p>
 </answer>

 <answer id="deploy-packages">
  <p>
   Yes, packages are only available to strictly defined friends
  </p>
 </answer>

 <answer id="deploy-shared">
  <p>
   Shared location
  </p>
 </answer>

 <answer id="exec-ant-tasks">
  <p>
   No
  </p>
 </answer>

 <answer id="exec-classloader">
  <p>
   No.
  </p>
 </answer>

 <answer id="exec-component">
  <p>
   No.
  </p>
 </answer>

 <answer id="exec-introspection">
  <p>
   No.
  </p>
 </answer>

 <answer id="exec-privateaccess">
  <p>
   None.
  </p>
 </answer>

 <answer id="exec-process">
  <p>
   No.
  </p>
 </answer>

 <answer id="exec-property">
  <p>
   No.
  </p>
 </answer>

 <answer id="exec-reflection">
  <p>
   Not directly reflection. The code however relies on that it is deployed
   to the same runtime package as FileSystems API and accessess its package
   private parts.
  </p>
 </answer>

 <answer id="exec-threading">
  <p>
   See Filesystems API
  </p>
 </answer>

 <answer id="format-clipboard">
  <p>
   See Filesystems API
  </p>
 </answer>

 <answer id="format-dnd">
  <p>
   See Filesystems API
  </p>
 </answer>

 <answer id="format-types">
  <p>
   None.
  </p>
 </answer>

 <answer id="lookup-lookup">
  <p>
   No.
  </p>
 </answer>

 <answer id="lookup-register">
  <p>
   None.
  </p>
 </answer>

 <answer id="lookup-remove">
  <p>
   No.
  </p>
 </answer>

 <answer id="perf-exit">
  <p>
   No.
  </p>
 </answer>

 <answer id="perf-huge_dialogs">
  <p>
   None.
  </p>
 </answer>

 <answer id="perf-limit">
  <p>
   N/A
  </p>
 </answer>

 <answer id="perf-mem">
  <p>
   N/A
  </p>
 </answer>

 <answer id="perf-menus">
  <p>
   No menus
  </p>
 </answer>

 <answer id="perf-progress">
  <p>
   No.
  </p>
 </answer>

 <answer id="perf-scale">
  <p>
   See Filesystems API
  </p>
 </answer>

 <answer id="perf-spi">
  <p>
   N/A
  </p>
 </answer>

 <answer id="perf-startup">
  <p>
   No.
  </p>
 </answer>

 <answer id="perf-wakeup">
  <p>
   No.
  </p>
 </answer>

 <answer id="resources-file">
  <p>
      Yes, for initialization of <a href="@openide-filesystems@/org/openide/filesystems/LocalFileSystem.html">LocalFileSystem</a>
      and <a href="@openide-filesystems@/org/openide/filesystems/JarFileSystem.html">JarFileSystem</a>
  </p>
 </answer>

 <answer id="resources-layer">
  <p>
   No layer
  </p>
 </answer>

 <answer id="resources-mask">
  <p>
   No.
  </p>
 </answer>

 <answer id="resources-preferences">
  <p>
   No.
  </p>
 </answer>

 <answer id="resources-read">
  <p>
   No.
  </p>
 </answer>

 <answer id="security-grant">
  <p>
   No.
  </p>
 </answer>

 <answer id="security-policy">
  <p>
   No.
  </p>
 </answer>

</api-answers>

Line 0 Link Here

(-)a/openide.filesystems.compat8/build.xml (+5 lines)
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<project basedir="." default="netbeans" name="openide.filesystems.compat8">
	3	<description>Builds, tests, and runs the project org.openide.filesystems.compat8</description>
	4	<import file="../nbbuild/templates/projectized.xml"/>
	5	</project>

Line 0 Link Here

(-)a/openide.filesystems.compat8/manifest.mf (+6 lines)
	1	Manifest-Version: 1.0
	2	OpenIDE-Module: org.openide.filesystems.compat8
	3	OpenIDE-Module-Localizing-Bundle: org/openide/filesystems/compat8/Bundle.properties
	4	OpenIDE-Module-Specification-Version: 9.0
	5	OpenIDE-Module-Fragment-Host: org.openide.filesystems
	6

Line 0 Link Here

(-)a/openide.filesystems.compat8/nbproject/project.properties (+4 lines)
	1	javac.source=1.6
	2	javac.compilerargs=-Xlint -Xlint:-serial
	3	module.jar.dir=core
	4	javadoc.arch=${basedir}/arch.xml




<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.netbeans.org/ns/project/1">
    <type>org.netbeans.modules.apisupport.project</type>
    <configuration>
        <data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
            <code-name-base>org.openide.filesystems.compat8</code-name-base>
            <module-dependencies>
                <dependency>
                    <code-name-base>org.openide.filesystems</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.modules</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>7.44</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.base</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.lookup</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>8.17</specification-version>
                    </run-dependency>
                </dependency>
            </module-dependencies>
            <public-packages>
                <package>org.openide.filesystems</package>
            </public-packages>
        </data>
    </configuration>
</project>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.openide.filesystems;

import java.util.Enumeration;
import java.util.StringTokenizer;
import org.openide.modules.PatchFor;
import org.openide.util.Enumerations;
import org.openide.util.Lookup;
import org.openide.util.NbCollections;
import org.openide.util.SharedClassObject;
import org.openide.util.actions.SystemAction;

/**
 * 8.0 compatibility patch for AbstractFileSystem.
 * @author sdedic
 */
@PatchFor(AbstractFileSystem.class)
public abstract class AbstractFileSystemCompat extends FileSystem {
    /** system actions for this FS if it has refreshTime != 0 */
    private static SystemAction[] SYSTEM_ACTIONS;

    /** system actions for this FS */
    private static final SystemAction[] NO_SYSTEM_ACTIONS = new SystemAction[] {  };

    
    /* Finds file when its name is provided.
    *
    * @param aPackage package name where each package is separated by a dot
    * @param name name of the file (without dots) or <CODE>null</CODE> if
    *    one want to obtain name of package and not file in it
    * @param ext extension of the file or <CODE>null</CODE> if one needs
    *    package and not file name
    *
    * @warning when one of name or ext is <CODE>null</CODE> then name and
    *    ext should be ignored and scan should look only for a package
    *
    * @return FileObject that represents file with given name or
    *   <CODE>null</CODE> if the file does not exist
    */
    @Deprecated
    public FileObject find(String aPackage, String name, String ext) {
        // create enumeration of name to look for
        Enumeration<String> st = NbCollections.checkedEnumerationByFilter(new StringTokenizer(aPackage, "."), String.class, true); // NOI18N

        if ((name == null) || (ext == null)) {
            // search for folder, return the object only if it is folder
            FileObject fo = getAbstractRoot().find(st);

            return ((fo != null) && fo.isFolder()) ? fo : null;
        } else {
            Enumeration<String> en = Enumerations.concat(st, Enumerations.singleton(name + '.' + ext));

            // tries to find it (can return null)
            return getAbstractRoot().find(en);
        }
    }

    abstract AbstractFileObject getAbstractRoot();
    
    abstract boolean isEnabledRefreshFolder();

    /* Action for this filesystem.
    *
    * @return refresh action
    */
    public SystemAction[] getActions() {
        if (!isEnabledRefreshFolder()) {
            return NO_SYSTEM_ACTIONS;
        } else {
            if (SYSTEM_ACTIONS == null) {
                try {
                    ClassLoader l = Lookup.getDefault().lookup(ClassLoader.class);

                    if (l == null) {
                        l = getClass().getClassLoader();
                    }

                    Class<?> c = Class.forName("org.openide.actions.FileSystemRefreshAction", true, l); // NOI18N
                    SystemAction ra = SharedClassObject.findObject(c.asSubclass(SystemAction.class), true);

                    // initialize the SYSTEM_ACTIONS
                    SYSTEM_ACTIONS = new SystemAction[] { ra };
                } catch (Exception ex) {
                    // ok, we are probably running in standalone mode and
                    // classes needed to initialize the RefreshAction are
                    // not available
                    SYSTEM_ACTIONS = NO_SYSTEM_ACTIONS;
                }
            }

            return SYSTEM_ACTIONS;
        }
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 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.openide.filesystems;

import java.io.IOException;

/** Exception thrown to signal that external
* execution and compilation is not supported on a given filesystem.
*
* @author Jaroslav Tulach
* @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
*/
@Deprecated
public class EnvironmentNotSupportedException extends IOException {
    /** generated Serialized Version UID */
    static final long serialVersionUID = -1138390681913514558L;

    /** the throwing exception */
    private FileSystem fs;

    /**
    * @param fs filesystem that caused the error
    */
    public EnvironmentNotSupportedException(FileSystem fs) {
        this.fs = fs;
        assert false : "Deprecated.";
    }

    /**
    * @param fs filesystem that caused the error
    * @param reason text description for the error
    */
    public EnvironmentNotSupportedException(FileSystem fs, String reason) {
        super(reason);
        this.fs = fs;
        assert false : "Deprecated.";
    }

    /** Getter for the filesystem that does not support environment operations.
    */
    public FileSystem getFileSystem() {
        return fs;
    }
}




package org.openide.filesystems;

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

/** Interface that allows filesystems to set up the Java environment
* for external execution and compilation.
* Currently just used to append entries to the external class path.
* @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
*/
@Deprecated
public abstract class FileSystem$Environment {
        /** Deprecated. */
        public FileSystem$Environment() {
            assert false : "Deprecated.";
        }

        /** Adds one element to the class path environment variable.
        * @param classPathElement string representing the one element
        * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public void addClassPath(String classPathElement) {
        }
}





/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 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.openide.filesystems;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Vector;

/** This class defines the capabilities of a filesystem to
* take part in different operations. Some filesystems are
* not designed to allow compilation on them, some do not want
* to be present in class path when executing or debugging
* a program.
* <P>
* Moreover there can be additional capabilities to check
* and this class defines ways how one can communicated with
* a filesystem to find out whether the system is "capable"
* enough to be used in the operation.
*
* @author Jaroslav Tulach
 * @deprecated Now useless.
*/
@Deprecated
public class FileSystemCapability extends Object {
    /** Object that is capable of every thing.
    */
    public static final FileSystemCapability ALL = new FileSystemCapability() {
            public boolean capableOf(FileSystemCapability c) {
                return true;
            }
        };

    /** Well known capability of being compiled.
     * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
     */
    @Deprecated
    public static final FileSystemCapability COMPILE = new FileSystemCapability();

    /** Well known ability to be executed.
     * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
     */
    @Deprecated
    public static final FileSystemCapability EXECUTE = new FileSystemCapability();

    /** Well known ability to be debugged.
     * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
     */
    @Deprecated
    public static final FileSystemCapability DEBUG = new FileSystemCapability();

    /** Well known ability to contain documentation files
     * @deprecated Please use <a href="@org-netbeans-api-java@/org/netbeans/api/queries/JavadocForBinaryQuery.html"><code>JavadocForBinaryQuery</code></a> instead.
     */
    @Deprecated
    public static final FileSystemCapability DOC = new FileSystemCapability();

    public FileSystemCapability() {
        if (DOC == null) {
            // do not report static initializers
            return;
        }

        assert false : "Deprecated.";
    }

    /** Basic operation that tests whether this object
    * is capable to do different capability.
    * <P>
    * The default implementation claims that it is
    * capable to handle only identical capability (==).
    *
    * @param c capability to test
    * @return true if yes
    */
    public boolean capableOf(FileSystemCapability c) {
        return c == this;
    }

    /** All filesystems that are capable of this capability.
    * @return enumeration of FileSystems that satifies this capability
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public Enumeration<? extends FileSystem> fileSystems() {
        class FFS implements org.openide.util.Enumerations.Processor<FileSystem, FileSystem> {
            @Deprecated
            public FileSystem process(FileSystem fs, Collection<FileSystem> ignore) {
                return FileSystemCompat.compat(fs).getCapability().
                        capableOf(FileSystemCapability.this) ? fs : null;
            }
        }

        return org.openide.util.Enumerations.filter(Repository.getDefault().fileSystems(), new FFS());
    }

    /** Find a resource in repository, ignoring not capable filesystems.
    * @param resName name of the resource
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public FileObject findResource(String resName) {
        Enumeration<? extends FileSystem> en = fileSystems();

        while (en.hasMoreElements()) {
            FileSystem fs = en.nextElement();
            FileObject fo = fs.findResource(resName);

            if (fo != null) {
                // object found
                return fo;
            }
        }

        return null;
    }

    /** Searches for the given resource among all filesystems
    * that satifies this capability, returning all matches.
    * @param name name of the resource
    * @return enumeration of {@link FileObject}s
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public Enumeration<? extends FileObject> findAllResources(String name) {
        Vector<FileObject> v = new Vector<FileObject>(8);
        Enumeration<? extends FileSystem> en = fileSystems();

        while (en.hasMoreElements()) {
            FileSystem fs = en.nextElement();
            FileObject fo = fs.findResource(name);

            if (fo != null) {
                v.addElement(fo);
            }
        }

        return v.elements();
    }

    /** Finds file when its name is provided. It scans in the list of
    * filesystems and asks them for the specified file by a call to
    * {@link FileSystem#find find}. The first object that is found is returned or <CODE>null</CODE>
    * if none of the filesystems contain such a file.
    *
    * @param aPackage package name where each package is separated by a dot
    * @param name name of the file (without dots) or <CODE>null</CODE> if
    *    one wants to obtain the name of a package and not a file in it
    * @param ext extension of the file or <CODE>null</CODE> if one needs
    *    a package and not a file name
    *
    * @return {@link FileObject} that represents file with given name or
    *   <CODE>null</CODE> if the file does not exist
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public final FileObject find(String aPackage, String name, String ext) {
        Enumeration<? extends FileSystem> en = fileSystems();

        while (en.hasMoreElements()) {
            FileSystem fs = en.nextElement();
            FileObject fo = fs.find(aPackage, name, ext);

            if (fo != null) {
                // object found
                return fo;
            }
        }

        return null;
    }

    /** Finds all files among all filesystems with this capability
    * that match a given name, returning all matches.
    * All filesystems are queried with {@link FileSystem#find}.
    *
    * @param aPackage package name where each package is separated by a dot
    * @param name name of the file (without dots) or <CODE>null</CODE> if
    *    one wants to obtain the name of a package and not a file in it
    * @param ext extension of the file or <CODE>null</CODE> if one needs
    *    a package and not a file name
    *
    * @return enumeration of {@link FileObject}s
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public final Enumeration<? extends FileObject> findAll(String aPackage, String name, String ext) {
        Enumeration<? extends FileSystem> en = fileSystems();
        Vector<FileObject> ret = new Vector<FileObject>();

        while (en.hasMoreElements()) {
            FileSystem fs = (FileSystem) en.nextElement();
            FileObject fo = fs.find(aPackage, name, ext);

            if (fo != null) {
                ret.addElement(fo);
            }
        }

        return ret.elements();
    }

    /** Adds PropertyChange listener. Every class which implements changes of capabilities
    * has to implement it's property change support.
    * @param l the listener to be added.
    */
    public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
    }

    /** Removes PropertyChange listener. Every class which implements changes of capabilities
    * has to implement it's property change support.
    * @param l the listener to be removed.
    */
    public void removePropertyChangeListener(PropertyChangeListener l) {
    }

    /** Default implementation of capabilities, that behaves like
    * JavaBean and allows to set whether the well known
    * capabilities (like compile, execute) should be enabled
    * or not.
     * @deprecated For the same reason the whole class is.
    */
    @Deprecated
    public static class Bean extends FileSystemCapability implements java.io.Serializable {
        static final long serialVersionUID = 627905674809532736L;

        /** change listeners */
        private transient PropertyChangeSupport supp;

        /** compilation */
        private boolean compilation = true;

        /** execution */
        private boolean execution = true;

        /** debugging */
        private boolean debug = true;

        /** doc */
        private boolean doc = false;

        /** Checks for well known capabilities and if they are allowed.
        *
        * @param c capability to test
        * @return true if yes
        */
        public boolean capableOf(FileSystemCapability c) {
            if (c == COMPILE) {
                return compilation;
            }

            if (c == EXECUTE) {
                return execution;
            }

            if (c == DEBUG) {
                return debug;
            }

            if (c == DOC) {
                return doc;
            }

            if (c == ALL) {
                return true;
            }

            if (!(c instanceof Bean)) {
                return false;
            }

            // try match of values
            Bean b = (Bean) c;

            return (compilation == b.compilation) && (execution == b.execution) && (debug == b.debug) &&
            (doc == b.doc);
        }

        /** Getter for value of compiling capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public boolean getCompile() {
            return compilation;
        }

        /** Setter for allowing compiling capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public void setCompile(boolean val) {
            if (val != compilation) {
                compilation = val;

                if (supp != null) {
                    supp.firePropertyChange(
                        "compile", // NOI18N
                        (!val) ? Boolean.TRUE : Boolean.FALSE, val ? Boolean.TRUE : Boolean.FALSE
                    );
                }
            }
        }

        /** Getter for value of executiong capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public boolean getExecute() {
            return execution;
        }

        /** Setter for allowing executing capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public void setExecute(boolean val) {
            if (val != execution) {
                execution = val;

                if (supp != null) {
                    supp.firePropertyChange(
                        "execute", // NOI18N
                        (!val) ? Boolean.TRUE : Boolean.FALSE, val ? Boolean.TRUE : Boolean.FALSE
                    );
                }
            }
        }

        /** Getter for value of debugging capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public boolean getDebug() {
            return debug;
        }

        /** Setter for allowing debugging capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public void setDebug(boolean val) {
            if (val != debug) {
                debug = val;

                if (supp != null) {
                    supp.firePropertyChange(
                        "debug", // NOI18N
                        (!val) ? Boolean.TRUE : Boolean.FALSE, val ? Boolean.TRUE : Boolean.FALSE
                    );
                }
            }
        }

        /** Getter for value of doc capability.
         * @deprecated Please use <a href="@org-netbeans-api-java@/org/netbeans/api/queries/JavadocForBinaryQuery.html"><code>JavadocForBinaryQuery</code></a> instead.
        */
        @Deprecated
        public boolean getDoc() {
            return doc;
        }

        /** Setter for allowing debugging capability.
         * @deprecated Please use <a href="@org-netbeans-api-java@/org/netbeans/api/queries/JavadocForBinaryQuery.html"><code>JavadocForBinaryQuery</code></a> instead.
        */
        @Deprecated
        public void setDoc(boolean val) {
            if (val != doc) {
                doc = val;

                if (supp != null) {
                    supp.firePropertyChange(
                        "doc", // NOI18N
                        (!val) ? Boolean.TRUE : Boolean.FALSE, val ? Boolean.TRUE : Boolean.FALSE
                    );
                }
            }
        }

        public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
            if (supp == null) {
                supp = new PropertyChangeSupport(this);
            }

            supp.addPropertyChangeListener(l);
        }

        public void removePropertyChangeListener(PropertyChangeListener l) {
            if (supp != null) {
                supp.removePropertyChangeListener(l);
            }
        }
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.openide.filesystems;

import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.util.Set;
import org.openide.modules.PatchFor;
import org.openide.util.actions.SystemAction;

/**
 * The class provides an API compatibility bridge to support implementations
 * compiled against <code>org.openide.filesystems&lt;8.0</code> and earlier
 *
 * @author sdedic
 */
@PatchFor(FileSystem.class)
public abstract class FileSystemCompat {
    /** Property name giving capabilities state. @deprecated No more capabilities. */
    static final String PROP_CAPABILITIES = "capabilities"; // NOI18N    

    /** hidden flag */
    private boolean hidden = false;

    /** Describes capabilities of the filesystem.
    */
    @Deprecated // have to store it for compat
    private /* XXX JDK #6460147: javac still reports it even though @Deprecated,
               and @SuppressWarnings("deprecation") does not help either: FileSystemCapability*/Object capability;

    /** property listener on FileSystemCapability. */
    private transient PropertyChangeListener capabilityListener;

    /** Returns an array of actions that can be invoked on any file in
    * this filesystem.
    * These actions should preferably
    * support the {@link org.openide.util.actions.Presenter.Menu Menu},
    * {@link org.openide.util.actions.Presenter.Popup Popup},
    * and {@link org.openide.util.actions.Presenter.Toolbar Toolbar} presenters.
    *
    * @return array of available actions
    */
    public abstract SystemAction[] getActions();

    /**
     * Get actions appropriate to a certain file selection.
     * By default, returns the same list as {@link #getActions()}.
     * @param foSet one or more files which may be selected
     * @return zero or more actions appropriate to those files
     */
    public SystemAction[] getActions(Set<FileObject> foSet) {
        return this.getActions();
    }

    /** Allows filesystems to set up the environment for external execution
    * and compilation.
    * Each filesystem can add its own values that
    * influence the environment. The set of operations that can modify
    * environment is described by the {@link Environment} interface.
    * <P>
    * The default implementation throws an exception to signal that it does not
    * support external compilation or execution.
    *
    * @param env the environment to setup
    * @exception EnvironmentNotSupportedException if external execution
    *    and compilation cannot be supported
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public void prepareEnvironment(FileSystem$Environment env) throws EnvironmentNotSupportedException {
        Object o = this;
        throw new EnvironmentNotSupportedException((FileSystem)o);
    }
    
    /**
     * Provides access to deprecated methods at runtime.
     * 
     * @param fs The FileSystem
     * @return the FileSystemCompat instanceo for the FileSystem.
     */
    public static FileSystemCompat compat(FileSystem fs) {
        Object o = fs;
        return (FileSystemCompat)o;
    }
    
    private FileSystem fs() {
        Object o = this;
        return (FileSystem)o;
    }

    /** The object describing capabilities of this filesystem.
     * Subclasses cannot override it.
     * @return object describing capabilities of this filesystem.
     * @deprecated Capabilities are no longer used.
     */
    @Deprecated
    public final FileSystemCapability getCapability() {
        if (capability == null) {
            capability = new FileSystemCapability.Bean();
            ((FileSystemCapability) capability).addPropertyChangeListener(getCapabilityChangeListener());
        }

        return (FileSystemCapability) capability;
    }

    /** Allows subclasses to change a set of capabilities of the
    * filesystem.
    * @param capability the capability to use
     * @deprecated Capabilities are no longer used.
    */
    @Deprecated
    protected final void setCapability(FileSystemCapability capability) {
        if (this.capability != null) {
            ((FileSystemCapability) this.capability).removePropertyChangeListener(getCapabilityChangeListener());
        }

        this.capability = capability;

        if (this.capability != null) {
            ((FileSystemCapability) this.capability).addPropertyChangeListener(getCapabilityChangeListener());
        }
    }

    /** returns property listener on FileSystemCapability. */
    private synchronized PropertyChangeListener getCapabilityChangeListener() {
        if (capabilityListener == null) {
            capabilityListener = new PropertyChangeListener() {
                        public void propertyChange(java.beans.PropertyChangeEvent propertyChangeEvent) {
                            firePropertyChange(
                                PROP_CAPABILITIES, propertyChangeEvent.getOldValue(), propertyChangeEvent.getNewValue()
                            );
                        }
                    };
        }

        return capabilityListener;
    }
    
    abstract void firePropertyChange(String s, Object o, Object n);

    /** Reads object from stream and creates listeners.
    * @param in the input stream to read from
    * @exception IOException error during read
    * @exception ClassNotFoundException when class not found
    */
    @SuppressWarnings("deprecation")
    private void readObject(java.io.ObjectInputStream in)
    throws java.io.IOException, java.lang.ClassNotFoundException {
        in.defaultReadObject();

        if (capability != null) {
            ((FileSystemCapability) capability).addPropertyChangeListener(getCapabilityChangeListener());
        }
    }

    /** Set hidden state of the object.
     * A hidden filesystem is not presented to the user in the Repository list (though it may be present in the Repository Settings list).
    *
    * @param hide <code>true</code> if the filesystem should be hidden
     * @deprecated This property is now useless.
    */
    @Deprecated
    public final void setHidden(boolean hide) {
        if (hide != hidden) {
            hidden = hide;
            firePropertyChange(FileSystem.PROP_HIDDEN, (!hide) ? Boolean.TRUE : Boolean.FALSE, hide ? Boolean.TRUE : Boolean.FALSE);
        }
    }

    /** Getter for the hidden property.
     * @return the hidden property.
     * @deprecated This property is now useless.
    */
    @Deprecated
    public final boolean isHidden() {
        return hidden;
    }

    /** Tests whether filesystem will survive reloading of system pool.
    * If true then when
    * {@link Repository} is reloading its content, it preserves this
    * filesystem in the pool.
    * <P>
    * This can be used when the pool contains system level and user level
    * filesystems. The system ones should be preserved when the user changes
    * the content (for example when he is loading a new project).
    * <p>The default implementation returns <code>false</code>.
    *
    * @return true if the filesystem should be persistent
     * @deprecated This property is long since useless.
    */
    @Deprecated
    protected boolean isPersistent() {
        return false;
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.openide.filesystems;

import java.io.File;
import java.io.IOException;
import org.openide.modules.ConstructorDelegate;
import org.openide.modules.PatchFor;

/**
 * Support for compatibility with NB 8.0 and earlier.
 * 
 * @author sdedic
 */
@PatchFor(JarFileSystem.class)
public abstract class JarFileSystemCompat extends AbstractFileSystem {
    public JarFileSystemCompat() {
        super();
    }
    
    @ConstructorDelegate
    public static void createJarFileSystemCompat(JarFileSystemCompat jfs, FileSystemCapability cap) throws IOException {
        FileSystemCompat.compat(jfs).setCapability(cap);
    }
    
    /** Prepare environment for external compilation or execution.
    * <P>
    * Adds name of the ZIP/JAR file, if it has been set, to the class path.
     * @deprecated Useless.
    */
    @Deprecated
    public void prepareEnvironment(FileSystem$Environment env) {
        if (getJarFile() != null) {
            env.addClassPath(getJarFile().getAbsolutePath());
        }
    }
    
    public abstract File getJarFile();
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.openide.filesystems;

import java.io.File;
import org.openide.modules.ConstructorDelegate;
import org.openide.modules.PatchFor;

/**
 *
 * @author sdedic
 */
@PatchFor(LocalFileSystem.class)
public abstract class LocalFileSystemCompat extends AbstractFileSystem {
    public LocalFileSystemCompat() {
        
    }
    
    @ConstructorDelegate
    public static void createLocalFileSystemCompat(LocalFileSystemCompat self, FileSystemCapability cap) {
        FileSystemCompat.compat(self).setCapability(cap);
    }
    
    /** Prepare environment by adding the root directory of the filesystem to the class path.
    * @param environment the environment to add to
     * @deprecated Useless.
    */
    @Deprecated
    public void prepareEnvironment(FileSystem$Environment environment) {
        environment.addClassPath(getRootDirectory().getAbsolutePath());
    }
    
    public abstract File getRootDirectory();
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.openide.filesystems;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.openide.modules.PatchFor;
import org.openide.util.actions.SystemAction;

/**
 *
 * @author sdedic
 */
@PatchFor(MultiFileSystem.class)
public abstract class MultiFileSystemCompat extends FileSystem {
    /** Merge actions from all delegates.
    */
    public SystemAction[] getActions() {
        List<SystemAction> al = new ArrayList<SystemAction>(101); // randomly choosen constant
        Set<SystemAction> uniq = new HashSet<SystemAction>(101); // not that randommly choosen

        FileSystem[] del = this.getDelegates();

        for (int i = 0; i < del.length; i++) {
            if (del[i] == null) {
                continue;
            }

            SystemAction[] acts = compat(del[i]).getActions();

            for (int j = 0; j < acts.length; j++) {
                if (uniq.add(acts[j])) {
                    al.add(acts[j]);
                }
            }
        }

        return al.toArray(new SystemAction[al.size()]);
    }

    public SystemAction[] getActions(final Set<FileObject> foSet) {
        List<SystemAction> al = new ArrayList<SystemAction>(101); // randomly choosen constant
        Set<SystemAction> uniq = new HashSet<SystemAction>(101); // not that randommly choosen

        final FileSystem[] del = this.getDelegates();

        for (int i = 0; i < del.length; i++) {
            if (del[i] == null) {
                continue;
            }

            final SystemAction[] acts = compat(del[i]).getActions(foSet);

            for (int j = 0; j < acts.length; j++) {
                if (uniq.add(acts[j])) {
                    al.add(acts[j]);
                }
            }
        }

        return al.toArray(new SystemAction[al.size()]);
    }
    
    static FileSystemCompat compat(FileSystem fs) {
        Object o = fs;
        return (FileSystemCompat)o;
    }

    /** Lets any sub filesystems prepare the environment.
     * If they do not support it, it does not care.
     * @deprecated Useless.
     */
    @Deprecated
    public void prepareEnvironment(FileSystem$Environment env)
    throws EnvironmentNotSupportedException {
        FileSystem[] layers = getDelegates();

        for (int i = 0; i < layers.length; i++) {
            if (layers[i] != null) {
                try {
                    compat(layers[i]).prepareEnvironment(env);
                } catch (EnvironmentNotSupportedException ense) {
                    // Fine.
                }
            }
        }
    }

    protected abstract FileSystem[] getDelegates();
}

Line 0 Link Here

(-)a/openide.filesystems.compat8/src/org/openide/filesystems/compat8/Bundle.properties (+6 lines)
	1	OpenIDE-Module-Display-Category=Infrastructure
	2	OpenIDE-Module-Long-Description=\
	3	After NetBeans 8.0 release, deprecated and obsolete features were removed from the FileSystem API mainline. \
	4	To preserve binary compatibility, implementations from this module are injected at runtime into Filesystem API classes to allow modules compiled against older version of FileSystem API to run
	5	OpenIDE-Module-Name=Filesystems API 8.0 Compatibility
	6	OpenIDE-Module-Short-Description=Support for FileSystem backward compatibility with NetBeans 8.0

Line 0 Link Here

(-)a/openide.filesystems.nb/build.xml (+5 lines)
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<project basedir="." default="netbeans" name="openide.filesystems.nb">
	3	<description>Builds, tests, and runs the project openide.filesystems.nb</description>
	4	<import file="../nbbuild/templates/projectized.xml"/>
	5	</project>

Line 0 Link Here

(-)a/openide.filesystems.nb/manifest.mf (+5 lines)
	1	Manifest-Version: 1.0
	2	OpenIDE-Module: org.openide.filesystems.nb
	3	OpenIDE-Module-Localizing-Bundle: org/openide/filesystems/nb/Bundle.properties
	4	OpenIDE-Module-Specification-Version: 9.0
	5

Line 0 Link Here

(-)a/openide.filesystems.nb/nbproject/project.properties (+2 lines)
	1	javac.source=1.6
	2	javac.compilerargs=-Xlint -Xlint:-serial




<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.netbeans.org/ns/project/1">
    <type>org.netbeans.modules.apisupport.project</type>
    <configuration>
        <data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
            <code-name-base>org.openide.filesystems.nb</code-name-base>
            <module-dependencies>
                <dependency>
                    <code-name-base>org.openide.filesystems</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.base</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.lookup</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>8.0</specification-version>
                    </run-dependency>
                </dependency>
            </module-dependencies>
            <test-dependencies>
                <test-type>
                    <name>unit</name>
                    <test-dependency>
                        <code-name-base>org.netbeans.libs.junit4</code-name-base>
                        <compile-dependency/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.netbeans.modules.nbjunit</code-name-base>
                        <recursive/>
                        <compile-dependency/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.openide.filesystems</code-name-base>
                        <recursive/>
                        <compile-dependency/>
                        <test/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.openide.util.lookup</code-name-base>
                        <compile-dependency/>
                        <test/>
                    </test-dependency>
                </test-type>
            </test-dependencies>
            <public-packages>
                <package>org.openide.filesystems</package>
            </public-packages>
        </data>
    </configuration>
</project>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 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 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.openide.filesystems;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.filechooser.FileFilter;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;

/**
 * Support methods for creation of registered {@link FileFilter file filters}.
 */
public final class FileFilterSupport {

    /**
     * The logger.
     */
    private static final Logger LOG = Logger.getLogger(
            FileFilterSupport.class.getName());

    /**
     * Hide the default constructor.
     */
    private FileFilterSupport() {
    }

    /**
     * Construct description for {@link FileFilter} that accepts files with
     * specified extension.
     *
     * @param displayName Human readable display name (e.g. "HTML files")
     * @param elements List of accepted filter elements.
     *
     * @return Display name (description) for the filter.
     */
    private static String constructFilterDisplayName(String displayName,
            List<FilterElement> elements) {
        StringBuilder sb = new StringBuilder(displayName);
        boolean first = true;
        sb.append(" [");                                                //NOI18N
        for (FilterElement el : elements) {
            if (first) {
                first = false;
            } else {
                sb.append(", ");                                        //NOI18N
            }
            sb.append(el.getName());
        }
        sb.append("]");                                                 //NOI18N
        return sb.toString();
    }

    /**
     * Check whether passed file is accepted by filter for specified list of
     * extensions.
     *
     * @param file File to be accepted or rejected.
     * @param elements List of accepted filter elements.
     *
     * @return True if the file is accepted, false if it is rejected.
     *
     * @see FileFilterSupport
     */
    private static boolean accept(File file, List<FilterElement> elements) {
        if (file != null) {
            if (file.isDirectory()) {
                return true;
            }
            for (FilterElement elm : elements) {
                if (elm.accept(file)) {
                    return true;
                }
            }
        }
        return false;
    }

    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);
    }

    private static FileFilter createFilter(final String name,
            final Set<FileObject> resolvers) {
        ArrayList<FilterElement> elems = new ArrayList<FilterElement>(3);
        String lastAtt;
        for (FileObject fo : resolvers) {
            int i = 0;
            while ((lastAtt = (String) fo.getAttribute(
                    "ext." + i)) != null) { //NOI18N
                addExtensionToList(elems, lastAtt);
                i++;
            }
            int n = 0;
            while ((lastAtt = (String) fo.getAttribute("fileName." //NOI18N
                    + (n++))) != null) {
                addNameToList(elems, lastAtt);
            }
            String type;
            if ((type = (String) fo.getAttribute("mimeType")) != null) {//NOI18N
                addMimeTypeExts(elems, type);
            }
            int t = 0;
            while ((type = (String) fo.getAttribute(
                    "mimeType." + (t++))) != null) {     //NOI18N
                addMimeTypeExts(elems, type);
            }
        }
        sortFilterElements(elems);
        return new FileFilterImpl(name, elems);
    }

    /**
     * Add all extensions assigned to a MIME Type to the extension list.
     */
    private static void addMimeTypeExts(List<FilterElement> exts, String type) {
        addAllExtensionsToList(exts, FileUtil.getMIMETypeExtensions(type));
    }

    /**
     * Add new items to list of extensions, prevent duplicates.
     *
     * @param list List of extensions to alter.
     * @param toAdd List of extensions (without starting dot) to add.
     */
    private static void addAllExtensionsToList(List<FilterElement> list,
            List<String> toAdd) {
        for (String s : toAdd) {
            addExtensionToList(list, s);
        }
    }

    /**
     * Add new item to list of extensions, prevent duplacates.
     *
     * @param list List of extensions to alter.
     * @param s Extensions without starting dot.
     */
    private static void addExtensionToList(List<FilterElement> list,
            String ext) {
        addFilterElementToList(list, FilterElement.createForExtension(ext));
    }

    private static void addNameToList(List<FilterElement> list, String name) {
        Pattern p = Pattern.compile(
                "\\[([^,]+), (true|false), (true|false)\\](\\S*)");     //NOI18N
        Matcher m = p.matcher(name);
        if (m.find()) {
            String fileName = m.group(1);
            boolean substring = m.group(2).equals("true");              //NOI18N
            boolean ignoreCase = m.group(3).equals("true");             //NOI18N
            String extension = m.group(4);
            addFilterElementToList(list, FilterElement.createForFileName(
                    fileName, extension, substring, ignoreCase));
        } else {
            LOG.log(Level.INFO, "Incorrect name pattern {0}", name);    //NOI18N
        }
    }

    private static void addFilterElementToList(List<FilterElement> list,
            FilterElement newItem) {

        for (int i = 0; i < list.size(); i++) {
            FilterElement el = list.get(i);
            FilterElement.ComparisonResult result = newItem.compare(el);
            switch (result) {
                case DIFFERENT:
                    continue;
                case THE_SAME:
                case WORSE:
                    return;
                case BETTER:
                    list.set(i, newItem);
                    return;
            }
        }
        list.add(newItem);
    }

    private static List<FileFilter> sortFiltersByDescription(
            List<FileFilter> list) {

        Collections.sort(list, new Comparator<FileFilter>() {
            @Override
            public int compare(FileFilter o1, FileFilter o2) {
                return o1.getDescription().compareTo(o2.getDescription());
            }
        });
        return list;
    }

    private static List<FilterElement> sortFilterElements(
            List<FilterElement> elements) {
        Collections.sort(elements, new Comparator<FilterElement>() {
            @Override
            public int compare(FilterElement o1, FilterElement o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        return elements;
    }

    private static class FileFilterImpl extends FileFilter {

        private final String name;
        List<FilterElement> filterElements;

        public FileFilterImpl(String name, List<FilterElement> elements) {
            this.name = name;
            this.filterElements = elements;
        }

        @Override
        public boolean accept(File pathname) {
            return FileFilterSupport.accept(pathname, filterElements);
        }

        @Override
        public String getDescription() {
            return FileFilterSupport.constructFilterDisplayName(
                    name, filterElements);
        }
    }

    /**
     * Element of File Filter. One accepted extension or file name pattern.
     */
    private static abstract class FilterElement {

        public abstract String getName();

        public abstract boolean accept(File f);

        /**
         * Compare two filter elements. Correct implementation of this method
         * prevents adding duplicite elements to the filter.
         */
        public abstract ComparisonResult compare(FilterElement e);

        public static FilterElement createForExtension(String ext) {
            return new ExtensionBasedFilterElement(ext);
        }

        public static FilterElement createForFileName(String name,
                String extension, boolean substring, boolean ignoreCase) {
            return new NameBasedFilterElement(name, extension,
                    substring, ignoreCase);
        }

        public static enum ComparisonResult {

            THE_SAME, BETTER, WORSE, DIFFERENT
        }

        private static class ExtensionBasedFilterElement extends FilterElement {

            private final String extension;

            public ExtensionBasedFilterElement(String extension) {
                if (extension != null) {
                    this.extension = extension;
                } else {
                    throw new NullPointerException();
                }
            }

            @Override
            public String getName() {
                return "." + extension;                                 //NOI18N
            }

            @Override
            public boolean accept(File f) {
                return f.getName().toLowerCase().endsWith(
                        "." + extension.toLowerCase());                 //NOI18N
            }

            @Override
            public ComparisonResult compare(FilterElement e) {
                if (!(e instanceof ExtensionBasedFilterElement)) {
                    return ComparisonResult.DIFFERENT;
                }
                ExtensionBasedFilterElement x = (ExtensionBasedFilterElement) e;
                if (x == null) {
                    throw new NullPointerException();
                }
                if (this.extension.equals(x.extension)) {
                    return ComparisonResult.THE_SAME;
                } else if (this.extension.equalsIgnoreCase(x.extension)
                        && this.extension.length() > 1) {
                    if (Character.isUpperCase(x.extension.charAt(0))) {
                        return ComparisonResult.BETTER; //this better, x worse
                    } else {
                        return ComparisonResult.WORSE; // this worse, x better
                    }
                } else {
                    return ComparisonResult.DIFFERENT;
                }
            }
        }

        private static class NameBasedFilterElement extends FilterElement {

            String name;
            String ext;
            boolean substring;
            boolean ignoreCase;
            Pattern p;

            public NameBasedFilterElement(String name, String ext,
                    boolean substring, boolean ignoreCase) {
                this.name = name;
                this.ext = ext;
                this.substring = substring;
                this.ignoreCase = ignoreCase;
                StringBuilder sb = new StringBuilder();
                if (ignoreCase) {
                    sb.append("(?i)");                                  //NOI18N
                }
                if (substring) {
                    sb.append(".*");                                    //NOI18N
                }
                sb.append(name);                                        //NOI18N
                if (substring) {
                    sb.append(".*");                                    //NOI18N
                }
                if (!ext.isEmpty()) {
                    sb.append("\\.");                                   //NOI18N
                    sb.append(ext);
                }
                p = Pattern.compile(sb.toString());
            }

            @Override
            public String getName() {
                return name + (ext.isEmpty() ? "" : "." + ext);         //NOI18N
            }

            @Override
            public boolean accept(File f) {
                return p.matcher(f.getName()).matches();
            }

            @Override
            public ComparisonResult compare(FilterElement e) {
                if (e == null) {
                    throw new NullPointerException();
                } else if (!(e instanceof NameBasedFilterElement)) {
                    return ComparisonResult.DIFFERENT;
                }
                NameBasedFilterElement x = (NameBasedFilterElement) e;
                if (this.name.equals(x.name) && this.ext.equals(x.ext)) {
                    if (this.substring == x.substring
                            && this.ignoreCase == x.ignoreCase) {
                        return ComparisonResult.THE_SAME;
                    } else {
                        return compareFlags(x);
                    }
                } else if (this.ext.equalsIgnoreCase(x.ext)
                        && this.name.equalsIgnoreCase(x.name)
                        && (this.ignoreCase || x.ignoreCase)) {
                    if (this.substring == x.substring
                            && this.ignoreCase == x.ignoreCase) {
                        if (Character.isLowerCase(this.name.charAt(0))) {
                            return ComparisonResult.BETTER;
                        } else {
                            return ComparisonResult.WORSE;
                        }
                    } else {
                        return compareFlags(x);
                    }
                } else {
                    return ComparisonResult.DIFFERENT;
                }
            }

            private ComparisonResult compareFlags(NameBasedFilterElement x) {
                if (this.substring == x.substring
                        && this.ignoreCase) {
                    return ComparisonResult.BETTER;
                } else if (this.ignoreCase == x.ignoreCase
                        && this.substring) {
                    return ComparisonResult.BETTER;
                } else if (this.substring != x.substring
                        && this.ignoreCase != x.ignoreCase) {
                    return ComparisonResult.DIFFERENT;
                } else {
                    return ComparisonResult.WORSE;
                }
            }
        }
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.netbeans.modules.openide.filesystems;

import java.awt.Image;
import java.awt.Toolkit;
import java.beans.BeanInfo;
import java.net.URL;
import java.util.Arrays;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.util.BaseUtilities;
import org.openide.util.Exceptions;
import org.openide.util.ImageUtilities;
import org.openide.util.NbBundle;
import org.openide.util.lookup.ServiceProvider;

/**
 *
 * @author sdedic
 */
@ServiceProvider(service = FileSystem.Status.class)
public final class FileSystemStatus implements FileSystem.Status{
    private static final Logger LOG = Logger.getLogger(FileSystemStatus.class.getName());
    
    public String annotateName(String s, Set<? extends FileObject> files) {
        // Look for a localized file name.
        // Note: all files in the set are checked. But please only place the attribute
        // on the primary file, and use this primary file name as the bundle key.
        for (FileObject fo : files) {
            // annotate a name
            String displayName = annotateName(fo);
            if (displayName != null) {
                return displayName;
            }
        }
        return s;
    }

    private final String annotateName(FileObject fo) {
        String bundleName = (String) fo.getAttribute("SystemFileSystem.localizingBundle"); // NOI18N
        if (bundleName != null) {
            try {
                bundleName = BaseUtilities.translate(bundleName);
                ResourceBundle b = NbBundle.getBundle(bundleName);
                try {
                    return b.getString(fo.getPath());
                } catch (MissingResourceException ex) {
                    // ignore--normal
                }
            } catch (MissingResourceException ex) {
                Exceptions.attachMessage(ex, warningMessage(bundleName, fo));
                LOG.log(Level.INFO, null, ex);
                // ignore
            }
        }
        return (String) fo.getAttribute("displayName"); // NOI18N
    }

    private String warningMessage(String name, FileObject fo) {
        Object by = fo.getAttribute("layers"); // NOI18N
        if (by instanceof Object[]) {
            by = Arrays.toString((Object[]) by);
        }
        return "Cannot load " + name + " for " + fo + " defined by " + by; // NOI18N
    }

    public Image annotateIcon(Image im, int type, Set<? extends FileObject> files) {
        for (FileObject fo : files) {
            Image img = annotateIcon(fo, type);
            if (img != null) {
                return img;
            }
        }
        return im;
    }

    private Image annotateIcon(FileObject fo, int type) {
        String attr = null;
        if (type == BeanInfo.ICON_COLOR_16x16) {
            attr = "SystemFileSystem.icon"; // NOI18N
        } else if (type == BeanInfo.ICON_COLOR_32x32) {
            attr = "SystemFileSystem.icon32"; // NOI18N
        }
        if (attr != null) {
            Object value = fo.getAttribute(attr);
            if (value != null) {
                if (value instanceof URL) {
                    return Toolkit.getDefaultToolkit().getImage((URL) value);
                } else if (value instanceof Image) {
                    // #18832
                    return (Image) value;
                } else {
                    LOG.warning("Attribute " + attr + " on " + fo + " expected to be a URL or Image; was: " + value);
                }
            }
        }
        String base = (String) fo.getAttribute("iconBase"); // NOI18N
        if (base != null) {
            if (type == BeanInfo.ICON_COLOR_16x16) {
                return ImageUtilities.loadImage(base, true);
            } else if (type == BeanInfo.ICON_COLOR_32x32) {
                return ImageUtilities.loadImage(insertBeforeSuffix(base, "_32"), true); // NOI18N
            }
        }
        return null;
    }

    private String insertBeforeSuffix(String path, String toInsert) {
        String withoutSuffix = path;
        String suffix = ""; // NOI18N
        if (path.lastIndexOf('.') >= 0) {
            withoutSuffix = path.substring(0, path.lastIndexOf('.'));
            suffix = path.substring(path.lastIndexOf('.'), path.length());
        }
        return withoutSuffix + toInsert + suffix;
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.netbeans.modules.openide.filesystems;

import org.openide.filesystems.spi.CustomInstanceFactory;
import org.openide.util.SharedClassObject;
import org.openide.util.lookup.ServiceProvider;

/**
 * Handles creation of SharedClassObjects for Filesystems API.
 * 
 * @author sdedic
 */
@ServiceProvider(service = CustomInstanceFactory.class)
public final class SharedClassObjectFactory implements CustomInstanceFactory {

    @Override
    public <T> T createInstance(Class<T> clazz) {
        if (SharedClassObject.class.isAssignableFrom(clazz)) {
            return (T)SharedClassObject.findObject(clazz.asSubclass(SharedClassObject.class), true);
        } else {
            return null;
        }
    }
    
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 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.openide.filesystems;

import java.awt.Component;
import java.awt.FileDialog;
import java.awt.Frame;
import java.awt.HeadlessException;
import java.awt.KeyboardFocusManager;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import javax.swing.Icon;
import javax.swing.JFileChooser;
import javax.swing.SwingUtilities;
import javax.swing.filechooser.FileFilter;
import javax.swing.filechooser.FileSystemView;
import javax.swing.filechooser.FileView;
import org.netbeans.modules.openide.filesystems.FileFilterSupport;
import org.openide.filesystems.FileUtil;
import org.openide.util.*;

/**
 * Utility class for working with JFileChoosers.  In particular, remembering
 * the last-used directory for a given file is made transparent.  You pass an
 * ad-hoc string key to the constructor (the fully qualified name of the
 * calling class is good for uniqueness, and there is a constructor that takes
 * a <code>Class</code> object as an argument for this purpose).  That key is
 * used to look up the most recently-used directory from any previous invocations
 * with the same key.  This makes it easy to have your user interface
 * &ldquo;remember&rdquo; where the user keeps particular types of files, and
 * saves the user from having to navigate through the same set of directories
 * every time they need to locate a file from a particular place.
 * <p/>
 * <code>FileChooserBuilder</code>'s methods each return <code>this</code>, so
 * it is possible to chain invocations to simplify setting up a file chooser.
 * Example usage:
 * <pre>
 *      <font color="gray">//The default dir to use if no value is stored</font>
 *      File home = new File (System.getProperty("user.home") + File.separator + "lib");
 *      <font color="gray">//Now build a file chooser and invoke the dialog in one line of code</font>
 *      <font color="gray">//&quot;libraries-dir&quot; is our unique key</font>
 *      File toAdd = new FileChooserBuilder ("libraries-dir").setTitle("Add Library").
 *              setDefaultWorkingDirectory(home).setApproveText("Add").showOpenDialog();
 *      <font color="gray">//Result will be null if the user clicked cancel or closed the dialog w/o OK</font>
 *      if (toAdd != null) {
 *          //do something
 *      }
 *</pre>
 * <p/>
 * Instances of this class are intended to be thrown away after use.  Typically
 * you create a builder, set it to create file choosers as you wish, then
 * use it to show a dialog or create a file chooser you then do something
 * with.
 * <p/>
 * Supports the most common subset of JFileChooser functionality;  if you
 * need to do something exotic with a file chooser, you are probably better
 * off creating your own.
 * <p/>
 * <b>Note:</b> If you use the constructor that takes a <code>Class</code> object,
 * please use <code>new FileChooserBuilder(MyClass.class)</code>, not
 * <code>new FileChooserBuilder(getClass())</code>.  This avoids unexpected
 * behavior in the case of subclassing.
 *
 * @author Tim Boudreau
 */
public class FileChooserBuilder {
    private boolean dirsOnly;
    private BadgeProvider badger;
    private String title;
    private String approveText;
    //Just in case...
    private static boolean PREVENT_SYMLINK_TRAVERSAL =
            !Boolean.getBoolean("allow.filechooser.symlink.traversal"); //NOI18N
    private final String dirKey;
    private File failoverDir;
    private FileFilter filter;
    private boolean fileHiding;
    private boolean controlButtonsShown = true;
    private String aDescription;
    private boolean filesOnly;
    private static final boolean DONT_STORE_DIRECTORIES =
            Boolean.getBoolean("forget.recent.dirs");
    private SelectionApprover approver;
    private final List<FileFilter> filters = new ArrayList<FileFilter>(3);
    private boolean useAcceptAllFileFilter = true;
    /**
     * Create a new FileChooserBuilder using the name of the passed class
     * as the metadata for looking up a starting directory from previous
     * application sessions or invocations.
     * @param type A non-null class object, typically the calling class
     */
    public FileChooserBuilder(Class type) {
        this(type.getName());
    }

    /**
     * Create a new FileChooserBuilder.  The passed key is used as a key
     * into NbPreferences to look up the directory the file chooser should
     * initially be rooted on.
     *
     * @param dirKey A non-null ad-hoc string.  If a FileChooser was previously
     * used with the same string as is passed, then the initial directory
     */
    public FileChooserBuilder(String dirKey) {
        Parameters.notNull("dirKey", dirKey);
        this.dirKey = dirKey;
    }

    /**
     * Set whether or not any file choosers created by this builder will show
     * only directories.
     * @param val true if files should not be shown
     * @return this
     */
    public FileChooserBuilder setDirectoriesOnly(boolean val) {
        dirsOnly = val;
        assert !filesOnly : "FilesOnly and DirsOnly are mutually exclusive";
        return this;
    }

    public FileChooserBuilder setFilesOnly(boolean val) {
        filesOnly = val;
        assert !dirsOnly : "FilesOnly and DirsOnly are mutually exclusive";
        return this;
    }

    /**
     * Provide an implementation of BadgeProvider which will "badge" the
     * icons of some files.
     *
     * @param provider A badge provider which will alter the icon of files
     * or folders that may be of particular interest to the user
     * @return this
     */
    public FileChooserBuilder setBadgeProvider(BadgeProvider provider) {
        this.badger = provider;
        return this;
    }

    /**
     * Set the dialog title for any JFileChoosers created by this builder.
     * @param val A localized, human-readable title
     * @return this
     */
    public FileChooserBuilder setTitle(String val) {
        title = val;
        return this;
    }

    /**
     * Set the text on the OK button for any file chooser dialogs produced
     * by this builder.
     * @param val A short, localized, human-readable string
     * @return this
     */
    public FileChooserBuilder setApproveText(String val) {
        approveText = val;
        return this;
    }

    /**
     * Set a file filter which filters the list of selectable files.
     * @param filter
     * @return this
     */
    public FileChooserBuilder setFileFilter (FileFilter filter) {
        this.filter = filter;
        return this;
    }

    /**
     * Determines whether the <code>AcceptAll FileFilter</code> is used
     * as an available choice in the choosable filter list.
     * If false, the <code>AcceptAll</code> file filter is removed from
     * the list of available file filters.
     * If true, the <code>AcceptAll</code> file filter will become the
     * the actively used file filter.
     * @param accept whether the <code>AcceptAll FileFilter</code> is used
     * @return this
     * @since 8.3
     */
    public FileChooserBuilder setAcceptAllFileFilterUsed(boolean accept) {
        useAcceptAllFileFilter = accept;
        return this;
    }

    /**
     * Set the current directory which should be used <b>only if</b>
     * a last-used directory cannot be found for the key string passed
     * into this builder's constructor.
     * @param dir A directory to root any created file choosers on if
     * there is no stored path for this builder's key
     * @return this
     */
    public FileChooserBuilder setDefaultWorkingDirectory (File dir) {
        failoverDir = dir;
        return this;
    }

    /**
     * Enable file hiding in any created file choosers
     * @param fileHiding Whether or not to hide files.  Default is no.
     * @return this
     */
    public FileChooserBuilder setFileHiding(boolean fileHiding) {
        this.fileHiding = fileHiding;
        return this;
    }

    /**
     * Show/hide control buttons
     * @param val Whether or not to hide files.  Default is no.
     * @return this
     */
    public FileChooserBuilder setControlButtonsAreShown(boolean val) {
        this.controlButtonsShown = val;
        return this;
    }

    /**
     * Set the accessible description for any file choosers created by this
     * builder
     * @param aDescription The description
     * @return this
     */
    public FileChooserBuilder setAccessibleDescription(String aDescription) {
        this.aDescription = aDescription;
        return this;
    }

    /**
     * Create a JFileChooser that conforms to the parameters set in this
     * builder.
     * @return A file chooser
     */
    public JFileChooser createFileChooser() {
        JFileChooser result = new SavedDirFileChooser(dirKey, failoverDir,
                force, approver);
        prepareFileChooser(result);
        return result;
    }

    private boolean force = false;
    /**
     * Force use of the failover directory - i.e. ignore the directory key
     * passed in.
     * @param val
     * @return this
     */
    public FileChooserBuilder forceUseOfDefaultWorkingDirectory(boolean val) {
        this.force = val;
        return this;
    }

    /**
     * Tries to find an appropriate component to parent the file chooser to
     * when showing a dialog.
     * @return this
     */
    private Component findDialogParent() {
        Component parent = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
        if (parent == null) {
            parent = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
        }
        if (parent == null) {
            Frame[] f = Frame.getFrames();
            parent = f.length == 0 ? null : f[f.length - 1];
        }
        return parent;
    }

    /**
     * Show an open dialog that allows multiple selection.
     * @return An array of files, or null if the user cancelled the dialog
     */
    public File[] showMultiOpenDialog() {
        JFileChooser chooser = createFileChooser();
        chooser.setMultiSelectionEnabled(true);
        int result = chooser.showOpenDialog(findDialogParent());
        if (JFileChooser.APPROVE_OPTION == result) {
            File[] files = chooser.getSelectedFiles();
            return files == null ? new File[0] : files;
        } else {
            return null;
        }
    }

    /**
     * Show an open dialog with a file chooser set up according to the
     * parameters of this builder.
     * @return A file if the user clicks the accept button and a file or
     * folder was selected at the time the user clicked cancel.
     */
    public File showOpenDialog() {
        JFileChooser chooser = createFileChooser();
        if( Boolean.getBoolean("nb.native.filechooser") ) { //NOI18N
            FileDialog fileDialog = createFileDialog( chooser.getCurrentDirectory() );
            if( null != fileDialog ) {
                return showFileDialog(fileDialog, FileDialog.LOAD );
            }
        }
        chooser.setMultiSelectionEnabled(false);
        int dlgResult = chooser.showOpenDialog(findDialogParent());
        if (JFileChooser.APPROVE_OPTION == dlgResult) {
            File result = chooser.getSelectedFile();
            if (result != null && !result.exists()) {
                result = null;
            }
            return result;
        } else {
            return null;
        }

    }

    /**
     * Show a save dialog with the file chooser set up according to the
     * parameters of this builder.
     * @return A file if the user clicks the accept button and a file or
     * folder was selected at the time the user clicked cancel.
     */
    public File showSaveDialog() {
        JFileChooser chooser = createFileChooser();
        if( Boolean.getBoolean("nb.native.filechooser") ) { //NOI18N
            FileDialog fileDialog = createFileDialog( chooser.getCurrentDirectory() );
            if( null != fileDialog ) {
                return showFileDialog( fileDialog, FileDialog.SAVE );
            }
        }
        int result = chooser.showSaveDialog(findDialogParent());
        if (JFileChooser.APPROVE_OPTION == result) {
            return chooser.getSelectedFile();
        } else {
            return null;
        }
    }
    
    private File showFileDialog( FileDialog fileDialog, int mode ) {
        String oldFileDialogProp = System.getProperty("apple.awt.fileDialogForDirectories"); //NOI18N
        if( dirsOnly ) {
            System.setProperty("apple.awt.fileDialogForDirectories", "true"); //NOI18N
        }
        fileDialog.setMode( mode );
        fileDialog.setVisible(true);
        if( dirsOnly ) {
            if( null != oldFileDialogProp ) {
                System.setProperty("apple.awt.fileDialogForDirectories", oldFileDialogProp); //NOI18N
            } else {
                System.clearProperty("apple.awt.fileDialogForDirectories"); //NOI18N
            }
        }
        if( fileDialog.getDirectory() != null && fileDialog.getFile() != null ) {
            String selFile = fileDialog.getFile();
            File dir = new File( fileDialog.getDirectory() );
            return new File( dir, selFile );
        }
        return null;
    }
    
    private void prepareFileChooser(JFileChooser chooser) {
        chooser.setFileSelectionMode(dirsOnly ? JFileChooser.DIRECTORIES_ONLY
                : filesOnly ? JFileChooser.FILES_ONLY :
                JFileChooser.FILES_AND_DIRECTORIES);
        chooser.setFileHidingEnabled(fileHiding);
        chooser.setControlButtonsAreShown(controlButtonsShown);
        chooser.setAcceptAllFileFilterUsed(useAcceptAllFileFilter);
        if (title != null) {
            chooser.setDialogTitle(title);
        }
        if (approveText != null) {
            chooser.setApproveButtonText(approveText);
        }
        if (badger != null) {
            chooser.setFileView(new CustomFileView(new BadgeIconProvider(badger),
                    chooser.getFileSystemView()));
        }
        if (PREVENT_SYMLINK_TRAVERSAL) {
            FileUtil.preventFileChooserSymlinkTraversal(chooser,
                    chooser.getCurrentDirectory());
        }
        if (filter != null) {
            chooser.setFileFilter(filter);
        }
        if (aDescription != null) {
            chooser.getAccessibleContext().setAccessibleDescription(aDescription);
        }
        if (!filters.isEmpty()) {
            for (FileFilter f : filters) {
                chooser.addChoosableFileFilter(f);
            }
        }
    }

    private FileDialog createFileDialog( File currentDirectory ) {
        if( badger != null )
            return null;
        if( !Boolean.getBoolean("nb.native.filechooser") )
            return null;
        if( dirsOnly && !BaseUtilities.isMac() )
            return null;
        Component parentComponent = findDialogParent();
        Frame parentFrame = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parentComponent);
        FileDialog fileDialog = new FileDialog(parentFrame);
        if (title != null) {
            fileDialog.setTitle(title);
        }
        if( null != currentDirectory )
            fileDialog.setDirectory(currentDirectory.getAbsolutePath());
        return fileDialog;
    }
    
    /**
     * Equivalent to calling <code>JFileChooser.addChoosableFileFilter(filter)</code>.
     * Adds another file filter that can be displayed in the file filters combo
     * box in the file chooser.
     *
     * @param filter The file filter to add
     * @return this
     * @since 7.26.0
     */
    public FileChooserBuilder addFileFilter (FileFilter filter) {
        filters.add (filter);
        return this;
    }

    /**
     * Add all default file filters to the file chooser.
     *
     * @see MIMEResolver.Registration#showInFileChooser()
     * @see MIMEResolver.ExtensionRegistration#showInFileChooser()
     * @return this
     * @since 8.1
     */
    public FileChooserBuilder addDefaultFileFilters() {
        filters.addAll(FileFilterSupport.findRegisteredFileFilters());
        return this;
    }

    /**
     * Set a selection approver which can display an &quot;Overwrite file?&quot;
     * or similar dialog if necessary, when the user presses the accept button
     * in the file chooser dialog.
     *
     * @param approver A SelectionApprover which will determine if the selection
     * is valid
     * @return this
     * @since 7.26.0
     */
    public FileChooserBuilder setSelectionApprover (SelectionApprover approver) {
        this.approver = approver;
        return this;
    }

    /**
     * Object which can approve the selection (enabling the OK button or
     * equivalent) in a JFileChooser.  Equivalent to overriding
     * <code>JFileChooser.approveSelection()</code>
     * @since 7.26.0
     */
    public interface SelectionApprover {
        /**
         * Approve the selection, enabling the dialog to be closed.  Called by
         * the JFileChooser's <code>approveSelection()</code> method.  Use this
         * interface if you want to, for example, show a dialog asking
         * &quot;Overwrite File X?&quot; or similar.
         *
         * @param selection The selected file(s) at the time the user presses
         * the Open, Save or OK button
         * @return true if the selection is accepted, false if it is not and
         * the dialog should not be closed
         */
        public boolean approve (File[] selection);
    }

    private static final class SavedDirFileChooser extends JFileChooser {
        private final String dirKey;
        private final SelectionApprover approver;
        SavedDirFileChooser(String dirKey, File failoverDir, boolean force, SelectionApprover approver) {
            this.dirKey = dirKey;
            this.approver = approver;
            if (force && failoverDir != null && failoverDir.exists() && failoverDir.isDirectory()) {
                setCurrentDirectory(failoverDir);
            } else {
                String path = DONT_STORE_DIRECTORIES ? null :
                    NbPreferences.forModule(FileChooserBuilder.class).get(dirKey, null);
                if (path != null) {
                    File f = new File(path);
                    if (f.exists() && f.isDirectory()) {
                        setCurrentDirectory(f);
                    } else if (failoverDir != null) {
                        setCurrentDirectory(failoverDir);
                    }
                } else if (failoverDir != null) {
                    setCurrentDirectory(failoverDir);
                }
            }
        }

        @Override
        public void approveSelection() {
            if (approver != null) {
                File[] selected = getSelectedFiles();
                final File sf = getSelectedFile();
                if ((selected == null || selected.length == 0) && sf != null) {
                    selected = new File[] { sf };
                }
                boolean approved = approver.approve(selected);
                if (approved) {
                    super.approveSelection();
                }
            } else {
                super.approveSelection();
            }
        }

        @Override
        public int showDialog(Component parent, String approveButtonText) throws HeadlessException {
            int result = super.showDialog(parent, approveButtonText);
            if (result == APPROVE_OPTION) {
                saveCurrentDir();
            }
            return result;
        }

        private void saveCurrentDir() {
            File dir = super.getCurrentDirectory();
            if (!DONT_STORE_DIRECTORIES && dir != null && dir.exists() && dir.isDirectory()) {
                NbPreferences.forModule(FileChooserBuilder.class).put(dirKey, dir.getPath());
            }
        }
    }

    //Can open this API later if there is a use-case
    interface IconProvider {
        public Icon getIcon(File file, Icon orig);
    }

    /**
     * Provides "badges" for icons that indicate files or folders of particular
     * interest to the user.
     * @see FileChooserBuilder#setBadgeProvider
     */
    public interface BadgeProvider {
        /**
         *  Get the badge the passed file should use.  <b>Note:</b> this method
         * is called for every visible file.  The negative test (deciding
         * <i>not</i> to badge a file) should be very, very fast and immediately
         * return null.
         * @param file The file in question
         * @return an icon or null if no change to the appearance of the file
         * is needed
         */
        public Icon getBadge(File file);

        /**
         * Get the x offset for badges produced by this provider.  This is
         * the location of the badge icon relative to the real icon for the
         * file.
         * @return  a rightward pixel offset
         */
        public int getXOffset();

        /**
         * Get the y offset for badges produced by this provider.  This is
         * the location of the badge icon relative to the real icon for the
         * file.
         * @return  a downward pixel offset
         */
        public int getYOffset();
    }

    private static final class BadgeIconProvider implements IconProvider {

        private final BadgeProvider badger;

        public BadgeIconProvider(BadgeProvider badger) {
            this.badger = badger;
        }

        public Icon getIcon(File file, Icon orig) {
            Icon badge = badger.getBadge(file);
            if (badge != null && orig != null) {
                return new MergedIcon(orig, badge, badger.getXOffset(),
                        badger.getYOffset());
            }
            return orig;
        }
    }

    private static final class CustomFileView extends FileView {

        private final IconProvider provider;
        private final FileSystemView view;

        CustomFileView(IconProvider provider, FileSystemView view) {
            this.provider = provider;
            this.view = view;
        }

        @Override
        public Icon getIcon(File f) {
            Icon result = view.getSystemIcon(f);
            result = provider.getIcon(f, result);
            return result;
        }
    }

    private static class MergedIcon implements Icon {

        private Icon icon1;
        private Icon icon2;
        private int xMerge;
        private int yMerge;

        MergedIcon(Icon icon1, Icon icon2, int xMerge, int yMerge) {
            assert icon1 != null;
            assert icon2 != null;
            this.icon1 = icon1;
            this.icon2 = icon2;

            if (xMerge == -1) {
                xMerge = icon1.getIconWidth() - icon2.getIconWidth();
            }

            if (yMerge == -1) {
                yMerge = icon1.getIconHeight() - icon2.getIconHeight();
            }

            this.xMerge = xMerge;
            this.yMerge = yMerge;
        }

        public int getIconHeight() {
            return Math.max(icon1.getIconHeight(), yMerge + icon2.getIconHeight());
        }

        public int getIconWidth() {
            return Math.max(icon1.getIconWidth(), yMerge + icon2.getIconWidth());
        }

        public void paintIcon(java.awt.Component c, java.awt.Graphics g, int x, int y) {
            icon1.paintIcon(c, g, x, y);
            icon2.paintIcon(c, g, x + xMerge, y + yMerge);
        }
    }
}

Line 0 Link Here

(-)a/openide.filesystems.nb/src/org/openide/filesystems/nb/Bundle.properties (+6 lines)
	1	OpenIDE-Module-Display-Category=RCP Platform
	2	OpenIDE-Module-Long-Description=\
	3	The FileSystems API should remain independent of desktop (most notably javax.swing) dependencies in order to be used as a support library in arbitrary deployment. \
	4	Classes that use Swing UI library were factored out into this module.
	5	OpenIDE-Module-Name=Filesystems NetBeans Client
	6	OpenIDE-Module-Short-Description=Swing specific classes for Filesystems API




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 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 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.openide.filesystems;

import java.io.File;
import java.util.List;
import javax.swing.filechooser.FileFilter;
import org.netbeans.junit.NbTestCase;
import org.openide.filesystems.MIMEResolver;
import org.openide.util.NbBundle;

/**
 * Test registered FileFilters.
 *
 * @author jhavlin
 */
@NbBundle.Messages({
    "RESOLVER=Resolver",
    "FILECHOOSER=BNM Files"
})
@MIMEResolver.Registration(
    displayName = "#RESOLVER",
    resource = "mime-resolver-filechooser.xml",
    showInFileChooser = "#FILECHOOSER", position=543543)
public class FileFilterSupportTest extends NbTestCase {

    public FileFilterSupportTest(String name) {
        super(name);
    }

    /**
     * This test, although it is quite short, tests a lot of ascpects of default
     * file filters. The resolver definition XML file contains several
     * duplicities, which are detected and ignored. If this detection fails,
     * filter description and {@code accept} method is changed, and it is cought
     * by this test.
     */
    public void testRegisteredFilters() {
        List<FileFilter> list = FileFilterSupport.findRegisteredFileFilters();
        assertNotNull(list);
        assertFalse(list.isEmpty());

        boolean found = false;
        for (FileFilter filter : list) {

            if (filter.getDescription().startsWith("BNM Files")) {
                found = true;
                checkBnmFilesFilter(filter);
            }
        }
        assertTrue("Registered File Filter was not found.", found);
    }

    private void checkBnmFilesFilter(FileFilter f) {
        assertEquals("BNM Files [.bnm, bnmHelp, bnmProject, bnminfo, bnmsettings]",
                f.getDescription());
        assertTrue(f.accept(new File("first.bnm")));
        assertTrue(f.accept(new File("second.BNM")));
        assertTrue(f.accept(new File("third.bNm")));
        assertTrue(f.accept(new File("bnmProject")));
        assertTrue(f.accept(new File("PREFIXbnmProjectAndSuFfIx")));
        assertFalse(f.accept(new File("bnmproject")));
        assertTrue(f.accept(new File("bnmSettings")));
        assertTrue(f.accept(new File("BNMSETTINGS")));
        assertFalse(f.accept(new File("bnmSettingsX")));
        assertTrue(f.accept(new File("bnmInfo")));
        assertTrue(f.accept(new File("AbnmInfoB")));
        assertTrue(f.accept(new File("aBNMINFOb")));
        assertTrue(f.accept(new File("bnmHelp")));
        assertFalse(f.accept(new File("bnmhelp")));
        assertFalse(f.accept(new File("bnmHelpX")));
        assertFalse(f.accept(new File("foo.txt")));
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.netbeans.modules.openide.filesystems;

import java.io.File;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.Lookup;
import org.openide.util.SharedClassObject;
import org.openide.util.lookup.Lookups;
import org.openide.util.lookup.NamedServicesLookupTest;

/**
 *
 * @author sdedic
 */
public class SharedClassObjectFactoryTest extends NamedServicesLookupTest {
    private FileObject root;
    private Logger LOG;
    

    public SharedClassObjectFactoryTest(String name) {
        super(name);
    }
    
    @Override
    protected Level logLevel() {
        return Level.FINEST;
    }
    
    @Override
    protected void setUp() throws Exception {
        if (System.getProperty("netbeans.user") == null) {
            System.setProperty("netbeans.user", new File(getWorkDir(), "ud").getPath());
        }
        
        LOG = Logger.getLogger("Test." + getName());
        
        root = FileUtil.getConfigRoot();
        for (FileObject fo : root.getChildren()) {
            fo.delete();
        }
        
        super.setUp();
    }
    
    public void testSharedClassObject() throws Exception {
        Shared instance = SharedClassObject.findObject(Shared.class, true);
        FileObject data = FileUtil.createData(root, "dir/" + Shared.class.getName().replace('.', '-') + ".instance");
        Lookup l = Lookups.forPath("dir");
        assertSame(instance, l.lookup(Shared.class));
        
        Shared created = FileUtil.getConfigObject(data.getPath(), Shared.class);
        assertSame("Config file found", instance, created);
    }
    
    public static final class Shared extends SharedClassObject {}

}




<?xml version="1.0"?>
<MIME-resolver>
    <file>
        <ext name="bnm"/>
        <resolver mime="text/x-bnm"/>
    </file>

    <!-- BNM PROJECT -->
    <file>
        <!--
            Duplicite resolver that accept less files than the following one.
            Should not be used in the filter.
        -->
        <ext name=""/>
        <name name="bnmProject" substring="false" ignorecase="false" />
        <resolver mime="text/x-bnm-project"/>
    </file>
    <file>
        <ext name=""/>
        <name name="bnmProject" substring="true" ignorecase="false" />
        <resolver mime="text/x-bnm-project"/>
    </file>

    <!-- BNM SETTINGS -->
    <file>
        <ext name=""/>
        <name name="bnmSettings" substring="false" />
        <resolver mime="text/x-bnm-settings"/>
    </file>
    <file>
        <!--
            Duplicite resolver that accept less files than the previous one.
            Should not be used in the filter.
        -->
        <ext name=""/>
        <name name="bnmSettings" substring="false" ignorecase="true" />
        <resolver mime="text/x-bnm-settings"/>
    </file>

    <!-- BNM INFO -->
    <file>
        <ext name=""/>
        <name name="bnmInfo" substring="true" />
        <resolver mime="text/x-bnm-info"/>
    </file>
    <file>
        <!--
            Duplicite resolver that accept the same files as the previous one,
            only differs in case of file name, that is ignored.
            Should not be used in the filter.
        -->
        <ext name=""/>
        <name name="BNMInfo" substring="true" />
        <resolver mime="text/x-bnm-info"/>
    </file>

    <!-- BNM HELP -->
    <file>
        <ext name=""/>
        <name name="bnmHelp" substring="false" ignorecase="false" />
        <resolver mime="text/x-bnm-help"/>
    </file>
</MIME-resolver>




/*
 * 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 2008 Sun Microsystems, Inc.
 */

package org.openide.filesystems;

import java.awt.Component;
import java.awt.Dialog;
import javax.swing.UIManager;
import javax.swing.JRootPane;
import java.util.concurrent.atomic.AtomicReference;
import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.CountDownLatch;
import java.awt.Container;
import java.awt.EventQueue;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import javax.swing.AbstractButton;
import javax.swing.JFileChooser;
import javax.swing.RootPaneContainer;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
import javax.swing.filechooser.FileFilter;
import javax.swing.plaf.metal.MetalLookAndFeel;
import org.netbeans.junit.NbTestCase;
import org.openide.util.RequestProcessor;
import static org.junit.Assert.*;
import org.netbeans.junit.RandomlyFails;

/**
 * @author tim
 */
public class FileChooserBuilderTest extends NbTestCase {

    public FileChooserBuilderTest(String name) {
        super(name);
    }

    /**
     * Test of setDirectoriesOnly method, of class FileChooserBuilder.
     */
    public void testSetDirectoriesOnly() {
        FileChooserBuilder instance = new FileChooserBuilder("x");
        boolean dirsOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY;
        assertFalse(dirsOnly);
        instance.setDirectoriesOnly(true);
        dirsOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY;
        assertTrue(dirsOnly);
    }

    /**
     * Test of setFilesOnly method, of class FileChooserBuilder.
     */
    public void testSetFilesOnly() {
        FileChooserBuilder instance = new FileChooserBuilder("y");
        boolean filesOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.FILES_ONLY;
        assertFalse(filesOnly);
        instance.setFilesOnly(true);
        filesOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.FILES_ONLY;
        assertTrue(filesOnly);
    }

    /**
     * Test of setTitle method, of class FileChooserBuilder.
     */
    public void testSetTitle() {
        FileChooserBuilder instance = new FileChooserBuilder("a");
        assertNull(instance.createFileChooser().getDialogTitle());
        instance.setTitle("foo");
        assertEquals("foo", instance.createFileChooser().getDialogTitle());
    }

    /**
     * Test of setApproveText method, of class FileChooserBuilder.
     */
    public void testSetApproveText() {
        FileChooserBuilder instance = new FileChooserBuilder("b");
        assertNull(instance.createFileChooser().getDialogTitle());
        instance.setApproveText("bar");
        assertEquals("bar", instance.createFileChooser().getApproveButtonText());
    }

    /**
     * Test of setFileFilter method, of class FileChooserBuilder.
     */
    public void testSetFileFilter() {
        FileFilter filter = new FileFilter() {

            @Override
            public boolean accept(File f) {
                return true;
            }

            @Override
            public String getDescription() {
                return "X";
            }
        };
        FileChooserBuilder instance = new FileChooserBuilder("c");
        instance.setFileFilter(filter);
        assertEquals(filter, instance.createFileChooser().getFileFilter());
    }

    /**
     * Test of setDefaultWorkingDirectory method, of class FileChooserBuilder.
     */
    public void testSetDefaultWorkingDirectory() throws IOException {
        FileChooserBuilder instance = new FileChooserBuilder("d");
        File dir = getWorkDir();
        assertTrue("tmpdir is not sane", dir.exists() && dir.isDirectory());
        instance.setDefaultWorkingDirectory(dir);
        assertEquals(dir, instance.createFileChooser().getCurrentDirectory());
    }

    /**
     * Test of setFileHiding method, of class FileChooserBuilder.
     */
    public void testSetFileHiding() {
        FileChooserBuilder instance = new FileChooserBuilder("e");
        assertFalse(instance.createFileChooser().isFileHidingEnabled());
        instance.setFileHiding(true);
        assertTrue(instance.createFileChooser().isFileHidingEnabled());
    }

    /**
     * Test of setControlButtonsAreShown method, of class FileChooserBuilder.
     */
    public void testSetControlButtonsAreShown() {
        FileChooserBuilder instance = new FileChooserBuilder("f");
        assertTrue(instance.createFileChooser().getControlButtonsAreShown());
        instance.setControlButtonsAreShown(false);
        assertFalse(instance.createFileChooser().getControlButtonsAreShown());
    }

    /**
     * Test of setAccessibleDescription method, of class FileChooserBuilder.
     */
    public void testSetAccessibleDescription() {
        FileChooserBuilder instance = new FileChooserBuilder("g");
        String desc = "desc";
        instance.setAccessibleDescription(desc);
        assertEquals(desc, instance.createFileChooser().getAccessibleContext().getAccessibleDescription());
    }

    /**
     * Test of createFileChooser method, of class FileChooserBuilder.
     */
    public void testCreateFileChooser() {
        FileChooserBuilder instance = new FileChooserBuilder("h");
        assertNotNull(instance.createFileChooser());
    }

    public void testSetSelectionApprover() throws Exception {
        FileChooserBuilder instance = new FileChooserBuilder("i");
        File tmp = new File(System.getProperty("java.io.tmpdir"));
        assertTrue ("Environment is insane", tmp.exists() && tmp.isDirectory());
        File sel = new File("tmp" + System.currentTimeMillis());
        if (!sel.exists()) {
            assertTrue (sel.createNewFile());
        }
        instance.setDefaultWorkingDirectory(tmp);
        SA sa = new SA();
        instance.setSelectionApprover(sa);
        JFileChooser ch = instance.createFileChooser();
        ch.setSelectedFile(sel);
        ch.approveSelection();
        sa.assertApproveInvoked(sel);
    }

    public void testAddFileFilter() {
        FileChooserBuilder instance = new FileChooserBuilder("j");
        FF one = new FF ("a");
        FF two = new FF ("b");
        instance.addFileFilter(one);
        instance.addFileFilter(two);
        JFileChooser ch = instance.createFileChooser();
        Set<FileFilter> ff = new HashSet<FileFilter>(Arrays.asList(one, two));
        Set<FileFilter> actual = new HashSet<FileFilter>(Arrays.asList(ch.getChoosableFileFilters()));
        assertTrue (actual.containsAll(ff));
        //actual should also contain JFileChooser.getAcceptAllFileFilter()
        assertEquals (ff.size() + 1, actual.size());
    }

    public void testSetAcceptAllFileFilterUsed() {
        FileChooserBuilder instance = new FileChooserBuilder("k");
        assertTrue(instance.createFileChooser().isAcceptAllFileFilterUsed());
        instance.setAcceptAllFileFilterUsed(false);
        assertFalse(instance.createFileChooser().isAcceptAllFileFilterUsed());
    }

    private static final class FF extends FileFilter {
        private String x;
        FF(String x) {
            this.x = x;
        }

        @Override
        public boolean accept(File f) {
            return f.getName().endsWith(x);
        }

        @Override
        public String getDescription() {
            return x;
        }

    }

    private static final class SA implements FileChooserBuilder.SelectionApprover {
        private File[] selection;
        @Override
        public boolean approve(File[] selection) {
            this.selection = selection;
            return true;
        }

        void assertApproveInvoked(File selected) {
            assertNotNull ("approve method called", selection);
            assertEquals("One selected file", 1, selection.length);
            assertEquals("It is the one", selected, selection[0]);
        }
    }

    private static AbstractButton findDefaultButton(Container c, String txt) {
        if (c instanceof RootPaneContainer) {
            JRootPane root = ((RootPaneContainer) c).getRootPane();
            if (root == null) {
                return null;
            }
            AbstractButton btn = root.getDefaultButton();
            if (btn == null) {
                //Metal L&F does not set default button for JFileChooser
                Container parent = c;
                while (parent.getParent() != null && !(parent instanceof Dialog)) {
                    parent = parent.getParent();
                }
                if (parent instanceof Dialog) {
                    return findFileChooserAcceptButton ((Dialog) parent, txt);
                }
            } else {
                return btn;
            }
        }
        return null;
    }

    private static AbstractButton findFileChooserAcceptButton(Dialog dlg, String txt) {
        for (Component c : dlg.getComponents()) {
            if (c instanceof Container) {
                AbstractButton result = scanForButton((Container) c, txt);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }

    private static AbstractButton scanForButton(Container container, String txt) {
        assertNotNull (container);
        assertNotNull (txt);
        if (container instanceof AbstractButton) {
            if (txt.equals(((AbstractButton) container).getText())) {
                return ((AbstractButton) container);
            }
        } else {
            for (Component c : container.getComponents()) {
                if (c instanceof Container) {
                    AbstractButton b = scanForButton ((Container) c, txt);
                    if (b != null) {
                        return b;
                    }
                }
            }
        }
        return null;
    }

    @RandomlyFails // NB-Core-Build #8038: Button is visible
    public void testForceUseOfDefaultWorkingDirectory() throws InterruptedException, IOException, InvocationTargetException, UnsupportedLookAndFeelException {
        UIManager.setLookAndFeel(new MetalLookAndFeel());
        FileChooserBuilder instance = new FileChooserBuilder("i").setApproveText("__OK");
        instance.setDirectoriesOnly(true);
        final File toDir = getWorkDir();
        final File selDir = new File(toDir, "sel" + System.currentTimeMillis());
        if (!selDir.exists()) {
            assertTrue(selDir.mkdirs());
        }

        final JFileChooser ch = instance.createFileChooser();
        assertEquals ("__OK", ch.getApproveButtonText());
        final CountDownLatch showLatch = new CountDownLatch(1);
        ch.addAncestorListener (new AncestorListener() {

            @Override
            public void ancestorAdded(AncestorEvent event) {
                if (ch.isShowing()) {
                    ch.removeAncestorListener(this);
                    showLatch.countDown();
                }
            }

            @Override
            public void ancestorRemoved(AncestorEvent event) {

            }

            @Override
            public void ancestorMoved(AncestorEvent event) {

            }

        });

        final AtomicReference<Object> chooserRes = new AtomicReference<Object>();
        RequestProcessor.Task task = RequestProcessor.getDefault().post(new Runnable() {

            @Override
            public void run() {
                Object r = ch.showOpenDialog(null);
                chooserRes.set(r);
            }

        });


        showLatch.await();
        EventQueue.invokeAndWait (new Runnable() {
            @Override
            public void run() {
                ch.setCurrentDirectory(toDir);
            }
        });
        EventQueue.invokeAndWait (new Runnable() {
            @Override
            public void run() {
                ch.setSelectedFile (selDir);
            }
        });
        assertTrue ("Button is visible: " + ch, ch.isShowing());
        final AtomicReference<AbstractButton> btn = new AtomicReference<AbstractButton>();
        EventQueue.invokeAndWait(new Runnable() {

            @Override
            public void run() {
                AbstractButton defButton = findDefaultButton(ch.getTopLevelAncestor(), ch.getApproveButtonText());
                btn.set(defButton);
            }

        });
        assertNotNull("have a button", btn.get());
        assertTrue(btn.get().isEnabled());
        EventQueue.invokeAndWait(new Runnable() {
            @Override
            public void run() {
                AbstractButton defButton = btn.get();
                defButton.doClick();
            }
        });

        task.waitFinished();
        assertEquals(JFileChooser.APPROVE_OPTION, chooserRes.get());

        assertEquals(toDir, ch.getCurrentDirectory());

        instance = new FileChooserBuilder("i");
        assertEquals("Directory not retained", toDir, instance.createFileChooser().getCurrentDirectory());

        File userHome = new File(System.getProperty("user.home"));
        assertTrue("Environment not sane", userHome.exists() && userHome.isDirectory());
        instance.forceUseOfDefaultWorkingDirectory(true).setDefaultWorkingDirectory(userHome);

        assertEquals(userHome, instance.createFileChooser().getCurrentDirectory());
    }
}




        <apidef name="filesystems">Filesystems API</apidef>
    </apidefs>
    <changes>
        <change id="FileSystemStatus.icons">
            <api name="filesystems"/>
            <summary>FileSystem.Status icon annotation moved</summary>
            <version major="9" minor="0"/>
            <date year="2014" month="4" day="11"/>
            <author login="sdedic"/>
            <compatibility modification="yes" addition="yes" binary="compatible" source="compatible" semantic="incompatible"/>
            <description>
                <p>
                    The default implementation of FileSystem.Status annotated file's icon using ImageUtilities
                    which uses AWT graphics etc. Such dependency is not desirable in a standalone FileSystem API
                    library.
                </p>
                <p>
                    The builtin implementation now does not work with the icon at all and returns null. A proper
                    implementation for FileSystem.Status is looked up in default Lookup and is implemented
                    properly (with Icon annotations) in <code>openide.filesystems.nb</code> module.
                </p>
            </description>
            <issue number="243561"/>
        </change>
        <change id="SharedClassObject.separate">
            <api name="filesystems"/>
            <summary>Removed dependency on SharedClassObject</summary>
            <version major="9" minor="0"/>
            <date year="2014" month="4" day="11"/>
            <author login="sdedic"/>
            <compatibility modification="yes" addition="yes" binary="compatible" source="compatible" semantic="incompatible"/>
            <description>
                <p>
                    If the FileSystems API encounters a <a href="@openide-util@/org/openide/util/SharedClassObject.html#find">SharedClassObject</a> subclass in the <code>instanceClass</code> attribute,
                    or derives the subclass from FileObject's name, it does not create the instance using the default
                    constructor, but rather using <a href="@openide-util@/org/openide/util/SharedClassObject.html#find">SharedClassObject.find</a>
                    method.
                    The <code>SharedClassObject</code> is long deprecated and adds unwanted dependency on desktop
                    utilities to FileSystems API. 
                </p>
                <p>
                    A new SPI, <a href="@TOP@/org/openide/filesystems/spi/CustomInstanceFactory.html">CustomInstanceFactory</a> is created
                    to create instances based on the type. The instance is searched for in the default Lookup. 
                    The NetBeans Platform will provide an implementation that handles <code>SharedClassObjects</code>,
                    but FileSystems API library no longer implements that behaviour. A compatible implementation
                    of <code>CustomInstanceFactory</code> is provided by the <code>openide.filesystems.nb</code>
                    module.
                </p>
            </description>
            <issue number="243561"/>
        </change>
        <change id="RemoveDeprecatedAndObsolete.8">
            <api name="filesystems"/>
            <summary>Remove dependency on Swing (SystemAction) and obsolete APIs</summary>
            <version major="9" minor="0"/>
            <date year="2014" month="4" day="11"/>
            <author login="sdedic"/>
            <compatibility modification="yes" binary="compatible" source="incompatible" deletion="yes" semantic="compatible"/>
            <description>
                <p>
                    The primary goal of the change is to remove dependencies on Swing APIs - FileSystems should not depend
                    or directly use <code>SystemAction</code> extends <code>javax.swing.Action</code>. At the same time, 
                    methods or classes which are long @deprecated and have no semantic value are removed from the APIs.
                </p>
                <p>
                    The changes are binary-compatible; a compatibility module is created as <code>org.openide.filesystems.compat8</code>.
                    Live code (<a href="@openide-filesystems-compat8@/org/openide/filesystems/FileChooserBuilder.html">FileChooserBuilder</a>
                    is moved to a new module <code>org.openide.filesystems.nb</code> with automatic dependency in place for client which
                    use filesystems in their old API version.
                </p>
                <p>
                    It's strongly discouraged to compile against the <code>compat8</code> module. Its contents will be maintained only to
                    ensure binary compatibility with FileSystems API 8.x, API users should not rely on any contract exposed directly by the compat8
                    module.
                </p>
            </description>
            <issue number="243561"/>
        </change>
        <change id="MultiFileObject.revealEntriesAttribute">
            <api name="filesystems"/>
            <summary>Allowed to reveal deleted files, or original files overriden by writable layer</summary>




        </question>
-->
<answer id="lookup-lookup">
    The following services are looked up:
    <ul>
        <li>Implementations of MIMEResolver and URLMapper are looked up</li>
        <li>instance of <a href="@TOP@/org/openide/filesystems/FileSystem.Status.html">FileSystem.Status</a> which is
            used as the Status of the <b>default</b> FileSystem</li>
        <li>instance of <a href="@TOP@/org/openide/filesystems/spi/CustomInstanceFactory.html">CustomInstanceFactory</a>
            which is used to create instances for FileSystem files without <code>instanceCreate</code> attribute</li>
    </ul>
</answer>



        </question>
-->
<answer id="lookup-register">
    <code>URLStreamHandlerFactory</code> implementations for <b>nbfs:</b> and
    <b>memory:</b> protocols are registered as named services.
</answer>



Lines 2-6 Link Here

(-)a/openide.filesystems/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.openide.filesystems	2	OpenIDE-Module: org.openide.filesystems
3	OpenIDE-Module-Localizing-Bundle: org/openide/filesystems/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/openide/filesystems/Bundle.properties
4	OpenIDE-Module-Layer: org/openide/filesystems/resources/layer.xml	4	OpenIDE-Module-Layer: org/openide/filesystems/resources/layer.xml
5	OpenIDE-Module-Specification-Version: 8.11	5	OpenIDE-Module-Specification-Version: 9.0
6		6




        </transformation>
    </transformationgroup>

    <transformationgroup>
        <description>Separation of desktop and cleanup</description>
        <transformation>
            <trigger-dependency type="older">
                <module-dependency codenamebase="org.openide.filesystems" spec="9.0"/>
            </trigger-dependency>
            <implies>
                <result>
                    <module-dependency codenamebase="org.openide.filesystems.nb"/>
                    <module-dependency codenamebase="org.openide.filesystems.compat8"/>
                </result>
            </implies>
        </transformation>
    </transformationgroup>

</transformations>




            <code-name-base>org.openide.filesystems</code-name-base>
            <module-dependencies>
                <dependency>
                    <code-name-base>org.openide.util</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.base</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

                        <recursive/>
                        <compile-dependency/>
                    </test-dependency>
<!--                    <test-dependency>
                        <code-name-base>org.openide.util</code-name-base>
                        <compile-dependency/>
                        <test/>
                    </test-dependency>-->
                    <test-dependency>
                        <code-name-base>org.openide.util.base</code-name-base>
                        <compile-dependency/>
                        <test/>
                    </test-dependency>

            <public-packages>
                <package>org.openide.filesystems</package>
                <package>org.openide.filesystems.annotations</package>
                <package>org.openide.filesystems.spi</package>
            </public-packages>
        </data>
    </configuration>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 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 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.openide.filesystems;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.filechooser.FileFilter;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;

/**
 * Support methods for creation of registered {@link FileFilter file filters}.
 */
public final class FileFilterSupport {

    /**
     * The logger.
     */
    private static final Logger LOG = Logger.getLogger(
            FileFilterSupport.class.getName());

    /**
     * Hide the default constructor.
     */
    private FileFilterSupport() {
    }

    /**
     * Construct description for {@link FileFilter} that accepts files with
     * specified extension.
     *
     * @param displayName Human readable display name (e.g. "HTML files")
     * @param elements List of accepted filter elements.
     *
     * @return Display name (description) for the filter.
     */
    private static String constructFilterDisplayName(String displayName,
            List<FilterElement> elements) {
        StringBuilder sb = new StringBuilder(displayName);
        boolean first = true;
        sb.append(" [");                                                //NOI18N
        for (FilterElement el : elements) {
            if (first) {
                first = false;
            } else {
                sb.append(", ");                                        //NOI18N
            }
            sb.append(el.getName());
        }
        sb.append("]");                                                 //NOI18N
        return sb.toString();
    }

    /**
     * Check whether passed file is accepted by filter for specified list of
     * extensions.
     *
     * @param file File to be accepted or rejected.
     * @param elements List of accepted filter elements.
     *
     * @return True if the file is accepted, false if it is rejected.
     *
     * @see FileFilterSupport
     */
    private static boolean accept(File file, List<FilterElement> elements) {
        if (file != null) {
            if (file.isDirectory()) {
                return true;
            }
            for (FilterElement elm : elements) {
                if (elm.accept(file)) {
                    return true;
                }
            }
        }
        return false;
    }

    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);
    }

    private static FileFilter createFilter(final String name,
            final Set<FileObject> resolvers) {
        ArrayList<FilterElement> elems = new ArrayList<FilterElement>(3);
        String lastAtt;
        for (FileObject fo : resolvers) {
            int i = 0;
            while ((lastAtt = (String) fo.getAttribute(
                    "ext." + i)) != null) { //NOI18N
                addExtensionToList(elems, lastAtt);
                i++;
            }
            int n = 0;
            while ((lastAtt = (String) fo.getAttribute("fileName." //NOI18N
                    + (n++))) != null) {
                addNameToList(elems, lastAtt);
            }
            String type;
            if ((type = (String) fo.getAttribute("mimeType")) != null) {//NOI18N
                addMimeTypeExts(elems, type);
            }
            int t = 0;
            while ((type = (String) fo.getAttribute(
                    "mimeType." + (t++))) != null) {     //NOI18N
                addMimeTypeExts(elems, type);
            }
        }
        sortFilterElements(elems);
        return new FileFilterImpl(name, elems);
    }

    /**
     * Add all extensions assigned to a MIME Type to the extension list.
     */
    private static void addMimeTypeExts(List<FilterElement> exts, String type) {
        addAllExtensionsToList(exts, FileUtil.getMIMETypeExtensions(type));
    }

    /**
     * Add new items to list of extensions, prevent duplicates.
     *
     * @param list List of extensions to alter.
     * @param toAdd List of extensions (without starting dot) to add.
     */
    private static void addAllExtensionsToList(List<FilterElement> list,
            List<String> toAdd) {
        for (String s : toAdd) {
            addExtensionToList(list, s);
        }
    }

    /**
     * Add new item to list of extensions, prevent duplacates.
     *
     * @param list List of extensions to alter.
     * @param s Extensions without starting dot.
     */
    private static void addExtensionToList(List<FilterElement> list,
            String ext) {
        addFilterElementToList(list, FilterElement.createForExtension(ext));
    }

    private static void addNameToList(List<FilterElement> list, String name) {
        Pattern p = Pattern.compile(
                "\\[([^,]+), (true|false), (true|false)\\](\\S*)");     //NOI18N
        Matcher m = p.matcher(name);
        if (m.find()) {
            String fileName = m.group(1);
            boolean substring = m.group(2).equals("true");              //NOI18N
            boolean ignoreCase = m.group(3).equals("true");             //NOI18N
            String extension = m.group(4);
            addFilterElementToList(list, FilterElement.createForFileName(
                    fileName, extension, substring, ignoreCase));
        } else {
            LOG.log(Level.INFO, "Incorrect name pattern {0}", name);    //NOI18N
        }
    }

    private static void addFilterElementToList(List<FilterElement> list,
            FilterElement newItem) {

        for (int i = 0; i < list.size(); i++) {
            FilterElement el = list.get(i);
            FilterElement.ComparisonResult result = newItem.compare(el);
            switch (result) {
                case DIFFERENT:
                    continue;
                case THE_SAME:
                case WORSE:
                    return;
                case BETTER:
                    list.set(i, newItem);
                    return;
            }
        }
        list.add(newItem);
    }

    private static List<FileFilter> sortFiltersByDescription(
            List<FileFilter> list) {

        Collections.sort(list, new Comparator<FileFilter>() {
            @Override
            public int compare(FileFilter o1, FileFilter o2) {
                return o1.getDescription().compareTo(o2.getDescription());
            }
        });
        return list;
    }

    private static List<FilterElement> sortFilterElements(
            List<FilterElement> elements) {
        Collections.sort(elements, new Comparator<FilterElement>() {
            @Override
            public int compare(FilterElement o1, FilterElement o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        return elements;
    }

    private static class FileFilterImpl extends FileFilter {

        private final String name;
        List<FilterElement> filterElements;

        public FileFilterImpl(String name, List<FilterElement> elements) {
            this.name = name;
            this.filterElements = elements;
        }

        @Override
        public boolean accept(File pathname) {
            return FileFilterSupport.accept(pathname, filterElements);
        }

        @Override
        public String getDescription() {
            return FileFilterSupport.constructFilterDisplayName(
                    name, filterElements);
        }
    }

    /**
     * Element of File Filter. One accepted extension or file name pattern.
     */
    private static abstract class FilterElement {

        public abstract String getName();

        public abstract boolean accept(File f);

        /**
         * Compare two filter elements. Correct implementation of this method
         * prevents adding duplicite elements to the filter.
         */
        public abstract ComparisonResult compare(FilterElement e);

        public static FilterElement createForExtension(String ext) {
            return new ExtensionBasedFilterElement(ext);
        }

        public static FilterElement createForFileName(String name,
                String extension, boolean substring, boolean ignoreCase) {
            return new NameBasedFilterElement(name, extension,
                    substring, ignoreCase);
        }

        public static enum ComparisonResult {

            THE_SAME, BETTER, WORSE, DIFFERENT
        }

        private static class ExtensionBasedFilterElement extends FilterElement {

            private final String extension;

            public ExtensionBasedFilterElement(String extension) {
                if (extension != null) {
                    this.extension = extension;
                } else {
                    throw new NullPointerException();
                }
            }

            @Override
            public String getName() {
                return "." + extension;                                 //NOI18N
            }

            @Override
            public boolean accept(File f) {
                return f.getName().toLowerCase().endsWith(
                        "." + extension.toLowerCase());                 //NOI18N
            }

            @Override
            public ComparisonResult compare(FilterElement e) {
                if (!(e instanceof ExtensionBasedFilterElement)) {
                    return ComparisonResult.DIFFERENT;
                }
                ExtensionBasedFilterElement x = (ExtensionBasedFilterElement) e;
                if (x == null) {
                    throw new NullPointerException();
                }
                if (this.extension.equals(x.extension)) {
                    return ComparisonResult.THE_SAME;
                } else if (this.extension.equalsIgnoreCase(x.extension)
                        && this.extension.length() > 1) {
                    if (Character.isUpperCase(x.extension.charAt(0))) {
                        return ComparisonResult.BETTER; //this better, x worse
                    } else {
                        return ComparisonResult.WORSE; // this worse, x better
                    }
                } else {
                    return ComparisonResult.DIFFERENT;
                }
            }
        }

        private static class NameBasedFilterElement extends FilterElement {

            String name;
            String ext;
            boolean substring;
            boolean ignoreCase;
            Pattern p;

            public NameBasedFilterElement(String name, String ext,
                    boolean substring, boolean ignoreCase) {
                this.name = name;
                this.ext = ext;
                this.substring = substring;
                this.ignoreCase = ignoreCase;
                StringBuilder sb = new StringBuilder();
                if (ignoreCase) {
                    sb.append("(?i)");                                  //NOI18N
                }
                if (substring) {
                    sb.append(".*");                                    //NOI18N
                }
                sb.append(name);                                        //NOI18N
                if (substring) {
                    sb.append(".*");                                    //NOI18N
                }
                if (!ext.isEmpty()) {
                    sb.append("\\.");                                   //NOI18N
                    sb.append(ext);
                }
                p = Pattern.compile(sb.toString());
            }

            @Override
            public String getName() {
                return name + (ext.isEmpty() ? "" : "." + ext);         //NOI18N
            }

            @Override
            public boolean accept(File f) {
                return p.matcher(f.getName()).matches();
            }

            @Override
            public ComparisonResult compare(FilterElement e) {
                if (e == null) {
                    throw new NullPointerException();
                } else if (!(e instanceof NameBasedFilterElement)) {
                    return ComparisonResult.DIFFERENT;
                }
                NameBasedFilterElement x = (NameBasedFilterElement) e;
                if (this.name.equals(x.name) && this.ext.equals(x.ext)) {
                    if (this.substring == x.substring
                            && this.ignoreCase == x.ignoreCase) {
                        return ComparisonResult.THE_SAME;
                    } else {
                        return compareFlags(x);
                    }
                } else if (this.ext.equalsIgnoreCase(x.ext)
                        && this.name.equalsIgnoreCase(x.name)
                        && (this.ignoreCase || x.ignoreCase)) {
                    if (this.substring == x.substring
                            && this.ignoreCase == x.ignoreCase) {
                        if (Character.isLowerCase(this.name.charAt(0))) {
                            return ComparisonResult.BETTER;
                        } else {
                            return ComparisonResult.WORSE;
                        }
                    } else {
                        return compareFlags(x);
                    }
                } else {
                    return ComparisonResult.DIFFERENT;
                }
            }

            private ComparisonResult compareFlags(NameBasedFilterElement x) {
                if (this.substring == x.substring
                        && this.ignoreCase) {
                    return ComparisonResult.BETTER;
                } else if (this.ignoreCase == x.ignoreCase
                        && this.substring) {
                    return ComparisonResult.BETTER;
                } else if (this.substring != x.substring
                        && this.ignoreCase != x.ignoreCase) {
                    return ComparisonResult.DIFFERENT;
                } else {
                    return ComparisonResult.WORSE;
                }
            }
        }
    }
}




 * Software is Sun Microsystems, Inc.
 *
 * Portions Copyrighted 2007 Sun Microsystems, Inc.
 *//*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc.
 *
 * Portions Copyrighted 2007 Sun Microsystems, Inc.
 */

package org.netbeans.modules.openide.filesystems;

import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedHashMap;

import org.openide.filesystems.FileStateInvalidException;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.spi.CustomInstanceFactory;
import org.openide.util.BaseUtilities;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.SharedClassObject;
import org.openide.util.Utilities;
import org.openide.util.lookup.AbstractLookup;
import org.openide.util.lookup.Lookups;
import org.openide.util.lookup.ProxyLookup;

        }
    } // end of OverFiles
    
    private static volatile Lookup.Result<CustomInstanceFactory> factories;
    
    private static Collection<? extends CustomInstanceFactory> getInstanceFactories() {
        Lookup.Result<CustomInstanceFactory> fr;
        
        if ((fr = factories) == null) {
            factories = fr = Lookup.getDefault().lookupResult(CustomInstanceFactory.class);
        }
        return fr.allInstances();
    }
            
    public static final <T> T createInstance(Class<T> type) throws InstantiationException, 
            IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        T r = null;
        for (CustomInstanceFactory fif : getInstanceFactories()) {
            r = (T)fif.createInstance(type);
            if (r != null) {
                break;
            }
        }
        if (r == null) {
            Constructor<T> init = type.getDeclaredConstructor();
            init.setAccessible(true);
            r = init.newInstance();
        }
        return r;
    }
    
    private static final class FOItem extends AbstractLookup.Pair<Object> {
        private static Reference<Object> EMPTY = new WeakReference<Object>(null);

                    if (type == null) {
                        return null;
                    }
                    r = createInstance(type);
                        r = SharedClassObject.findObject(type.asSubclass(SharedClassObject.class), true);
                    } else {
                        r = type.newInstance();
                    }
                } catch (InstantiationException ex) {
                    Exceptions.printStackTrace(ex);
                } catch (IllegalAccessException ex) {
                    Exceptions.printStackTrace(ex);
                } catch (InvocationTargetException ex) {
                    Exceptions.printStackTrace(ex);
                } catch (NoSuchMethodException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
            return resultType.isInstance(r) ? resultType.cast(r) : null;

            // first of all try "instanceClass" property of the primary file
            Object attr = fo.getAttribute ("instanceClass");
            if (attr instanceof String) {
                return BaseUtilities.translate((String) attr);
            } else if (attr != null) {
                LOG.warning(
                    "instanceClass was a " + attr.getClass().getName()); // NOI18N

            }

            name = name.replace ('-', '.');
            name = BaseUtilities.translate(name);

            //System.out.println ("Original: " + getPrimaryFile ().getName () + " new one: " + name); // NOI18N
            return name;

Lines 49-55 Link Here

(-)a/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/FileElement.java (-2 / +2 lines)
49	import java.util.logging.Logger;	49	import java.util.logging.Logger;
50	import org.openide.filesystems.FileObject;	50	import org.openide.filesystems.FileObject;
51	import org.openide.filesystems.FileUtil;	51	import org.openide.filesystems.FileUtil;
52	import org.openide.util.Utilities;	52	import org.openide.util.BaseUtilities;
53	import org.openide.xml.XMLUtil;	53	import org.openide.xml.XMLUtil;
54		54
55	/**	55	/**
Lines 529-535 Link Here
529	/** #26521, 114976 - ignore not readable and windows' locked files. */	529	/** #26521, 114976 - ignore not readable and windows' locked files. */
530	private static void handleIOException(FileObject fo, IOException ioe) throws IOException {	530	private static void handleIOException(FileObject fo, IOException ioe) throws IOException {
531	if (fo.canRead()) {	531	if (fo.canRead()) {
532	if (!Utilities.isWindows() \|\| !(ioe instanceof FileNotFoundException) \|\| !fo.isValid() \|\| !fo.getName().toLowerCase().contains("ntuser")) {//NOI18N	532	if (!BaseUtilities.isWindows() \|\| !(ioe instanceof FileNotFoundException) \|\| !fo.isValid() \|\| !fo.getName().toLowerCase().contains("ntuser")) {//NOI18N
533	throw ioe;	533	throw ioe;
534	}	534	}
535	}	535	}

Lines 57-63 Link Here

(-)a/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/MIMEResolverImpl.java (-2 / +2 lines)
57	import org.openide.filesystems.MIMEResolver;	57	import org.openide.filesystems.MIMEResolver;
58	import org.openide.util.Exceptions;	58	import org.openide.util.Exceptions;
59	import org.openide.util.Parameters;	59	import org.openide.util.Parameters;
60	import org.openide.util.Utilities;	60	import org.openide.util.BaseUtilities;
61	import org.openide.xml.XMLUtil;	61	import org.openide.xml.XMLUtil;
62	import org.w3c.dom.Document;	62	import org.w3c.dom.Document;
63	import org.w3c.dom.Element;	63	import org.w3c.dom.Element;
Lines 75-81 Link Here
75	// enable some tracing	75	// enable some tracing
76	private static final Logger ERR = Logger.getLogger(MIMEResolverImpl.class.getName());	76	private static final Logger ERR = Logger.getLogger(MIMEResolverImpl.class.getName());
77		77
78	static final boolean CASE_INSENSITIVE = Utilities.getOperatingSystem() == Utilities.OS_VMS;	78	static final boolean CASE_INSENSITIVE = BaseUtilities.getOperatingSystem() == BaseUtilities.OS_VMS;
79		79
80	// notification limit in bytes for reading file content. It should not exceed 4192 (4kB) because it is read in one disk touch.	80	// notification limit in bytes for reading file content. It should not exceed 4192 (4kB) because it is read in one disk touch.
81	private static final int READ_LIMIT = 4000;	81	private static final int READ_LIMIT = 4000;




        }
    }
     // end of Invalid

    /** Replace that stores name of fs and file.
     * @deprecated In favor of AbstractFolder.Replace.
    */
    @Deprecated
    static final class Replace extends Object implements Serializable {
        /** generated Serialized Version UID */
        static final long serialVersionUID = -8543432135435542113L;
        private String fsName;
        private String fileName;

        /** Constructor
        */
        public Replace(String fsName, String fileName) {
            this.fsName = fsName;
            this.fileName = fileName;
        }

        /** Finds the right file.
        */
        public Object readResolve() {
            Repository rep = Repository.getDefault();
            @SuppressWarnings("deprecation") // FileSystem.systemName historical part of serial form
            FileSystem fs = rep.findFileSystem(fsName);
            FileObject fo = null;

            if (fs != null) {
                // scan desired system
                fo = fs.findResource(fileName);
            }

            if (fo == null) {
                // create invalid file instead
                return new Invalid(fsName, fileName);
            }

            return fo;
        }
    }
     // end of Replace
}




import java.util.Date;
import java.util.Enumeration;
import java.util.StringTokenizer;
import org.openide.util.Enumerations;
import org.openide.util.Lookup;
import org.openide.util.NbCollections;
import org.openide.util.SharedClassObject;
import org.openide.util.actions.SystemAction;

/**
 * This convenience implementation does much of the hard work of

    /** generated Serialized Version UID */
    private static final long serialVersionUID = -3345098214331282438L;

    /** system actions for this FS if it has refreshTime != 0 */
    private static SystemAction[] SYSTEM_ACTIONS;

    /** system actions for this FS */
    private static final SystemAction[] NO_SYSTEM_ACTIONS = new SystemAction[] {  };

    /** cached last value of Enumeration which holds resource name (enumeration like StringTokenizer)*/
    static transient private PathElements lastEnum;


        return getAbstractRoot();
    }

    /* Finds file when its name is provided.
    *
    * @param aPackage package name where each package is separated by a dot
    * @param name name of the file (without dots) or <CODE>null</CODE> if
    *    one want to obtain name of package and not file in it
    * @param ext extension of the file or <CODE>null</CODE> if one needs
    *    package and not file name
    *
    * @warning when one of name or ext is <CODE>null</CODE> then name and
    *    ext should be ignored and scan should look only for a package
    *
    * @return FileObject that represents file with given name or
    *   <CODE>null</CODE> if the file does not exist
    */
    @Deprecated
    public FileObject find(String aPackage, String name, String ext) {
        // create enumeration of name to look for
        Enumeration<String> st = NbCollections.checkedEnumerationByFilter(new StringTokenizer(aPackage, "."), String.class, true); // NOI18N

        if ((name == null) || (ext == null)) {
            // search for folder, return the object only if it is folder
            FileObject fo = getAbstractRoot().find(st);

            return ((fo != null) && fo.isFolder()) ? fo : null;
        } else {
            Enumeration<String> en = Enumerations.concat(st, Enumerations.singleton(name + '.' + ext));

            // tries to find it (can return null)
            return getAbstractRoot().find(en);
        }
    }

    /* Finds file when its resource name is given.
    * The name has the usual format for the {@link ClassLoader#getResource(String)}
    * method. So it may consist of "package1/package2/filename.ext".

        return (refresher != null);
    }

    /* Action for this filesystem.
    *
    * @return refresh action
    */
    public SystemAction[] getActions() {
        if (!isEnabledRefreshFolder()) {
            return NO_SYSTEM_ACTIONS;
        } else {
            if (SYSTEM_ACTIONS == null) {
                try {
                    ClassLoader l = Lookup.getDefault().lookup(ClassLoader.class);

                    if (l == null) {
                        l = getClass().getClassLoader();
                    }

                    Class<?> c = Class.forName("org.openide.actions.FileSystemRefreshAction", true, l); // NOI18N
                    SystemAction ra = SharedClassObject.findObject(c.asSubclass(SystemAction.class), true);

                    // initialize the SYSTEM_ACTIONS
                    SYSTEM_ACTIONS = new SystemAction[] { ra };
                } catch (Exception ex) {
                    // ok, we are probably running in standalone mode and
                    // classes needed to initialize the RefreshAction are
                    // not available
                    SYSTEM_ACTIONS = NO_SYSTEM_ACTIONS;
                }
            }

            return SYSTEM_ACTIONS;
        }
    }

    /** Set the number of milliseconds between automatic
    * refreshes of the directory structure.
    *

Lines 64-70 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/AbstractFolder.java (-2 / +2 lines)
64	import java.util.Set;	64	import java.util.Set;
65	import org.openide.util.Enumerations;	65	import org.openide.util.Enumerations;
66	import org.openide.util.NbBundle;	66	import org.openide.util.NbBundle;
67	import org.openide.util.Utilities;	67	import org.openide.util.BaseUtilities;
68		68
69	/** Implementation of the file object that simplyfies common	69	/** Implementation of the file object that simplyfies common
70	* tasks with hierarchy of objects for AbstractFileObject and MultiFileObject.	70	* tasks with hierarchy of objects for AbstractFileObject and MultiFileObject.
Lines 348-354 Link Here
348	//On OpenVMS, see if the name is stored in a different case	348	//On OpenVMS, see if the name is stored in a different case
349	//to work around a JVM bug.	349	//to work around a JVM bug.
350	//	350	//
351	if (Utilities.getOperatingSystem() == Utilities.OS_VMS) {	351	if (BaseUtilities.getOperatingSystem() == BaseUtilities.OS_VMS) {
352	if (Character.isLowerCase(name.charAt(0))) {	352	if (Character.isLowerCase(name.charAt(0))) {
353	r = map.get(name.toUpperCase());	353	r = map.get(name.toUpperCase());
354	} else {	354	} else {

Lines 52-58 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/DeepListener.java (-2 / +2 lines)
52	import java.util.concurrent.Callable;	52	import java.util.concurrent.Callable;
53	import java.util.logging.Level;	53	import java.util.logging.Level;
54	import java.util.logging.Logger;	54	import java.util.logging.Logger;
55	import org.openide.util.Utilities;	55	import org.openide.util.BaseUtilities;
56	import org.openide.util.WeakSet;	56	import org.openide.util.WeakSet;
57		57
58	/**	58	/**
Lines 71-77 Link Here
71	private final int hash;	71	private final int hash;
72		72
73	DeepListener(FileChangeListener listener, File path, FileFilter ff, Callable<Boolean> stop) {	73	DeepListener(FileChangeListener listener, File path, FileFilter ff, Callable<Boolean> stop) {
74	super(listener, Utilities.activeReferenceQueue());	74	super(listener, BaseUtilities.activeReferenceQueue());
75	this.path = path;	75	this.path = path;
76	this.stop = stop;	76	this.stop = stop;
77	this.filter = ff;	77	this.filter = ff;




import javax.xml.parsers.ParserConfigurationException;
import org.openide.util.Enumerations;
import org.openide.util.NbBundle;
import org.openide.util.BaseUtilities;
import org.openide.util.io.NbMarshalledObject;
import org.openide.xml.XMLUtil;
import org.xml.sax.Attributes;

            // However, OpenVMS now supports a file name beginning with "."
            // So we now have to copy the existing "_nbattrs." file into ".nbattrs"
            //
            if ((BaseUtilities.getOperatingSystem() == BaseUtilities.OS_VMS) && (arr[0] != null) && (f != null)) {
                if (arr[0].equalsIgnoreCase("_nbattrs.")) {
                    try {
                        deleteFile(f + "/" + arr[0]); // NOI18N

            // However, OpenVMS now supports a file name beginning with "."
            // So we now have to copy the existing "_nbattrs." file into ".nbattrs"
            //
            if ((BaseUtilities.getOperatingSystem() == BaseUtilities.OS_VMS) && (arr[i] != null) && (f != null)) {
                if (arr[i].equalsIgnoreCase("_nbattrs.")) {
                    try {
                        File fp = new File(f + "/" + ".nbattrs");




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 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.openide.filesystems;

import java.io.IOException;

/** Exception thrown to signal that external
* execution and compilation is not supported on a given filesystem.
*
* @author Jaroslav Tulach
* @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
*/
@Deprecated
public class EnvironmentNotSupportedException extends IOException {
    /** generated Serialized Version UID */
    static final long serialVersionUID = -1138390681913514558L;

    /** the throwing exception */
    private FileSystem fs;

    /**
    * @param fs filesystem that caused the error
    */
    public EnvironmentNotSupportedException(FileSystem fs) {
        this.fs = fs;
        assert false : "Deprecated.";
    }

    /**
    * @param fs filesystem that caused the error
    * @param reason text description for the error
    */
    public EnvironmentNotSupportedException(FileSystem fs, String reason) {
        super(reason);
        this.fs = fs;
        assert false : "Deprecated.";
    }

    /** Getter for the filesystem that does not support environment operations.
    */
    public FileSystem getFileSystem() {
        return fs;
    }
}




import java.util.concurrent.Callable;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openide.util.BaseUtilities;

/** Holds FileChangeListener and File pair and handle movement of auxiliary
 * FileChangeListener to the first existing upper folder and firing appropriate events.

    private boolean isOnTarget = false;

    public FileChangeImpl(FileChangeListener listener, File path) {
        super(listener, BaseUtilities.activeReferenceQueue());
        assert path != null;
        this.path = path;
    }

    }

    static FileChangeListener removeFileChangeListenerImpl(Logger logger, FileChangeListener listener, File path) {
        assert FileUtil.assertNormalized(path, BaseUtilities.isMac());
        logger.log(Level.FINE, "removeFileChangeListener {0} @ {1}", new Object[]{listener, path});
        synchronized (holders) {
            Map<File, FileChangeImpl> f2H = holders.get(listener);




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 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.openide.filesystems;

import java.awt.Component;
import java.awt.FileDialog;
import java.awt.Frame;
import java.awt.HeadlessException;
import java.awt.KeyboardFocusManager;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import javax.swing.Icon;
import javax.swing.JFileChooser;
import javax.swing.SwingUtilities;
import javax.swing.filechooser.FileFilter;
import javax.swing.filechooser.FileSystemView;
import javax.swing.filechooser.FileView;
import org.netbeans.modules.openide.filesystems.FileFilterSupport;
import org.openide.util.*;

/**
 * Utility class for working with JFileChoosers.  In particular, remembering
 * the last-used directory for a given file is made transparent.  You pass an
 * ad-hoc string key to the constructor (the fully qualified name of the
 * calling class is good for uniqueness, and there is a constructor that takes
 * a <code>Class</code> object as an argument for this purpose).  That key is
 * used to look up the most recently-used directory from any previous invocations
 * with the same key.  This makes it easy to have your user interface
 * &ldquo;remember&rdquo; where the user keeps particular types of files, and
 * saves the user from having to navigate through the same set of directories
 * every time they need to locate a file from a particular place.
 * <p/>
 * <code>FileChooserBuilder</code>'s methods each return <code>this</code>, so
 * it is possible to chain invocations to simplify setting up a file chooser.
 * Example usage:
 * <pre>
 *      <font color="gray">//The default dir to use if no value is stored</font>
 *      File home = new File (System.getProperty("user.home") + File.separator + "lib");
 *      <font color="gray">//Now build a file chooser and invoke the dialog in one line of code</font>
 *      <font color="gray">//&quot;libraries-dir&quot; is our unique key</font>
 *      File toAdd = new FileChooserBuilder ("libraries-dir").setTitle("Add Library").
 *              setDefaultWorkingDirectory(home).setApproveText("Add").showOpenDialog();
 *      <font color="gray">//Result will be null if the user clicked cancel or closed the dialog w/o OK</font>
 *      if (toAdd != null) {
 *          //do something
 *      }
 *</pre>
 * <p/>
 * Instances of this class are intended to be thrown away after use.  Typically
 * you create a builder, set it to create file choosers as you wish, then
 * use it to show a dialog or create a file chooser you then do something
 * with.
 * <p/>
 * Supports the most common subset of JFileChooser functionality;  if you
 * need to do something exotic with a file chooser, you are probably better
 * off creating your own.
 * <p/>
 * <b>Note:</b> If you use the constructor that takes a <code>Class</code> object,
 * please use <code>new FileChooserBuilder(MyClass.class)</code>, not
 * <code>new FileChooserBuilder(getClass())</code>.  This avoids unexpected
 * behavior in the case of subclassing.
 *
 * @author Tim Boudreau
 */
public class FileChooserBuilder {
    private boolean dirsOnly;
    private BadgeProvider badger;
    private String title;
    private String approveText;
    //Just in case...
    private static boolean PREVENT_SYMLINK_TRAVERSAL =
            !Boolean.getBoolean("allow.filechooser.symlink.traversal"); //NOI18N
    private final String dirKey;
    private File failoverDir;
    private FileFilter filter;
    private boolean fileHiding;
    private boolean controlButtonsShown = true;
    private String aDescription;
    private boolean filesOnly;
    private static final boolean DONT_STORE_DIRECTORIES =
            Boolean.getBoolean("forget.recent.dirs");
    private SelectionApprover approver;
    private final List<FileFilter> filters = new ArrayList<FileFilter>(3);
    private boolean useAcceptAllFileFilter = true;
    /**
     * Create a new FileChooserBuilder using the name of the passed class
     * as the metadata for looking up a starting directory from previous
     * application sessions or invocations.
     * @param type A non-null class object, typically the calling class
     */
    public FileChooserBuilder(Class type) {
        this(type.getName());
    }

    /**
     * Create a new FileChooserBuilder.  The passed key is used as a key
     * into NbPreferences to look up the directory the file chooser should
     * initially be rooted on.
     *
     * @param dirKey A non-null ad-hoc string.  If a FileChooser was previously
     * used with the same string as is passed, then the initial directory
     */
    public FileChooserBuilder(String dirKey) {
        Parameters.notNull("dirKey", dirKey);
        this.dirKey = dirKey;
    }

    /**
     * Set whether or not any file choosers created by this builder will show
     * only directories.
     * @param val true if files should not be shown
     * @return this
     */
    public FileChooserBuilder setDirectoriesOnly(boolean val) {
        dirsOnly = val;
        assert !filesOnly : "FilesOnly and DirsOnly are mutually exclusive";
        return this;
    }

    public FileChooserBuilder setFilesOnly(boolean val) {
        filesOnly = val;
        assert !dirsOnly : "FilesOnly and DirsOnly are mutually exclusive";
        return this;
    }

    /**
     * Provide an implementation of BadgeProvider which will "badge" the
     * icons of some files.
     *
     * @param provider A badge provider which will alter the icon of files
     * or folders that may be of particular interest to the user
     * @return this
     */
    public FileChooserBuilder setBadgeProvider(BadgeProvider provider) {
        this.badger = provider;
        return this;
    }

    /**
     * Set the dialog title for any JFileChoosers created by this builder.
     * @param val A localized, human-readable title
     * @return this
     */
    public FileChooserBuilder setTitle(String val) {
        title = val;
        return this;
    }

    /**
     * Set the text on the OK button for any file chooser dialogs produced
     * by this builder.
     * @param val A short, localized, human-readable string
     * @return this
     */
    public FileChooserBuilder setApproveText(String val) {
        approveText = val;
        return this;
    }

    /**
     * Set a file filter which filters the list of selectable files.
     * @param filter
     * @return this
     */
    public FileChooserBuilder setFileFilter (FileFilter filter) {
        this.filter = filter;
        return this;
    }

    /**
     * Determines whether the <code>AcceptAll FileFilter</code> is used
     * as an available choice in the choosable filter list.
     * If false, the <code>AcceptAll</code> file filter is removed from
     * the list of available file filters.
     * If true, the <code>AcceptAll</code> file filter will become the
     * the actively used file filter.
     * @param accept whether the <code>AcceptAll FileFilter</code> is used
     * @return this
     * @since 8.3
     */
    public FileChooserBuilder setAcceptAllFileFilterUsed(boolean accept) {
        useAcceptAllFileFilter = accept;
        return this;
    }

    /**
     * Set the current directory which should be used <b>only if</b>
     * a last-used directory cannot be found for the key string passed
     * into this builder's constructor.
     * @param dir A directory to root any created file choosers on if
     * there is no stored path for this builder's key
     * @return this
     */
    public FileChooserBuilder setDefaultWorkingDirectory (File dir) {
        failoverDir = dir;
        return this;
    }

    /**
     * Enable file hiding in any created file choosers
     * @param fileHiding Whether or not to hide files.  Default is no.
     * @return this
     */
    public FileChooserBuilder setFileHiding(boolean fileHiding) {
        this.fileHiding = fileHiding;
        return this;
    }

    /**
     * Show/hide control buttons
     * @param val Whether or not to hide files.  Default is no.
     * @return this
     */
    public FileChooserBuilder setControlButtonsAreShown(boolean val) {
        this.controlButtonsShown = val;
        return this;
    }

    /**
     * Set the accessible description for any file choosers created by this
     * builder
     * @param aDescription The description
     * @return this
     */
    public FileChooserBuilder setAccessibleDescription(String aDescription) {
        this.aDescription = aDescription;
        return this;
    }

    /**
     * Create a JFileChooser that conforms to the parameters set in this
     * builder.
     * @return A file chooser
     */
    public JFileChooser createFileChooser() {
        JFileChooser result = new SavedDirFileChooser(dirKey, failoverDir,
                force, approver);
        prepareFileChooser(result);
        return result;
    }

    private boolean force = false;
    /**
     * Force use of the failover directory - i.e. ignore the directory key
     * passed in.
     * @param val
     * @return this
     */
    public FileChooserBuilder forceUseOfDefaultWorkingDirectory(boolean val) {
        this.force = val;
        return this;
    }

    /**
     * Tries to find an appropriate component to parent the file chooser to
     * when showing a dialog.
     * @return this
     */
    private Component findDialogParent() {
        Component parent = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
        if (parent == null) {
            parent = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
        }
        if (parent == null) {
            Frame[] f = Frame.getFrames();
            parent = f.length == 0 ? null : f[f.length - 1];
        }
        return parent;
    }

    /**
     * Show an open dialog that allows multiple selection.
     * @return An array of files, or null if the user cancelled the dialog
     */
    public File[] showMultiOpenDialog() {
        JFileChooser chooser = createFileChooser();
        chooser.setMultiSelectionEnabled(true);
        int result = chooser.showOpenDialog(findDialogParent());
        if (JFileChooser.APPROVE_OPTION == result) {
            File[] files = chooser.getSelectedFiles();
            return files == null ? new File[0] : files;
        } else {
            return null;
        }
    }

    /**
     * Show an open dialog with a file chooser set up according to the
     * parameters of this builder.
     * @return A file if the user clicks the accept button and a file or
     * folder was selected at the time the user clicked cancel.
     */
    public File showOpenDialog() {
        JFileChooser chooser = createFileChooser();
        if( Boolean.getBoolean("nb.native.filechooser") ) { //NOI18N
            FileDialog fileDialog = createFileDialog( chooser.getCurrentDirectory() );
            if( null != fileDialog ) {
                return showFileDialog(fileDialog, FileDialog.LOAD );
            }
        }
        chooser.setMultiSelectionEnabled(false);
        int dlgResult = chooser.showOpenDialog(findDialogParent());
        if (JFileChooser.APPROVE_OPTION == dlgResult) {
            File result = chooser.getSelectedFile();
            if (result != null && !result.exists()) {
                result = null;
            }
            return result;
        } else {
            return null;
        }

    }

    /**
     * Show a save dialog with the file chooser set up according to the
     * parameters of this builder.
     * @return A file if the user clicks the accept button and a file or
     * folder was selected at the time the user clicked cancel.
     */
    public File showSaveDialog() {
        JFileChooser chooser = createFileChooser();
        if( Boolean.getBoolean("nb.native.filechooser") ) { //NOI18N
            FileDialog fileDialog = createFileDialog( chooser.getCurrentDirectory() );
            if( null != fileDialog ) {
                return showFileDialog( fileDialog, FileDialog.SAVE );
            }
        }
        int result = chooser.showSaveDialog(findDialogParent());
        if (JFileChooser.APPROVE_OPTION == result) {
            return chooser.getSelectedFile();
        } else {
            return null;
        }
    }
    
    private File showFileDialog( FileDialog fileDialog, int mode ) {
        String oldFileDialogProp = System.getProperty("apple.awt.fileDialogForDirectories"); //NOI18N
        if( dirsOnly ) {
            System.setProperty("apple.awt.fileDialogForDirectories", "true"); //NOI18N
        }
        fileDialog.setMode( mode );
        fileDialog.setVisible(true);
        if( dirsOnly ) {
            if( null != oldFileDialogProp ) {
                System.setProperty("apple.awt.fileDialogForDirectories", oldFileDialogProp); //NOI18N
            } else {
                System.clearProperty("apple.awt.fileDialogForDirectories"); //NOI18N
            }
        }
        if( fileDialog.getDirectory() != null && fileDialog.getFile() != null ) {
            String selFile = fileDialog.getFile();
            File dir = new File( fileDialog.getDirectory() );
            return new File( dir, selFile );
        }
        return null;
    }
    
    private void prepareFileChooser(JFileChooser chooser) {
        chooser.setFileSelectionMode(dirsOnly ? JFileChooser.DIRECTORIES_ONLY
                : filesOnly ? JFileChooser.FILES_ONLY :
                JFileChooser.FILES_AND_DIRECTORIES);
        chooser.setFileHidingEnabled(fileHiding);
        chooser.setControlButtonsAreShown(controlButtonsShown);
        chooser.setAcceptAllFileFilterUsed(useAcceptAllFileFilter);
        if (title != null) {
            chooser.setDialogTitle(title);
        }
        if (approveText != null) {
            chooser.setApproveButtonText(approveText);
        }
        if (badger != null) {
            chooser.setFileView(new CustomFileView(new BadgeIconProvider(badger),
                    chooser.getFileSystemView()));
        }
        if (PREVENT_SYMLINK_TRAVERSAL) {
            FileUtil.preventFileChooserSymlinkTraversal(chooser,
                    chooser.getCurrentDirectory());
        }
        if (filter != null) {
            chooser.setFileFilter(filter);
        }
        if (aDescription != null) {
            chooser.getAccessibleContext().setAccessibleDescription(aDescription);
        }
        if (!filters.isEmpty()) {
            for (FileFilter f : filters) {
                chooser.addChoosableFileFilter(f);
            }
        }
    }

    private FileDialog createFileDialog( File currentDirectory ) {
        if( badger != null )
            return null;
        if( !Boolean.getBoolean("nb.native.filechooser") )
            return null;
        if( dirsOnly && !Utilities.isMac() )
            return null;
        Component parentComponent = findDialogParent();
        Frame parentFrame = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parentComponent);
        FileDialog fileDialog = new FileDialog(parentFrame);
        if (title != null) {
            fileDialog.setTitle(title);
        }
        if( null != currentDirectory )
            fileDialog.setDirectory(currentDirectory.getAbsolutePath());
        return fileDialog;
    }
    
    /**
     * Equivalent to calling <code>JFileChooser.addChoosableFileFilter(filter)</code>.
     * Adds another file filter that can be displayed in the file filters combo
     * box in the file chooser.
     *
     * @param filter The file filter to add
     * @return this
     * @since 7.26.0
     */
    public FileChooserBuilder addFileFilter (FileFilter filter) {
        filters.add (filter);
        return this;
    }

    /**
     * Add all default file filters to the file chooser.
     *
     * @see MIMEResolver.Registration#showInFileChooser()
     * @see MIMEResolver.ExtensionRegistration#showInFileChooser()
     * @return this
     * @since 8.1
     */
    public FileChooserBuilder addDefaultFileFilters() {
        filters.addAll(FileFilterSupport.findRegisteredFileFilters());
        return this;
    }

    /**
     * Set a selection approver which can display an &quot;Overwrite file?&quot;
     * or similar dialog if necessary, when the user presses the accept button
     * in the file chooser dialog.
     *
     * @param approver A SelectionApprover which will determine if the selection
     * is valid
     * @return this
     * @since 7.26.0
     */
    public FileChooserBuilder setSelectionApprover (SelectionApprover approver) {
        this.approver = approver;
        return this;
    }

    /**
     * Object which can approve the selection (enabling the OK button or
     * equivalent) in a JFileChooser.  Equivalent to overriding
     * <code>JFileChooser.approveSelection()</code>
     * @since 7.26.0
     */
    public interface SelectionApprover {
        /**
         * Approve the selection, enabling the dialog to be closed.  Called by
         * the JFileChooser's <code>approveSelection()</code> method.  Use this
         * interface if you want to, for example, show a dialog asking
         * &quot;Overwrite File X?&quot; or similar.
         *
         * @param selection The selected file(s) at the time the user presses
         * the Open, Save or OK button
         * @return true if the selection is accepted, false if it is not and
         * the dialog should not be closed
         */
        public boolean approve (File[] selection);
    }

    private static final class SavedDirFileChooser extends JFileChooser {
        private final String dirKey;
        private final SelectionApprover approver;
        SavedDirFileChooser(String dirKey, File failoverDir, boolean force, SelectionApprover approver) {
            this.dirKey = dirKey;
            this.approver = approver;
            if (force && failoverDir != null && failoverDir.exists() && failoverDir.isDirectory()) {
                setCurrentDirectory(failoverDir);
            } else {
                String path = DONT_STORE_DIRECTORIES ? null :
                    NbPreferences.forModule(FileChooserBuilder.class).get(dirKey, null);
                if (path != null) {
                    File f = new File(path);
                    if (f.exists() && f.isDirectory()) {
                        setCurrentDirectory(f);
                    } else if (failoverDir != null) {
                        setCurrentDirectory(failoverDir);
                    }
                } else if (failoverDir != null) {
                    setCurrentDirectory(failoverDir);
                }
            }
        }

        @Override
        public void approveSelection() {
            if (approver != null) {
                File[] selected = getSelectedFiles();
                final File sf = getSelectedFile();
                if ((selected == null || selected.length == 0) && sf != null) {
                    selected = new File[] { sf };
                }
                boolean approved = approver.approve(selected);
                if (approved) {
                    super.approveSelection();
                }
            } else {
                super.approveSelection();
            }
        }

        @Override
        public int showDialog(Component parent, String approveButtonText) throws HeadlessException {
            int result = super.showDialog(parent, approveButtonText);
            if (result == APPROVE_OPTION) {
                saveCurrentDir();
            }
            return result;
        }

        private void saveCurrentDir() {
            File dir = super.getCurrentDirectory();
            if (!DONT_STORE_DIRECTORIES && dir != null && dir.exists() && dir.isDirectory()) {
                NbPreferences.forModule(FileChooserBuilder.class).put(dirKey, dir.getPath());
            }
        }
    }

    //Can open this API later if there is a use-case
    interface IconProvider {
        public Icon getIcon(File file, Icon orig);
    }

    /**
     * Provides "badges" for icons that indicate files or folders of particular
     * interest to the user.
     * @see FileChooserBuilder#setBadgeProvider
     */
    public interface BadgeProvider {
        /**
         *  Get the badge the passed file should use.  <b>Note:</b> this method
         * is called for every visible file.  The negative test (deciding
         * <i>not</i> to badge a file) should be very, very fast and immediately
         * return null.
         * @param file The file in question
         * @return an icon or null if no change to the appearance of the file
         * is needed
         */
        public Icon getBadge(File file);

        /**
         * Get the x offset for badges produced by this provider.  This is
         * the location of the badge icon relative to the real icon for the
         * file.
         * @return  a rightward pixel offset
         */
        public int getXOffset();

        /**
         * Get the y offset for badges produced by this provider.  This is
         * the location of the badge icon relative to the real icon for the
         * file.
         * @return  a downward pixel offset
         */
        public int getYOffset();
    }

    private static final class BadgeIconProvider implements IconProvider {

        private final BadgeProvider badger;

        public BadgeIconProvider(BadgeProvider badger) {
            this.badger = badger;
        }

        public Icon getIcon(File file, Icon orig) {
            Icon badge = badger.getBadge(file);
            if (badge != null && orig != null) {
                return new MergedIcon(orig, badge, badger.getXOffset(),
                        badger.getYOffset());
            }
            return orig;
        }
    }

    private static final class CustomFileView extends FileView {

        private final IconProvider provider;
        private final FileSystemView view;

        CustomFileView(IconProvider provider, FileSystemView view) {
            this.provider = provider;
            this.view = view;
        }

        @Override
        public Icon getIcon(File f) {
            Icon result = view.getSystemIcon(f);
            result = provider.getIcon(f, result);
            return result;
        }
    }

    private static class MergedIcon implements Icon {

        private Icon icon1;
        private Icon icon2;
        private int xMerge;
        private int yMerge;

        MergedIcon(Icon icon1, Icon icon2, int xMerge, int yMerge) {
            assert icon1 != null;
            assert icon2 != null;
            this.icon1 = icon1;
            this.icon2 = icon2;

            if (xMerge == -1) {
                xMerge = icon1.getIconWidth() - icon2.getIconWidth();
            }

            if (yMerge == -1) {
                yMerge = icon1.getIconHeight() - icon2.getIconHeight();
            }

            this.xMerge = xMerge;
            this.yMerge = yMerge;
        }

        public int getIconHeight() {
            return Math.max(icon1.getIconHeight(), yMerge + icon2.getIconHeight());
        }

        public int getIconWidth() {
            return Math.max(icon1.getIconWidth(), yMerge + icon2.getIconWidth());
        }

        public void paintIcon(java.awt.Component c, java.awt.Graphics g, int x, int y) {
            icon1.paintIcon(c, g, x, y);
            icon2.paintIcon(c, g, x + xMerge, y + yMerge);
        }
    }
}




import org.openide.util.NbBundle;
import org.openide.util.Lookup;
import org.openide.util.Lookup.Result;
import org.openide.util.UserQuestionException;

/** This is the base for all implementations of file objects on a filesystem.
* Provides basic information about the object (its name, parent,

    /** Lock this file.
    * @return lock that can be used to perform various modifications on the file
    * @throws FileAlreadyLockedException if the file is already locked
    * @throws IOException (UserQuestionException) in case when the lock cannot be obtained now,
    *    but the underlaying implementation is able to do it after some
    *    complex/dangerous/long-lasting operation and request confirmation
    *    from the user

     * <li>Then:
     * <ul>
     * <li>If no exception is thrown, proceed with the operation.
     * <li>If a UserQuestionException is thrown,
     * call {@link UserQuestionException#confirmed} on it
     * (asynchronously - do not block any important threads). If <code>true</code>,
     * proceed with the operation. If <code>false</code>, exit.




package org.openide.filesystems;

import java.awt.Image;
import java.awt.Toolkit;
import java.beans.BeanInfo;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

import java.net.URL;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import java.util.logging.Level;
import java.util.logging.Logger;
import org.openide.util.*;
import org.openide.util.actions.SystemAction;
import org.openide.util.lookup.ServiceProvider;
import org.openide.util.lookup.ServiceProviders;


    /** Property name giving read-only state. */
    public static final String PROP_READ_ONLY = "readOnly"; // NOI18N

    /** Property name giving capabilities state. @deprecated No more capabilities. */
    static final String PROP_CAPABILITIES = "capabilities"; // NOI18N    

    /** Used for synchronization purpose*/
    private static final Object internLock = new Object();
    private transient static ThreadLocal<EventControl> thrLocal = new ThreadLocal<EventControl>();

    private transient Repository repository = null;
    private transient FCLSupport fclSupport;

    /** Describes capabilities of the filesystem.
    */
    @Deprecated // have to store it for compat
    private /* XXX JDK #6460147: javac still reports it even though @Deprecated,
               and @SuppressWarnings("deprecation") does not help either: FileSystemCapability*/Object capability;

    /** property listener on FileSystemCapability. */
    private transient PropertyChangeListener capabilityListener;

    /** hidden flag */
    private boolean hidden = false;

    /** system name */
    private String systemName = ""; // NOI18N


        }
    }

    /** Set hidden state of the object.
     * A hidden filesystem is not presented to the user in the Repository list (though it may be present in the Repository Settings list).
    *
    * @param hide <code>true</code> if the filesystem should be hidden
     * @deprecated This property is now useless.
    */
    @Deprecated
    public final void setHidden(boolean hide) {
        if (hide != hidden) {
            hidden = hide;
            firePropertyChange(PROP_HIDDEN, (!hide) ? Boolean.TRUE : Boolean.FALSE, hide ? Boolean.TRUE : Boolean.FALSE);
        }
    }

    /** Getter for the hidden property.
     * @return the hidden property.
     * @deprecated This property is now useless.
    */
    @Deprecated
    public final boolean isHidden() {
        return hidden;
    }

    /** Tests whether filesystem will survive reloading of system pool.
    * If true then when
    * {@link Repository} is reloading its content, it preserves this
    * filesystem in the pool.
    * <P>
    * This can be used when the pool contains system level and user level
    * filesystems. The system ones should be preserved when the user changes
    * the content (for example when he is loading a new project).
    * <p>The default implementation returns <code>false</code>.
    *
    * @return true if the filesystem should be persistent
     * @deprecated This property is long since useless.
    */
    @Deprecated
    protected boolean isPersistent() {
        return false;
    }

    /** Provides a name for the system that can be presented to the user.
    * <P>
    * This call should <STRONG>never</STRONG> be used to attempt to identify the file root

        throw new IOException("Unsupported operation"); // NOI18N
    }
        
    /** Returns an array of actions that can be invoked on any file in
    * this filesystem.
    * These actions should preferably
    * support the {@link org.openide.util.actions.Presenter.Menu Menu},
    * {@link org.openide.util.actions.Presenter.Popup Popup},
    * and {@link org.openide.util.actions.Presenter.Toolbar Toolbar} presenters.
    *
    * @return array of available actions
    */
    public abstract SystemAction[] getActions();

    /**
     * Get actions appropriate to a certain file selection.
     * By default, returns the same list as {@link #getActions()}.
     * @param foSet one or more files which may be selected
     * @return zero or more actions appropriate to those files
     */
    public SystemAction[] getActions(Set<FileObject> foSet) {
        return this.getActions();
    }

    /** Reads object from stream and creates listeners.
    * @param in the input stream to read from
    * @exception IOException error during read

    private void readObject(java.io.ObjectInputStream in)
    throws java.io.IOException, java.lang.ClassNotFoundException {
        in.defaultReadObject();

        if (capability != null) {
            ((FileSystemCapability) capability).addPropertyChangeListener(getCapabilityChangeListener());
        }
    }

    @Override
    public String toString() {
        return getSystemName() + "[" + super.toString() + "]"; // NOI18N
    }
    
    private static volatile Lookup.Result<FileSystem.Status> statusResult;
    
    private static FileSystem.Status defaultStatus() {
        if (statusResult == null) {
            statusResult = Lookup.getDefault().lookupResult(FileSystem.Status.class);
        }
        Iterator<? extends FileSystem.Status> it = statusResult.allInstances().iterator();
        return it.hasNext() ? it.next() : SFS_STATUS;
    *
    * @param env the environment to setup
    * @exception EnvironmentNotSupportedException if external execution
    *    and compilation cannot be supported
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public void prepareEnvironment(Environment env) throws EnvironmentNotSupportedException {
        throw new EnvironmentNotSupportedException(this);
    }

    /**

     * @return the status object for this filesystem
     */
    public Status getStatus() {
        return isDefault() ? defaultStatus() : STATUS_NONE;
    }

    /** The object describing capabilities of this filesystem.
     * Subclasses cannot override it.
     * @return object describing capabilities of this filesystem.
     * @deprecated Capabilities are no longer used.
     */
    @Deprecated
    public final FileSystemCapability getCapability() {
        if (capability == null) {
            capability = new FileSystemCapability.Bean();
            ((FileSystemCapability) capability).addPropertyChangeListener(getCapabilityChangeListener());
        }

        return (FileSystemCapability) capability;
    }

    /** Allows subclasses to change a set of capabilities of the
    * filesystem.
    * @param capability the capability to use
     * @deprecated Capabilities are no longer used.
    */
    @Deprecated
    protected final void setCapability(FileSystemCapability capability) {
        if (this.capability != null) {
            ((FileSystemCapability) this.capability).removePropertyChangeListener(getCapabilityChangeListener());
        }

        this.capability = capability;

        if (this.capability != null) {
            ((FileSystemCapability) this.capability).addPropertyChangeListener(getCapabilityChangeListener());
        }
    }

    /** Executes atomic action. The atomic action represents a set of

        getEventControl().dispatchEvent(run);
    }

    /** returns property listener on FileSystemCapability. */
    private synchronized PropertyChangeListener getCapabilityChangeListener() {
        if (capabilityListener == null) {
            capabilityListener = new PropertyChangeListener() {
                        public void propertyChange(java.beans.PropertyChangeEvent propertyChangeEvent) {
                            firePropertyChange(
                                PROP_CAPABILITIES, propertyChangeEvent.getOldValue(), propertyChangeEvent.getNewValue()
                            );
                        }
                    };
        }

        return capabilityListener;
    }

    private final EventControl getEventControl() {
        EventControl evnCtrl = thrLocal.get();


        public String annotateNameHtml(String name, Set<? extends FileObject> files);
    }

    /** Interface that allows filesystems to set up the Java environment
    * for external execution and compilation.
    * Currently just used to append entries to the external class path.
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public static abstract class Environment extends Object {
        /** Deprecated. */
        public Environment() {
            assert false : "Deprecated.";
        }

        /** Adds one element to the class path environment variable.
        * @param classPathElement string representing the one element
        * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public void addClassPath(String classPathElement) {
        }
    }

    /** Class used to notify events for the filesystem.
    */
    static abstract class EventDispatcher extends Object implements Runnable {

            String bundleName = (String) fo.getAttribute("SystemFileSystem.localizingBundle"); // NOI18N
            if (bundleName != null) {
                try {
                    bundleName = BaseUtilities.translate(bundleName);
                    ResourceBundle b = NbBundle.getBundle(bundleName);
                    try {
                        return b.getString(fo.getPath());

        }

        private Image annotateIcon(FileObject fo, int type) {
            String attr = null;
            if (type == BeanInfo.ICON_COLOR_16x16) {
                attr = "SystemFileSystem.icon"; // NOI18N
            } else if (type == BeanInfo.ICON_COLOR_32x32) {
                attr = "SystemFileSystem.icon32"; // NOI18N
            }
            if (attr != null) {
                Object value = fo.getAttribute(attr);
                if (value != null) {
                    if (value instanceof URL) {
                        return Toolkit.getDefaultToolkit().getImage((URL) value);
                    } else if (value instanceof Image) {
                        // #18832
                        return (Image) value;
                    } else {
                        LOG.warning("Attribute " + attr + " on " + fo + " expected to be a URL or Image; was: " + value);
                    }
                }
            }
            String base = (String) fo.getAttribute("iconBase"); // NOI18N
            if (base != null) {
                if (type == BeanInfo.ICON_COLOR_16x16) {
                    return ImageUtilities.loadImage(base, true);
                } else if (type == BeanInfo.ICON_COLOR_32x32) {
                    return ImageUtilities.loadImage(insertBeforeSuffix(base, "_32"), true); // NOI18N
                }
            }
            return null;
        }





/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 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.openide.filesystems;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Vector;

/** This class defines the capabilities of a filesystem to
* take part in different operations. Some filesystems are
* not designed to allow compilation on them, some do not want
* to be present in class path when executing or debugging
* a program.
* <P>
* Moreover there can be additional capabilities to check
* and this class defines ways how one can communicated with
* a filesystem to find out whether the system is "capable"
* enough to be used in the operation.
*
* @author Jaroslav Tulach
 * @deprecated Now useless.
*/
@Deprecated
public class FileSystemCapability extends Object {
    /** Object that is capable of every thing.
    */
    public static final FileSystemCapability ALL = new FileSystemCapability() {
            public boolean capableOf(FileSystemCapability c) {
                return true;
            }
        };

    /** Well known capability of being compiled.
     * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
     */
    @Deprecated
    public static final FileSystemCapability COMPILE = new FileSystemCapability();

    /** Well known ability to be executed.
     * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
     */
    @Deprecated
    public static final FileSystemCapability EXECUTE = new FileSystemCapability();

    /** Well known ability to be debugged.
     * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
     */
    @Deprecated
    public static final FileSystemCapability DEBUG = new FileSystemCapability();

    /** Well known ability to contain documentation files
     * @deprecated Please use <a href="@org-netbeans-api-java@/org/netbeans/api/queries/JavadocForBinaryQuery.html"><code>JavadocForBinaryQuery</code></a> instead.
     */
    @Deprecated
    public static final FileSystemCapability DOC = new FileSystemCapability();

    public FileSystemCapability() {
        if (DOC == null) {
            // do not report static initializers
            return;
        }

        assert false : "Deprecated.";
    }

    /** Basic operation that tests whether this object
    * is capable to do different capability.
    * <P>
    * The default implementation claims that it is
    * capable to handle only identical capability (==).
    *
    * @param c capability to test
    * @return true if yes
    */
    public boolean capableOf(FileSystemCapability c) {
        return c == this;
    }

    /** All filesystems that are capable of this capability.
    * @return enumeration of FileSystems that satifies this capability
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public Enumeration<? extends FileSystem> fileSystems() {
        class FFS implements org.openide.util.Enumerations.Processor<FileSystem, FileSystem> {
            @Deprecated
            public FileSystem process(FileSystem fs, Collection<FileSystem> ignore) {
                return fs.getCapability().capableOf(FileSystemCapability.this) ? fs : null;
            }
        }

        return org.openide.util.Enumerations.filter(Repository.getDefault().fileSystems(), new FFS());
    }

    /** Find a resource in repository, ignoring not capable filesystems.
    * @param resName name of the resource
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public FileObject findResource(String resName) {
        Enumeration<? extends FileSystem> en = fileSystems();

        while (en.hasMoreElements()) {
            FileSystem fs = en.nextElement();
            FileObject fo = fs.findResource(resName);

            if (fo != null) {
                // object found
                return fo;
            }
        }

        return null;
    }

    /** Searches for the given resource among all filesystems
    * that satifies this capability, returning all matches.
    * @param name name of the resource
    * @return enumeration of {@link FileObject}s
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public Enumeration<? extends FileObject> findAllResources(String name) {
        Vector<FileObject> v = new Vector<FileObject>(8);
        Enumeration<? extends FileSystem> en = fileSystems();

        while (en.hasMoreElements()) {
            FileSystem fs = en.nextElement();
            FileObject fo = fs.findResource(name);

            if (fo != null) {
                v.addElement(fo);
            }
        }

        return v.elements();
    }

    /** Finds file when its name is provided. It scans in the list of
    * filesystems and asks them for the specified file by a call to
    * {@link FileSystem#find find}. The first object that is found is returned or <CODE>null</CODE>
    * if none of the filesystems contain such a file.
    *
    * @param aPackage package name where each package is separated by a dot
    * @param name name of the file (without dots) or <CODE>null</CODE> if
    *    one wants to obtain the name of a package and not a file in it
    * @param ext extension of the file or <CODE>null</CODE> if one needs
    *    a package and not a file name
    *
    * @return {@link FileObject} that represents file with given name or
    *   <CODE>null</CODE> if the file does not exist
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public final FileObject find(String aPackage, String name, String ext) {
        Enumeration<? extends FileSystem> en = fileSystems();

        while (en.hasMoreElements()) {
            FileSystem fs = en.nextElement();
            FileObject fo = fs.find(aPackage, name, ext);

            if (fo != null) {
                // object found
                return fo;
            }
        }

        return null;
    }

    /** Finds all files among all filesystems with this capability
    * that match a given name, returning all matches.
    * All filesystems are queried with {@link FileSystem#find}.
    *
    * @param aPackage package name where each package is separated by a dot
    * @param name name of the file (without dots) or <CODE>null</CODE> if
    *    one wants to obtain the name of a package and not a file in it
    * @param ext extension of the file or <CODE>null</CODE> if one needs
    *    a package and not a file name
    *
    * @return enumeration of {@link FileObject}s
    * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
    */
    @Deprecated
    public final Enumeration<? extends FileObject> findAll(String aPackage, String name, String ext) {
        Enumeration<? extends FileSystem> en = fileSystems();
        Vector<FileObject> ret = new Vector<FileObject>();

        while (en.hasMoreElements()) {
            FileSystem fs = (FileSystem) en.nextElement();
            FileObject fo = fs.find(aPackage, name, ext);

            if (fo != null) {
                ret.addElement(fo);
            }
        }

        return ret.elements();
    }

    /** Adds PropertyChange listener. Every class which implements changes of capabilities
    * has to implement it's property change support.
    * @param l the listener to be added.
    */
    public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
    }

    /** Removes PropertyChange listener. Every class which implements changes of capabilities
    * has to implement it's property change support.
    * @param l the listener to be removed.
    */
    public void removePropertyChangeListener(PropertyChangeListener l) {
    }

    /** Default implementation of capabilities, that behaves like
    * JavaBean and allows to set whether the well known
    * capabilities (like compile, execute) should be enabled
    * or not.
     * @deprecated For the same reason the whole class is.
    */
    @Deprecated
    public static class Bean extends FileSystemCapability implements java.io.Serializable {
        static final long serialVersionUID = 627905674809532736L;

        /** change listeners */
        private transient PropertyChangeSupport supp;

        /** compilation */
        private boolean compilation = true;

        /** execution */
        private boolean execution = true;

        /** debugging */
        private boolean debug = true;

        /** doc */
        private boolean doc = false;

        /** Checks for well known capabilities and if they are allowed.
        *
        * @param c capability to test
        * @return true if yes
        */
        public boolean capableOf(FileSystemCapability c) {
            if (c == COMPILE) {
                return compilation;
            }

            if (c == EXECUTE) {
                return execution;
            }

            if (c == DEBUG) {
                return debug;
            }

            if (c == DOC) {
                return doc;
            }

            if (c == ALL) {
                return true;
            }

            if (!(c instanceof Bean)) {
                return false;
            }

            // try match of values
            Bean b = (Bean) c;

            return (compilation == b.compilation) && (execution == b.execution) && (debug == b.debug) &&
            (doc == b.doc);
        }

        /** Getter for value of compiling capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public boolean getCompile() {
            return compilation;
        }

        /** Setter for allowing compiling capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public void setCompile(boolean val) {
            if (val != compilation) {
                compilation = val;

                if (supp != null) {
                    supp.firePropertyChange(
                        "compile", // NOI18N
                        (!val) ? Boolean.TRUE : Boolean.FALSE, val ? Boolean.TRUE : Boolean.FALSE
                    );
                }
            }
        }

        /** Getter for value of executiong capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public boolean getExecute() {
            return execution;
        }

        /** Setter for allowing executing capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public void setExecute(boolean val) {
            if (val != execution) {
                execution = val;

                if (supp != null) {
                    supp.firePropertyChange(
                        "execute", // NOI18N
                        (!val) ? Boolean.TRUE : Boolean.FALSE, val ? Boolean.TRUE : Boolean.FALSE
                    );
                }
            }
        }

        /** Getter for value of debugging capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public boolean getDebug() {
            return debug;
        }

        /** Setter for allowing debugging capability.
         * @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
        */
        @Deprecated
        public void setDebug(boolean val) {
            if (val != debug) {
                debug = val;

                if (supp != null) {
                    supp.firePropertyChange(
                        "debug", // NOI18N
                        (!val) ? Boolean.TRUE : Boolean.FALSE, val ? Boolean.TRUE : Boolean.FALSE
                    );
                }
            }
        }

        /** Getter for value of doc capability.
         * @deprecated Please use <a href="@org-netbeans-api-java@/org/netbeans/api/queries/JavadocForBinaryQuery.html"><code>JavadocForBinaryQuery</code></a> instead.
        */
        @Deprecated
        public boolean getDoc() {
            return doc;
        }

        /** Setter for allowing debugging capability.
         * @deprecated Please use <a href="@org-netbeans-api-java@/org/netbeans/api/queries/JavadocForBinaryQuery.html"><code>JavadocForBinaryQuery</code></a> instead.
        */
        @Deprecated
        public void setDoc(boolean val) {
            if (val != doc) {
                doc = val;

                if (supp != null) {
                    supp.firePropertyChange(
                        "doc", // NOI18N
                        (!val) ? Boolean.TRUE : Boolean.FALSE, val ? Boolean.TRUE : Boolean.FALSE
                    );
                }
            }
        }

        public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
            if (supp == null) {
                supp = new PropertyChangeSupport(this);
            }

            supp.addPropertyChangeListener(l);
        }

        public void removePropertyChangeListener(PropertyChangeListener l) {
            if (supp != null) {
                supp.removePropertyChangeListener(l);
            }
        }
    }
}




import java.util.jar.JarInputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileSystemView;
import org.netbeans.modules.openide.filesystems.declmime.MIMEResolverImpl;
import org.openide.filesystems.FileSystem.AtomicAction;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;
import org.openide.util.Parameters;
import org.openide.util.RequestProcessor;
import org.openide.util.BaseUtilities;
import org.openide.util.WeakListeners;
import org.openide.util.lookup.implspi.NamedServicesProvider;


            }

            if ((fileURL != null) && "file".equals(fileURL.getProtocol())) {
                retVal = BaseUtilities.toFile(URI.create(fileURL.toExternalForm()));
            }
        }
        assert assertNormalized(retVal, BaseUtilities.isMac()); // #240180
        return retVal;
    }



        FileObject retVal = null;
        try {
            URL url = BaseUtilities.toURI(file).toURL();
            retVal = URLMapper.findFileObject(url);

            /*probably temporary piece of code to catch the cause of #46630*/

        }

        try {
            URL url = (BaseUtilities.toURI(file).toURL());
            retVal = URLMapper.findFileObjects(url);
        } catch (MalformedURLException e) {
            retVal = null;

     * @return true, if such name does not exists
     */
    private static boolean checkFreeName(FileObject fo, String name, String ext) {
        if ((BaseUtilities.isWindows() || (BaseUtilities.getOperatingSystem() == BaseUtilities.OS_OS2)) || BaseUtilities.isMac()) {
            // case-insensitive, do some special check
            Enumeration<? extends FileObject> en = fo.getChildren(false);


        LOG.log(Level.FINE, "FileUtil.normalizeFile for {0}", file); // NOI18N

        long now = System.currentTimeMillis();
        if ((BaseUtilities.isWindows() || (BaseUtilities.getOperatingSystem() == BaseUtilities.OS_OS2))) {
            retFile = normalizeFileOnWindows(file);
        } else if (BaseUtilities.isMac()) {
            retFile = normalizeFileOnMac(file);
        } else {
            retFile = normalizeFileOnUnixAlike(file);

    private static File normalizeFileOnUnixAlike(File file) {
        // On Unix, do not want to traverse symlinks.
        // URI.normalize removes ../ and ./ sequences nicely.
        file = BaseUtilities.toFile(BaseUtilities.toURI(file).normalize()).getAbsoluteFile();
        while (file.getAbsolutePath().startsWith("/../")) { // NOI18N
            file = new File(file.getAbsolutePath().substring(3));
        }


        try {
            // URI.normalize removes ../ and ./ sequences nicely.            
            File absoluteFile = BaseUtilities.toFile(BaseUtilities.toURI(file).normalize());
            File canonicalFile = file.getCanonicalFile();
            String absolutePath = absoluteFile.getAbsolutePath();
            if (absolutePath.equals("/..")) { // NOI18N

            }
        }
        // #135547 - on Windows Vista map "Documents and Settings\<username>\My Documents" to "Users\<username>\Documents"
        if((BaseUtilities.getOperatingSystem() & BaseUtilities.OS_WINVISTA) != 0) {
            if(retVal == null) {
                retVal = file.getAbsoluteFile();
            }

            do {
                wasDir = entry.isDirectory();
                LOG.finest("urlForArchiveOrDir:toURI:entry");   //NOI18N
                u = BaseUtilities.toURI(entry).toURL();
                isDir = entry.isDirectory();
            } while (wasDir ^ isDir);
            if (isArchiveFile(u) || entry.isFile() && entry.length() < 4) {

    public static File archiveOrDirForURL(URL entry) {
        String u = entry.toString();
        if (u.startsWith("jar:file:") && u.endsWith("!/")) { // NOI18N
            return BaseUtilities.toFile(URI.create(u.substring(4, u.length() - 2)));
        } else if (u.startsWith("file:")) { // NOI18N
            return BaseUtilities.toFile(URI.create(u));
        } else {
            return null;
        }

     * Make sure that a JFileChooser does not traverse symlinks on Unix.
     * @param chooser a file chooser
     * @param currentDirectory if not null, a file to set as the current directory
     *                         using {@link javax.swing.JFileChooser#setCurrentDirectory} without canonicalizing
     * @see <a href="http://www.netbeans.org/issues/show_bug.cgi?id=46459">Issue #46459</a>
     * @see <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4906607">JRE bug #4906607</a>
     * @since org.openide/1 4.42
     * @deprecated Just use {@link javax.swing.JFileChooser#setCurrentDirectory}. JDK 6 does not have this bug.
     */
    @Deprecated
    public static void preventFileChooserSymlinkTraversal(javax.swing.JFileChooser chooser, File currentDirectory) {
        chooser.setCurrentDirectory(currentDirectory);
    }


        }
    }

    private static final class NonCanonicalizingFileSystemView extends FileSystemView {
        private final FileSystemView delegate = FileSystemView.getFileSystemView();

        public NonCanonicalizingFileSystemView() {
        }

        @Override
        public boolean isFloppyDrive(File dir) {
            return delegate.isFloppyDrive(dir);
        }

        @Override
        public boolean isComputerNode(File dir) {
            return delegate.isComputerNode(dir);
        }

        public File createNewFolder(File containingDir)
        throws IOException {
            return wrapFileNoCanonicalize(delegate.createNewFolder(containingDir));
        }

        @Override
        public boolean isDrive(File dir) {
            return delegate.isDrive(dir);
        }

        @Override
        public boolean isFileSystemRoot(File dir) {
            return delegate.isFileSystemRoot(dir);
        }

        @Override
        public File getHomeDirectory() {
            return wrapFileNoCanonicalize(delegate.getHomeDirectory());
        }

        @Override
        public File createFileObject(File dir, String filename) {
            return wrapFileNoCanonicalize(delegate.createFileObject(dir, filename));
        }

        @Override
        public Boolean isTraversable(File f) {
            return delegate.isTraversable(f);
        }

        @Override
        public boolean isFileSystem(File f) {
            return delegate.isFileSystem(f);
        }

        /*
        protected File createFileSystemRoot(File f) {
            return translate(delegate.createFileSystemRoot(f));
        }
         */
        @Override
        public File getChild(File parent, String fileName) {
            return wrapFileNoCanonicalize(delegate.getChild(parent, fileName));
        }

        @Override
        public File getParentDirectory(File dir) {
            return wrapFileNoCanonicalize(delegate.getParentDirectory(dir));
        }

        @Override
        public Icon getSystemIcon(File f) {
            return delegate.getSystemIcon(f);
        }

        @Override
        public boolean isParent(File folder, File file) {
            return delegate.isParent(folder, file);
        }

        @Override
        public String getSystemTypeDescription(File f) {
            return delegate.getSystemTypeDescription(f);
        }

        @Override
        public File getDefaultDirectory() {
            return wrapFileNoCanonicalize(delegate.getDefaultDirectory());
        }

        @Override
        public String getSystemDisplayName(File f) {
            return delegate.getSystemDisplayName(f);
        }

        @Override
        public File[] getRoots() {
            return wrapFilesNoCanonicalize(delegate.getRoots());
        }

        @Override
        public boolean isHiddenFile(File f) {
            return delegate.isHiddenFile(f);
        }

        @Override
        public File[] getFiles(File dir, boolean useFileHiding) {
            return wrapFilesNoCanonicalize(delegate.getFiles(dir, useFileHiding));
        }

        @Override
        public boolean isRoot(File f) {
            return delegate.isRoot(f);
        }

        @Override
        public File createFileObject(String path) {
            return wrapFileNoCanonicalize(delegate.createFileObject(path));
        }
    }
    
    private static FileSystem getDiskFileSystem() {
        synchronized (FileUtil.class) {
            return diskFileSystem;




import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;
import org.openide.util.RequestProcessor.Task;
import org.openide.util.BaseUtilities;

/** A virtual filesystem based on a JAR archive.
* <p>For historical reasons many AbstractFileSystem.* methods are implemented

        this.attr = impl;
    }

   /** Creates new JAR for a given JAR file. This constructor
    * Constructor that can provide own capability for the filesystem.
    * @param cap the capability
     * @deprecated Useless.
    */
    @Deprecated
    public JarFileSystem(FileSystemCapability cap) {
        this();
        setCapability(cap);
    }

    /** Creates new JAR for a given JAR file. This constructor
     * behaves basically like:
     * <pre>
     * JarFileSystem fs = new JarFileSystem();

    //        super.addNotify ();
    //    }

    /** Prepare environment for external compilation or execution.
    * <P>
    * Adds name of the ZIP/JAR file, if it has been set, to the class path.
     * @deprecated Useless.
    */
    @Deprecated
    @Override
    public void prepareEnvironment(Environment env) {
        if (root != null) {
            env.addClassPath(root.getAbsolutePath());
        }
    }

    //
    // List

    }
    
    private static void dumpFDs() {
        if (BaseUtilities.isUnix()) {
            String selfName = ManagementFactory.getRuntimeMXBean().getName().replaceAll("@.*", ""); // NOI18N
            LOGGER.log(Level.INFO, "Dumping file descriptors for pid {0}", selfName); // NOI18N
            int pid;

     */
    private class Ref<T extends FileObject> extends WeakReference<T> implements Runnable {
        public Ref(T fo) {
            super(fo, BaseUtilities.activeReferenceQueue());
        }

        // do the cleanup




import java.util.logging.Level;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;
import org.openide.util.BaseUtilities;

/** Local filesystem. Provides access to files on local disk.
* <p>For historical reasons many AbstractFileSystem.* methods are implemented

        setRefreshTime(REFRESH_TIME);
    }

    /** Constructor. Allows user to provide own capabilities
    * for this filesystem.
    * @param cap capabilities for this filesystem
     * @deprecated Useless.
    */
    @Deprecated
    public LocalFileSystem(FileSystemCapability cap) {
        this();
        setCapability(cap);
    }

    /* Human presentable name */
    public String getDisplayName() {
        return rootFile.getAbsolutePath();

        return readOnly;
    }

    /** Prepare environment by adding the root directory of the filesystem to the class path.
    * @param environment the environment to add to
     * @deprecated Useless.
    */
    @Deprecated
    @Override
    public void prepareEnvironment(FileSystem.Environment environment) {
        environment.addClassPath(rootFile.getAbsolutePath());
    }

    /** Compute the system name of this filesystem for a given root directory.
    * <P>
    * The default implementation simply returns the filename separated by slashes.

    protected String computeSystemName(File rootFile) {
        String retVal = rootFile.getAbsolutePath().replace(File.separatorChar, '/');

        return ((BaseUtilities.isWindows() || (BaseUtilities.getOperatingSystem() == BaseUtilities.OS_OS2))) ? retVal.toLowerCase()
                                                                                                 : retVal;
    }


            // #7086 - (nf.exists() && !nf.equals(of)) instead of nf.exists() - fix for Win32
            boolean existsNF = nf.exists();
            boolean equalsOF = nf.equals(of);
            if (BaseUtilities.isMac()) {
                // File.equal on mac is not case insensitive (which it should be), 
                // so try harder
                equalsOF = of.getCanonicalFile().equals(nf.getCanonicalFile());

        OutputStream retVal = new BufferedOutputStream(new FileOutputStream(f));

        // workaround for #42624
        if (BaseUtilities.isMac()) {
            retVal = getOutputStreamForMac42624(retVal, name);
        }





package org.openide.filesystems;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

import org.openide.util.Enumerations;
import org.openide.util.NbBundle;
import org.openide.util.NbCollections;
import org.openide.util.actions.SystemAction;

/**
 * General base class for filesystems which proxy to others.

        return root;
    }

    /** Merge actions from all delegates.
    */
    public @Override SystemAction[] getActions() {
        List<SystemAction> al = new ArrayList<SystemAction>(101); // randomly choosen constant
        Set<SystemAction> uniq = new HashSet<SystemAction>(101); // not that randommly choosen

        FileSystem[] del = this.getDelegates();

        for (int i = 0; i < del.length; i++) {
            if (del[i] == null) {
                continue;
            }

            SystemAction[] acts = del[i].getActions();

            for (int j = 0; j < acts.length; j++) {
                if (uniq.add(acts[j])) {
                    al.add(acts[j]);
                }
            }
        }

        return al.toArray(new SystemAction[al.size()]);
    }

    public @Override SystemAction[] getActions(final Set<FileObject> foSet) {
        List<SystemAction> al = new ArrayList<SystemAction>(101); // randomly choosen constant
        Set<SystemAction> uniq = new HashSet<SystemAction>(101); // not that randommly choosen

        final FileSystem[] del = this.getDelegates();

        for (int i = 0; i < del.length; i++) {
            if (del[i] == null) {
                continue;
            }

            final SystemAction[] acts = del[i].getActions(foSet);

            for (int j = 0; j < acts.length; j++) {
                if (uniq.add(acts[j])) {
                    al.add(acts[j]);
                }
            }
        }

        return al.toArray(new SystemAction[al.size()]);
    }

    @Deprecated // have to override for compat
    public @Override FileObject find(String aPackage, String name, String ext) {
        // create enumeration of name to look for

    protected void markUnimportant(FileObject fo) {
    }

    /** Lets any sub filesystems prepare the environment.
     * If they do not support it, it does not care.
     * @deprecated Useless.
     */
    @Deprecated
    public @Override void prepareEnvironment(FileSystem.Environment env)
    throws EnvironmentNotSupportedException {
        FileSystem[] layers = getDelegates();

        for (int i = 0; i < layers.length; i++) {
            if (layers[i] != null) {
                try {
                    layers[i].prepareEnvironment(env);
                } catch (EnvironmentNotSupportedException ense) {
                    // Fine.
                }
            }
        }
    }

    /** Notifies all encapsulated filesystems in advance
    * to superclass behaviour. */
    public @Override void addNotify() {

Lines 47-53 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/Ordering.java (-2 / +2 lines)
47	import java.util.logging.Logger;	47	import java.util.logging.Logger;
48	import org.openide.util.NbCollections;	48	import org.openide.util.NbCollections;
49	import org.openide.util.TopologicalSortException;	49	import org.openide.util.TopologicalSortException;
50	import org.openide.util.Utilities;	50	import org.openide.util.BaseUtilities;
51		51
52	/**	52	/**
53	* Implements folder ordering logic in {@link FileUtil}.	53	* Implements folder ordering logic in {@link FileUtil}.
Lines 209-215 Link Here
209	return new ArrayList<FileObject>(children);	209	return new ArrayList<FileObject>(children);
210	} else {	210	} else {
211	try {	211	try {
212	return Utilities.topologicalSort(children, edges);	212	return BaseUtilities.topologicalSort(children, edges);
213	} catch (TopologicalSortException x) {	213	} catch (TopologicalSortException x) {
214	if (logWarnings) {	214	if (logWarnings) {
215	LOG.log(Level.WARNING, "Contradictory partial ordering in " + parent.getPath(), x);	215	LOG.log(Level.WARNING, "Contradictory partial ordering in " + parent.getPath(), x);

Lines 631-637 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/Repository.java (-2 / +2 lines)
631	while (iter.hasNext()) {	631	while (iter.hasNext()) {
632	FileSystem fs = (FileSystem) iter.next();	632	FileSystem fs = (FileSystem) iter.next();
633		633
634	if (!fs.isDefault() && !fs.isPersistent()) {	634	if (!fs.isDefault()) {
635	oos.writeObject(new NbMarshalledObject(fs));	635	oos.writeObject(new NbMarshalledObject(fs));
636	}	636	}
637	}	637	}
Lines 688-694 Link Here
688	while (ee.hasMoreElements()) {	688	while (ee.hasMoreElements()) {
689	fs = ee.nextElement();	689	fs = ee.nextElement();
690		690
691	if (!fs.isPersistent()) {	691	if (!fs.isDefault()) {
692	removeFileSystem(fs);	692	removeFileSystem(fs);
693	}	693	}
694	}	694	}




import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.BaseUtilities;

/** Mapper from FileObject -> URL.
 * Should be registered in default lookup. For details see {@link Lookup#getDefault()}.

                    // XXX clumsy; see ArchiveURLMapper for possible cleaner style
                    String toReplace = "__EXCLAMATION_REPLACEMENT__";//NOI18N
                    retURL = new URL(
                            "jar:" + BaseUtilities.toURI(new File(f,toReplace + fo.getPath())).toString().replaceFirst("/"+toReplace,"!/") + // NOI18N
                            ((fo.isFolder() && !fo.isRoot()) ? "/" : "")
                        ); // NOI18N
                } catch (MalformedURLException mfx) {

        }

        private static URL toURL(File fFile, FileObject fo) throws MalformedURLException {
            URL retVal = BaseUtilities.toURI(fFile).toURL();
            if (retVal != null && fo.isFolder()) {
                // #155742,160333 - URL for folder must always end with slash
                final String urlDef = retVal.toExternalForm();

            try {
                URI uri = new URI(u.toExternalForm());

                return FileUtil.normalizeFile(BaseUtilities.toFile(uri));
            } catch (URISyntaxException use) {
                // malformed URL
                return null;




import org.openide.util.Enumerations;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;
import org.openide.util.BaseUtilities;
import org.openide.xml.XMLUtil;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;

    * for this filesystem.
    * @param cap capabilities for this filesystem
     * @deprecated Useless.
    */
    @Deprecated
    public XMLFileSystem(FileSystemCapability cap) {
        this();
        setCapability(cap);
    }
    */

    /** Getter of url field.
     * @return URL associated with XMLFileSystem or null if no URL was set.

                
                if ("file".equals(protocol)) { //NOI18N
                    try {
                        File f = BaseUtilities.toFile(URI.create(url.toExternalForm()));
                        if (!f.equals(lastFile)) {
                            lastFile = f;
                            lastFileDate = new Date(f.lastModified());




import java.util.TreeSet;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import org.netbeans.modules.openide.filesystems.RecognizeInstanceFiles;
import org.openide.util.NbBundle;
import org.openide.util.BaseUtilities;
import org.openide.util.Utilities;
import org.openide.util.io.NbMarshalledObject;
import org.openide.util.io.NbObjectInputStream;


                    case 11:
                        return URL.class;
                    case 12:
                        return ExternalUtil.findClass(BaseUtilities.translate(value));
                    case 13:
                        return String.class;
                }

                        return new URL(value);
                    case 12:
                        // special support for singletons
                        Class cls = ExternalUtil.findClass(BaseUtilities.translate(value));
                        return RecognizeInstanceFiles.createInstance(cls);
                        if (SharedClassObject.class.isAssignableFrom(cls)) {
                            return SharedClassObject.findObject(cls, true);
                        } else {
                            Constructor<?> init = cls.getDeclaredConstructor();
                            init.setAccessible(true);
                            return init.newInstance((Object[]) null);
                        }
                    case 13:
                        String[] arr = value.split("#", 2); // NOI18N
                        return NbBundle.getBundle(arr[0]).getObject(arr[1]);




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 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 2014 Sun Microsystems, Inc.
 */

package org.openide.filesystems.spi;

/**
 * Creates instance of the desired class based on the file.
 * Module providers may register factories to control creation of instances
 * from files that use only file name or {@code instanceClass} attribute.
 * <p/>
 * Registered factories are called in the registration order, until one provides
 * a non-null result, which become the file's created instance. If all factories
 * return {@code null}, the FileSystems API will create the instance using the default
 * constructor.
 * 
 * <p/>
 * Module implementors are encouraged to use the <code>instanceCreate</code> attribute
 * instead.
 * 
 * @author sdedic
 * @since 9.0
 */
public interface CustomInstanceFactory {
    /**
     * Creates an instance of the class.
     * 
     * @param <T> the desired type
     * @param clazz the desired type
     * @return an instance of the `clazz' or <code>null</code>
     */
    public <T> T createInstance(Class<T> clazz);
}

Lines 51-57 Link Here

(-)a/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/FSFoldersInLookupTest.java (-2 / +1 lines)
51	import org.openide.filesystems.FileObject;	51	import org.openide.filesystems.FileObject;
52	import org.openide.filesystems.FileUtil;	52	import org.openide.filesystems.FileUtil;
53	import org.openide.util.Lookup;	53	import org.openide.util.Lookup;
54	import org.openide.util.SharedClassObject;
55		54
56	/**	55	/**
57	* @author Jaroslav Tulach	56	* @author Jaroslav Tulach
Lines 104-109 Link Here
104	assertNull("not found again", Lookup.getDefault().lookup(Shared.class));	103	assertNull("not found again", Lookup.getDefault().lookup(Shared.class));
105	}	104	}
106		105
107	public static final class Shared extends SharedClassObject {}	106	public static final class Shared {}
108		107
109	}	108	}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 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 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.openide.filesystems;

import java.io.File;
import java.util.List;
import javax.swing.filechooser.FileFilter;
import org.netbeans.junit.NbTestCase;
import org.openide.filesystems.MIMEResolver;
import org.openide.util.NbBundle;

/**
 * Test registered FileFilters.
 *
 * @author jhavlin
 */
@NbBundle.Messages({
    "RESOLVER=Resolver",
    "FILECHOOSER=BNM Files"
})
@MIMEResolver.Registration(
    displayName = "#RESOLVER",
resource = "mime-resolver-filechooser.xml",
showInFileChooser = "#FILECHOOSER", position=543543)
public class FileFilterSupportTest extends NbTestCase {

    public FileFilterSupportTest(String name) {
        super(name);
    }

    /**
     * This test, although it is quite short, tests a lot of ascpects of default
     * file filters. The resolver definition XML file contains several
     * duplicities, which are detected and ignored. If this detection fails,
     * filter description and {@code accept} method is changed, and it is cought
     * by this test.
     */
    public void testRegisteredFilters() {
        List<FileFilter> list = FileFilterSupport.findRegisteredFileFilters();
        assertNotNull(list);
        assertFalse(list.isEmpty());

        boolean found = false;
        for (FileFilter filter : list) {

            if (filter.getDescription().startsWith("BNM Files")) {
                found = true;
                checkBnmFilesFilter(filter);
            }
        }
        assertTrue("Registered File Filter was not found.", found);
    }

    private void checkBnmFilesFilter(FileFilter f) {
        assertEquals("BNM Files [.bnm, bnmHelp, bnmProject, bnminfo, bnmsettings]",
                f.getDescription());
        assertTrue(f.accept(new File("first.bnm")));
        assertTrue(f.accept(new File("second.BNM")));
        assertTrue(f.accept(new File("third.bNm")));
        assertTrue(f.accept(new File("bnmProject")));
        assertTrue(f.accept(new File("PREFIXbnmProjectAndSuFfIx")));
        assertFalse(f.accept(new File("bnmproject")));
        assertTrue(f.accept(new File("bnmSettings")));
        assertTrue(f.accept(new File("BNMSETTINGS")));
        assertFalse(f.accept(new File("bnmSettingsX")));
        assertTrue(f.accept(new File("bnmInfo")));
        assertTrue(f.accept(new File("AbnmInfoB")));
        assertTrue(f.accept(new File("aBNMINFOb")));
        assertTrue(f.accept(new File("bnmHelp")));
        assertFalse(f.accept(new File("bnmhelp")));
        assertFalse(f.accept(new File("bnmHelpX")));
        assertFalse(f.accept(new File("foo.txt")));
    }
}




import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.util.Lookup;
import org.openide.util.SharedClassObject;
import org.openide.util.lookup.Lookups;
import org.openide.util.lookup.NamedServicesLookupTest;


    public static final class Inst extends Object {
    }

    public void testSharedClassObject() throws Exception {
        Shared instance = SharedClassObject.findObject(Shared.class, true);
        FileObject data = FileUtil.createData(root, "dir/" + Shared.class.getName().replace('.', '-') + ".instance");
        Lookup l = Lookups.forPath("dir");
        assertSame(instance, l.lookup(Shared.class));
        
        Shared created = FileUtil.getConfigObject(data.getPath(), Shared.class);
        assertSame("Config file found", instance, created);
    }
    public void testNullForFolders() throws Exception {
        FileObject data = FileUtil.createFolder(root, "dir/" + Shared.class.getName().replace('.', '-') + ".instance");
        Shared nul = FileUtil.getConfigObject(data.getPath(), Shared.class);
        assertNull("No object for folders", nul);
    }

    public static final class Shared {}

    public void testDoNotCreateFoldersJustBecauseILookedThemUp() throws Exception {
        assertEquals(0, Lookups.forPath("nonexistent").lookupAll(Object.class).size());




<?xml version="1.0"?>
<MIME-resolver>
    <file>
        <ext name="bnm"/>
        <resolver mime="text/x-bnm"/>
    </file>

    <!-- BNM PROJECT -->
    <file>
        <!--
            Duplicite resolver that accept less files than the following one.
            Should not be used in the filter.
        -->
        <ext name=""/>
        <name name="bnmProject" substring="false" ignorecase="false" />
        <resolver mime="text/x-bnm-project"/>
    </file>
    <file>
        <ext name=""/>
        <name name="bnmProject" substring="true" ignorecase="false" />
        <resolver mime="text/x-bnm-project"/>
    </file>

    <!-- BNM SETTINGS -->
    <file>
        <ext name=""/>
        <name name="bnmSettings" substring="false" />
        <resolver mime="text/x-bnm-settings"/>
    </file>
    <file>
        <!--
            Duplicite resolver that accept less files than the previous one.
            Should not be used in the filter.
        -->
        <ext name=""/>
        <name name="bnmSettings" substring="false" ignorecase="true" />
        <resolver mime="text/x-bnm-settings"/>
    </file>

    <!-- BNM INFO -->
    <file>
        <ext name=""/>
        <name name="bnmInfo" substring="true" />
        <resolver mime="text/x-bnm-info"/>
    </file>
    <file>
        <!--
            Duplicite resolver that accept the same files as the previous one,
            only differs in case of file name, that is ignored.
            Should not be used in the filter.
        -->
        <ext name=""/>
        <name name="BNMInfo" substring="true" />
        <resolver mime="text/x-bnm-info"/>
    </file>

    <!-- BNM HELP -->
    <file>
        <ext name=""/>
        <name name="bnmHelp" substring="false" ignorecase="false" />
        <resolver mime="text/x-bnm-help"/>
    </file>
</MIME-resolver>

Lines 48-54 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/AttributesTestHidden.java (-2 / +2 lines)
48	import java.util.*;	48	import java.util.*;
49	import java.io.*;	49	import java.io.*;
50	import java.lang.reflect.Method;	50	import java.lang.reflect.Method;
51	import org.openide.util.Utilities;	51	import org.openide.util.BaseUtilities;
52		52
53	/**	53	/**
54	*	54	*
Lines 306-312 Link Here
306	).getBytes());	306	).getBytes());
307	fos.close();	307	fos.close();
308		308
309	XMLFileSystem xfs = new XMLFileSystem(Utilities.toURI(f).toURL());	309	XMLFileSystem xfs = new XMLFileSystem(BaseUtilities.toURI(f).toURL());
310	FileObject template = xfs.findResource("Templates/Other/special");	310	FileObject template = xfs.findResource("Templates/Other/special");
311	assertNotNull("template found", template);	311	assertNotNull("template found", template);
312	FileObject foTested = testedFS.getRoot().createData("copiedTemplate");	312	FileObject foTested = testedFS.getRoot().createData("copiedTemplate");




/*
 * 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 2008 Sun Microsystems, Inc.
 */

package org.openide.filesystems;

import java.awt.Component;
import java.awt.Dialog;
import javax.swing.UIManager;
import javax.swing.JRootPane;
import java.util.concurrent.atomic.AtomicReference;
import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.CountDownLatch;
import java.awt.Container;
import java.awt.EventQueue;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import javax.swing.AbstractButton;
import javax.swing.JFileChooser;
import javax.swing.RootPaneContainer;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
import javax.swing.filechooser.FileFilter;
import javax.swing.plaf.metal.MetalLookAndFeel;
import org.netbeans.junit.NbTestCase;
import org.openide.util.RequestProcessor;
import static org.junit.Assert.*;
import org.netbeans.junit.RandomlyFails;

/**
 * @author tim
 */
public class FileChooserBuilderTest extends NbTestCase {

    public FileChooserBuilderTest(String name) {
        super(name);
    }

    /**
     * Test of setDirectoriesOnly method, of class FileChooserBuilder.
     */
    public void testSetDirectoriesOnly() {
        FileChooserBuilder instance = new FileChooserBuilder("x");
        boolean dirsOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY;
        assertFalse(dirsOnly);
        instance.setDirectoriesOnly(true);
        dirsOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY;
        assertTrue(dirsOnly);
    }

    /**
     * Test of setFilesOnly method, of class FileChooserBuilder.
     */
    public void testSetFilesOnly() {
        FileChooserBuilder instance = new FileChooserBuilder("y");
        boolean filesOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.FILES_ONLY;
        assertFalse(filesOnly);
        instance.setFilesOnly(true);
        filesOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.FILES_ONLY;
        assertTrue(filesOnly);
    }

    /**
     * Test of setTitle method, of class FileChooserBuilder.
     */
    public void testSetTitle() {
        FileChooserBuilder instance = new FileChooserBuilder("a");
        assertNull(instance.createFileChooser().getDialogTitle());
        instance.setTitle("foo");
        assertEquals("foo", instance.createFileChooser().getDialogTitle());
    }

    /**
     * Test of setApproveText method, of class FileChooserBuilder.
     */
    public void testSetApproveText() {
        FileChooserBuilder instance = new FileChooserBuilder("b");
        assertNull(instance.createFileChooser().getDialogTitle());
        instance.setApproveText("bar");
        assertEquals("bar", instance.createFileChooser().getApproveButtonText());
    }

    /**
     * Test of setFileFilter method, of class FileChooserBuilder.
     */
    public void testSetFileFilter() {
        FileFilter filter = new FileFilter() {

            @Override
            public boolean accept(File f) {
                return true;
            }

            @Override
            public String getDescription() {
                return "X";
            }
        };
        FileChooserBuilder instance = new FileChooserBuilder("c");
        instance.setFileFilter(filter);
        assertEquals(filter, instance.createFileChooser().getFileFilter());
    }

    /**
     * Test of setDefaultWorkingDirectory method, of class FileChooserBuilder.
     */
    public void testSetDefaultWorkingDirectory() throws IOException {
        FileChooserBuilder instance = new FileChooserBuilder("d");
        File dir = getWorkDir();
        assertTrue("tmpdir is not sane", dir.exists() && dir.isDirectory());
        instance.setDefaultWorkingDirectory(dir);
        assertEquals(dir, instance.createFileChooser().getCurrentDirectory());
    }

    /**
     * Test of setFileHiding method, of class FileChooserBuilder.
     */
    public void testSetFileHiding() {
        FileChooserBuilder instance = new FileChooserBuilder("e");
        assertFalse(instance.createFileChooser().isFileHidingEnabled());
        instance.setFileHiding(true);
        assertTrue(instance.createFileChooser().isFileHidingEnabled());
    }

    /**
     * Test of setControlButtonsAreShown method, of class FileChooserBuilder.
     */
    public void testSetControlButtonsAreShown() {
        FileChooserBuilder instance = new FileChooserBuilder("f");
        assertTrue(instance.createFileChooser().getControlButtonsAreShown());
        instance.setControlButtonsAreShown(false);
        assertFalse(instance.createFileChooser().getControlButtonsAreShown());
    }

    /**
     * Test of setAccessibleDescription method, of class FileChooserBuilder.
     */
    public void testSetAccessibleDescription() {
        FileChooserBuilder instance = new FileChooserBuilder("g");
        String desc = "desc";
        instance.setAccessibleDescription(desc);
        assertEquals(desc, instance.createFileChooser().getAccessibleContext().getAccessibleDescription());
    }

    /**
     * Test of createFileChooser method, of class FileChooserBuilder.
     */
    public void testCreateFileChooser() {
        FileChooserBuilder instance = new FileChooserBuilder("h");
        assertNotNull(instance.createFileChooser());
    }

    public void testSetSelectionApprover() throws Exception {
        FileChooserBuilder instance = new FileChooserBuilder("i");
        File tmp = new File(System.getProperty("java.io.tmpdir"));
        assertTrue ("Environment is insane", tmp.exists() && tmp.isDirectory());
        File sel = new File("tmp" + System.currentTimeMillis());
        if (!sel.exists()) {
            assertTrue (sel.createNewFile());
        }
        instance.setDefaultWorkingDirectory(tmp);
        SA sa = new SA();
        instance.setSelectionApprover(sa);
        JFileChooser ch = instance.createFileChooser();
        ch.setSelectedFile(sel);
        ch.approveSelection();
        sa.assertApproveInvoked(sel);
    }

    public void testAddFileFilter() {
        FileChooserBuilder instance = new FileChooserBuilder("j");
        FF one = new FF ("a");
        FF two = new FF ("b");
        instance.addFileFilter(one);
        instance.addFileFilter(two);
        JFileChooser ch = instance.createFileChooser();
        Set<FileFilter> ff = new HashSet<FileFilter>(Arrays.asList(one, two));
        Set<FileFilter> actual = new HashSet<FileFilter>(Arrays.asList(ch.getChoosableFileFilters()));
        assertTrue (actual.containsAll(ff));
        //actual should also contain JFileChooser.getAcceptAllFileFilter()
        assertEquals (ff.size() + 1, actual.size());
    }

    public void testSetAcceptAllFileFilterUsed() {
        FileChooserBuilder instance = new FileChooserBuilder("k");
        assertTrue(instance.createFileChooser().isAcceptAllFileFilterUsed());
        instance.setAcceptAllFileFilterUsed(false);
        assertFalse(instance.createFileChooser().isAcceptAllFileFilterUsed());
    }

    private static final class FF extends FileFilter {
        private String x;
        FF(String x) {
            this.x = x;
        }

        @Override
        public boolean accept(File f) {
            return f.getName().endsWith(x);
        }

        @Override
        public String getDescription() {
            return x;
        }

    }

    private static final class SA implements FileChooserBuilder.SelectionApprover {
        private File[] selection;
        @Override
        public boolean approve(File[] selection) {
            this.selection = selection;
            return true;
        }

        void assertApproveInvoked(File selected) {
            assertNotNull ("approve method called", selection);
            assertEquals("One selected file", 1, selection.length);
            assertEquals("It is the one", selected, selection[0]);
        }
    }

    private static AbstractButton findDefaultButton(Container c, String txt) {
        if (c instanceof RootPaneContainer) {
            JRootPane root = ((RootPaneContainer) c).getRootPane();
            if (root == null) {
                return null;
            }
            AbstractButton btn = root.getDefaultButton();
            if (btn == null) {
                //Metal L&F does not set default button for JFileChooser
                Container parent = c;
                while (parent.getParent() != null && !(parent instanceof Dialog)) {
                    parent = parent.getParent();
                }
                if (parent instanceof Dialog) {
                    return findFileChooserAcceptButton ((Dialog) parent, txt);
                }
            } else {
                return btn;
            }
        }
        return null;
    }

    private static AbstractButton findFileChooserAcceptButton(Dialog dlg, String txt) {
        for (Component c : dlg.getComponents()) {
            if (c instanceof Container) {
                AbstractButton result = scanForButton((Container) c, txt);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }

    private static AbstractButton scanForButton(Container container, String txt) {
        assertNotNull (container);
        assertNotNull (txt);
        if (container instanceof AbstractButton) {
            if (txt.equals(((AbstractButton) container).getText())) {
                return ((AbstractButton) container);
            }
        } else {
            for (Component c : container.getComponents()) {
                if (c instanceof Container) {
                    AbstractButton b = scanForButton ((Container) c, txt);
                    if (b != null) {
                        return b;
                    }
                }
            }
        }
        return null;
    }

    @RandomlyFails // NB-Core-Build #8038: Button is visible
    public void testForceUseOfDefaultWorkingDirectory() throws InterruptedException, IOException, InvocationTargetException, UnsupportedLookAndFeelException {
        UIManager.setLookAndFeel(new MetalLookAndFeel());
        FileChooserBuilder instance = new FileChooserBuilder("i").setApproveText("__OK");
        instance.setDirectoriesOnly(true);
        final File toDir = getWorkDir();
        final File selDir = new File(toDir, "sel" + System.currentTimeMillis());
        if (!selDir.exists()) {
            assertTrue(selDir.mkdirs());
        }

        final JFileChooser ch = instance.createFileChooser();
        assertEquals ("__OK", ch.getApproveButtonText());
        final CountDownLatch showLatch = new CountDownLatch(1);
        ch.addAncestorListener (new AncestorListener() {

            @Override
            public void ancestorAdded(AncestorEvent event) {
                if (ch.isShowing()) {
                    ch.removeAncestorListener(this);
                    showLatch.countDown();
                }
            }

            @Override
            public void ancestorRemoved(AncestorEvent event) {

            }

            @Override
            public void ancestorMoved(AncestorEvent event) {

            }

        });

        final AtomicReference<Object> chooserRes = new AtomicReference<Object>();
        RequestProcessor.Task task = RequestProcessor.getDefault().post(new Runnable() {

            @Override
            public void run() {
                Object r = ch.showOpenDialog(null);
                chooserRes.set(r);
            }

        });


        showLatch.await();
        EventQueue.invokeAndWait (new Runnable() {
            @Override
            public void run() {
                ch.setCurrentDirectory(toDir);
            }
        });
        EventQueue.invokeAndWait (new Runnable() {
            @Override
            public void run() {
                ch.setSelectedFile (selDir);
            }
        });
        assertTrue ("Button is visible: " + ch, ch.isShowing());
        final AtomicReference<AbstractButton> btn = new AtomicReference<AbstractButton>();
        EventQueue.invokeAndWait(new Runnable() {

            @Override
            public void run() {
                AbstractButton defButton = findDefaultButton(ch.getTopLevelAncestor(), ch.getApproveButtonText());
                btn.set(defButton);
            }

        });
        assertNotNull("have a button", btn.get());
        assertTrue(btn.get().isEnabled());
        EventQueue.invokeAndWait(new Runnable() {
            @Override
            public void run() {
                AbstractButton defButton = btn.get();
                defButton.doClick();
            }
        });

        task.waitFinished();
        assertEquals(JFileChooser.APPROVE_OPTION, chooserRes.get());

        assertEquals(toDir, ch.getCurrentDirectory());

        instance = new FileChooserBuilder("i");
        assertEquals("Directory not retained", toDir, instance.createFileChooser().getCurrentDirectory());

        File userHome = new File(System.getProperty("user.home"));
        assertTrue("Environment not sane", userHome.exists() && userHome.isDirectory());
        instance.forceUseOfDefaultWorkingDirectory(true).setDefaultWorkingDirectory(userHome);

        assertEquals(userHome, instance.createFileChooser().getCurrentDirectory());
    }
}

Lines 1101-1108 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/FileObjectTestHid.java (-2 / +2 lines)
1101		1101
1102	public void testGetPath3() throws IOException{	1102	public void testGetPath3() throws IOException{
1103	/** There is no possible to create filenames ending in dots on Win platforms*/	1103	/** There is no possible to create filenames ending in dots on Win platforms*/
1104	if ((org.openide.util.Utilities.isWindows () \|\|	1104	if ((org.openide.util.BaseUtilities.isWindows () \|\|
1105	(org.openide.util.Utilities.getOperatingSystem () == org.openide.util.Utilities.OS_OS2))) {	1105	(org.openide.util.BaseUtilities.getOperatingSystem () == BaseUtilities.OS_OS2))) {
1106	return;	1106	return;
1107	}	1107	}
1108	checkSetUp();	1108	checkSetUp();




import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.RequestProcessor;
import org.openide.util.BaseUtilities;
import org.openide.util.test.MockLookup;

/**

    }

    public void testLowerAndCapitalNormalization() throws IOException {
        if (!BaseUtilities.isWindows()) {
            return;
        }
        clearWorkDir();

    }

    public void testToFileObjectSlash() throws Exception { // #98388
        if (!BaseUtilities.isUnix()) {
            return;
        }
        File root = new File("/");

    }
    private void assertCorrectURL(String filename, String expectedURLPrefix, String expectedURLSuffix) throws Exception {
        File d = getWorkDir();
        assertEquals(expectedURLSuffix == null ? null : new URL(expectedURLPrefix + BaseUtilities.toURI(d) + expectedURLSuffix),
                FileUtil.urlForArchiveOrDir(new File(d, filename)));
    }
    private void assertCorrectFile(String expectedFilename, String urlPrefix, String urlSuffix) throws Exception {
        assertEquals(expectedFilename == null ? null : new File(getWorkDir(), expectedFilename),
                FileUtil.archiveOrDirForURL(new URL(urlPrefix + BaseUtilities.toURI(getWorkDir()) + urlSuffix)));
    }

    /** Tests translation from jar resource url to jar archive url. */

        };
        log.addHandler(handler);
        try {
            final boolean result = FileUtil.isArchiveFile(BaseUtilities.toURI(testFile).toURL());
            assertTrue("The test.jar should be archive.",result);   //NOI18N
        } finally {
            log.removeHandler(handler);

    }
    
    public void testNormalizeNonExistingButNotAccessibleRootOnWindows() throws IOException {
        if (!BaseUtilities.isWindows()) {
            return;
        }
        for (File r : File.listRoots()) {

    private Map<String, String> createNormalizedPaths() throws IOException {
        // pairs of path before and after normalization
        Map<String, String> paths = new HashMap<String, String>();
        if (BaseUtilities.isWindows()) {
            paths.put("A:\\", "A:\\");
            paths.put("A:\\dummy", "A:\\dummy");
            paths.put("a:\\", "A:\\");

    }
    
    public void testNormalizePathChangeCase() throws Exception {
        if (!BaseUtilities.isWindows()) {
            return;
        }
        clearWorkDir();




import java.net.URL;
import java.util.List;
import java.util.ArrayList;
import org.openide.util.BaseUtilities;

public class FileUtilTestHidden extends TestBaseHid {


        file2 = FileUtil.normalizeFile(file);
        assertEquals(file2, file);

        if (BaseUtilities.isUnix()) {
            assertEquals(new File("/"), FileUtil.normalizeFile(new File("/..")));
            assertEquals(new File("/"), FileUtil.normalizeFile(new File("/../.")));
            assertEquals(new File("/tmp"), FileUtil.normalizeFile(new File("/../../tmp")));

    }

    public void testNormalizeFile2() throws Exception {
        if (!BaseUtilities.isWindows()) {
            return;
        }
        File rootFile = FileUtil.toFile(root);

    }

    public void testIsArchiveFile() throws Exception {
        final String base = BaseUtilities.toURI(getWorkDir()).toURL().toExternalForm();
        URL url = new URL(base + "test.jar");    //NOI18N
        assertTrue("test.jar has to be an archive", FileUtil.isArchiveFile(url));  //NOI18N
        url = new URL(base + ".hidden.jar");   //NOI18N

Lines 44-50 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/MIMESupport68318Test.java (-2 / +1 lines)
44	package org.openide.filesystems;	44	package org.openide.filesystems;
45	import java.io.IOException;	45	import java.io.IOException;
46	import org.netbeans.junit.NbTestCase;	46	import org.netbeans.junit.NbTestCase;
47	import org.openide.ErrorManager;
48	import org.openide.util.Lookup;	47	import org.openide.util.Lookup;
49	import org.openide.util.lookup.InstanceContent;	48	import org.openide.util.lookup.InstanceContent;
50		49
Lines 62-68 Link Here
62	}	61	}
63		62
64	protected void setUp() throws Exception {	63	protected void setUp() throws Exception {
65	ErrorManager.getDefault().log("Just initialize the ErrorManager");	64	// ErrorManager.getDefault().log("Just initialize the ErrorManager");
66	}	65	}
67		66
68	public void testQueryMIMEFromInsideTheLookup() throws IOException {	67	public void testQueryMIMEFromInsideTheLookup() throws IOException {

Lines 49-55 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/MultiFileObjectTestHid.java (-2 / +2 lines)
49	import java.util.ArrayList;	49	import java.util.ArrayList;
50	import java.util.Arrays;	50	import java.util.Arrays;
51	import java.util.List;	51	import java.util.List;
52	import org.openide.util.Utilities;	52	import org.openide.util.BaseUtilities;
53		53
54	public class MultiFileObjectTestHid extends TestBaseHid {	54	public class MultiFileObjectTestHid extends TestBaseHid {
55	private static String[] resources = new String [] {	55	private static String[] resources = new String [] {
Lines 236-242 Link Here
236	+ " </folder>\n"	236	+ " </folder>\n"
237	+ " </folder>\n"	237	+ " </folder>\n"
238	+ "</filesystem>");	238	+ "</filesystem>");
239	XMLFileSystem xml = new XMLFileSystem(Utilities.toURI(f).toURL());	239	XMLFileSystem xml = new XMLFileSystem(BaseUtilities.toURI(f).toURL());
240	all.add(xml);	240	all.add(xml);
241	mfs.setDelegates(all.toArray(new FileSystem[0]));	241	mfs.setDelegates(all.toArray(new FileSystem[0]));
242		242




import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import org.openide.util.BaseUtilities;

/**
 * @author  rm111737


        XMLFileSystem xfs = new XMLFileSystem  ();
        try {
            xfs.setXmlUrl(BaseUtilities.toURI(xmlFile).toURL());
        } catch (Exception ex) {}
        
        return xfs;

        
        XMLFileSystem xfs = new XMLFileSystem  ();
        try {
            xfs.setXmlUrl(BaseUtilities.toURI(xmlFile).toURL());
        } catch (Exception ex) {}
        
        return xfs;






import org.netbeans.junit.*;
import org.openide.util.Lookup;

import java.net.URL;
import java.io.File;
import org.openide.util.BaseUtilities;

/**
 * Simulates issue 50852.

     */
    protected void setUp() throws Exception {
        File workdir = getWorkDir();
        testURL = BaseUtilities.toURI(workdir).toURL();
        System.setProperty("org.openide.util.Lookup", "org.openide.filesystems.URLMapper50852Test$Lkp");
        MAPPER_INSTANCE = new MyURLMapper ();
        Lkp lkp = (Lkp)org.openide.util.Lookup.getDefault();




import java.io.OutputStream;
import java.net.URL;
import java.util.Arrays;
import java.util.Collections;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.zip.CRC32;
import java.util.zip.ZipEntry;
import org.netbeans.junit.NbTestCase;
import org.openide.util.BaseUtilities;

/**
 * Test functionality of URLMapper.

        lfs.setRootDirectory(getWorkDir());
        Repository.getDefault().addFileSystem(lfs);
        
        URL uPlus = BaseUtilities.toURI(plus).toURL();
        FileObject fo = URLMapper.findFileObject(uPlus);
        assertNotNull("File object found", fo);
        assertEquals("plus+plus", fo.getNameExt());

        FileObject rootFO = jfs.getRoot();
        FileObject textFO = jfs.findResource(textPath);
        assertNotNull("JAR contains a/b.txt", textFO);
        String rootS = "jar:" + BaseUtilities.toURI(jar) + "!/";
        URL rootU = new URL(rootS);
        URL textU = new URL(rootS + textPath);
        assertEquals("correct FO -> URL for root", rootU, URLMapper.findURL(rootFO, URLMapper.EXTERNAL));




import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import org.openide.util.Enumerations;
import org.openide.util.BaseUtilities;

public class XMLFileSystemTestHid extends TestBaseHid {
    /** Factory for all filesystems that want to use TCK in this class.

        
        resources = new String[] {"a/b/c","a/b1/c"};

        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(createXMLLayer()).toURL())) {
            // OK, unsupported
            return;
        }

    @Override
    protected void setUp() throws Exception {
        File f = createXMLLayer();
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        this.testedFS = xfs;
        this.allTestedFS = new FileSystem[] { xfs };
        super.setUp();

        
        
        
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertEquals ("Four bytes there", 4, fo.getSize ());
        registerDefaultListener (fo);
        
        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(f2).toURL())) {
            // OK, unsupported
            return;
        }

        
        
        
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertEquals ("Four bytes there", 4, fo.getSize ());
        registerDefaultListener (fo);
        
        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(f2).toURL())) {
            // OK, unsupported
            return;
        }

        
        
        
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertEquals("Old value is in the attribute", "old", fo.getAttribute("value"));
        registerDefaultListener (fo);
        
        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(f2).toURL())) {
            // OK, unsupported
            return;
        }

        
        
        
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        
        FileObject fo = xfs.findResource("TestModule/sample.txt");
        assertEquals("Four bytes there", 4, fo.getSize());
        registerDefaultListener(fo);
        
        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(f2).toURL())) {
            // OK, unsupported
            return;
        }

                f.lastModified() < f2.lastModified()
            );
        }
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertNotNull(fo);
        assertEquals(fo.lastModified().getTime(), f.lastModified());        

                "</filesystem>\n"
                );

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertNotNull(fo);
        

                + "    </folder>\n"
                + "</filesystem>");

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        final LocalFileSystem lfs = new LocalFileSystem();
        lfs.setRootDirectory(getWorkDir());
        MultiFileSystem mfs = new MultiFileSystem(lfs, xfs);

                );
        Count.cnt = 0;

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        /** the following is a fake implementation of filesystem that
         * allows us to prevent calls to fileObject.getAttributes()
         */

                "</filesystem>\n"
                );

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertNotNull(fo);


                "</filesystem>\n"
                );

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertNotNull(fo);


            "</filesystem>\n"
        );

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertNotNull(fo);


            "</filesystem>\n"
        );

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertNotNull(fo);

        XMLFileSystem realXMLFS = new XMLFileSystem(BaseUtilities.toURI(f).toURL());
        FileObject realfo = realXMLFS.findResource("TestModule/sample.txt");
        assertNotNull(realfo);


            "</filesystem>\n"
        );

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        FileObject snd = xfs.findResource ("TestModule/snd.txt");
        assertNotNull(fo);

                "</filesystem>\n"
                );

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertNotNull(fo);


            )
        );

        URL url1 = new URL("jar:" + BaseUtilities.toURI(jar1) + "!/layer.xml");
        URL url2 = new URL("jar:" + BaseUtilities.toURI(jar2) + "!/layer.xml");

        FileSystem xfs1 = FileSystemFactoryHid.createXMLSystem(getName(), this, url1);
        FileObject fo1 = xfs1.findResource("dir/file");

        File f2 = changeOfAnAttributeInLayerIsFiredgenerateLayer("Folder", "java.awt.Button");
        File f3 = changeOfAnAttributeInLayerIsFiredgenerateLayer("NoChange", "nochange");

        fs.setXmlUrls (new URL[] { BaseUtilities.toURI(f1).toURL(), BaseUtilities.toURI(f3).toURL() } );
        
        FileObject file = fs.findResource("Folder/empty.xml");
        assertNotNull("File found in layer", file);

        assertAttr("The first value is list", file, "value", "java.awt.List");
        assertAttr("Imutable value is nochange", nochange, "value", "nochange");
        
        fs.setXmlUrls (new URL[] { BaseUtilities.toURI(f2).toURL(), BaseUtilities.toURI(f3).toURL() } );
        String v2 = (String) file.getAttribute("value");
        assertEquals("The second value is button", "java.awt.Button", v2);
        

        LocalFileSystem target = new LocalFileSystem();
        target.setRootDirectory(r);

        FileSystem source = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
        FileObject template = source.findResource("Templates/Other/special");
        assertNotNull("template found", template);
        FileObject foTested = target.getRoot().createData("copiedTemplate");

            w.close();
        }

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f1).toURL(), BaseUtilities.toURI(f2).toURL());


        FileObject just1 = xfs.findResource("just1/empty.xml");

        String layers2 = layers(just2);
        String layersB = layers(both);

        if (!layersR.contains(BaseUtilities.toURI(f1).toString())) {
            fail("Missing " + BaseUtilities.toURI(f1).toString() + "\ninside: " + layersR);
        }
        if (!layersR.contains(BaseUtilities.toURI(f2).toString())) {
            fail("Missing " + BaseUtilities.toURI(f2).toString() + "\ninside: " + layersR);
        }

        assertEquals(BaseUtilities.toURI(f1).toString(), layers1);
        assertEquals(BaseUtilities.toURI(f2).toString(), layers2);
        if (!layersB.contains(BaseUtilities.toURI(f1).toString())) {
            fail("Missing " + f1 + "\ninside: " + layersB);
        }
        if (!layersB.contains(BaseUtilities.toURI(f2).toString())) {
            fail("Missing " + f2 + "\ninside: " + layersB);
        }
    }

            + "</filesystem>");
        w.close();

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(layer).toURL());

        FileObject fo = xfs.findResource("f/empty.xml");
        assertNotNull("File found", fo);

        File f1 = writeFile("layer1.xml",
                "<filesystem>\n" +
                "<folder name='d'>\n" +
                "<file name='f' url='" + BaseUtilities.toURI(c1) + "'/>" +
                "</folder>\n" +
                "</filesystem>\n"
                );
        File f2 = writeFile("layer2.xml",
                "<filesystem>\n" +
                "<folder name='d'>\n" +
                "<file name='f' url='" + BaseUtilities.toURI(c2) + "'>" +
                "  <attr name='weight' intvalue='100'/>" +
                "</file>\n" +
                "</folder>\n" +
                "</filesystem>\n"
                );

        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f2).toURL(), BaseUtilities.toURI(f1).toURL());
        FileObject fo = xfs.findResource("d/f");
        assertNotNull(fo);
        assertEquals(6, fo.getSize());
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f1).toURL(), BaseUtilities.toURI(f2).toURL());
        fo = xfs.findResource("d/f");
        assertNotNull(fo);
        assertEquals(6, fo.getSize());




import org.netbeans.junit.NbTestCase;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.XMLFileSystem;
import org.openide.util.BaseUtilities;
import org.openide.util.lookup.ServiceProvider;
import org.openide.util.test.AnnotationProcessorTestUtils;
import org.openide.util.test.TestFileUtils;

        File j = TestFileUtils.writeZipFile(new File(getWorkDir(), "cp.jar"), "other/x1:x1");
        TestFileUtils.writeFile(new File(src, "p/resources/x2"), "x2");
        ByteArrayOutputStream err = new ByteArrayOutputStream();
        boolean status = AnnotationProcessorTestUtils.runJavac(src, null, dest, new File[] {j, BaseUtilities.toFile(LayerBuilderTest.class.getProtectionDomain().getCodeSource().getLocation().toURI())}, err);
        String msgs = err.toString();
        assertTrue(msgs, status);
        assertTrue(msgs, msgs.contains("r1=x1") ^ AnnotationProcessorTestUtils.searchClasspathBroken());
        assertTrue(msgs, msgs.contains("r2=x2"));
        FileObject f = new XMLFileSystem(BaseUtilities.toURI(new File(dest, "META-INF/generated-layer.xml")).toURL()).findResource("f");
        assertNotNull(f);
        assertEquals("other/x1", f.getAttribute("r1"));
        assertEquals("p/resources/x2", f.getAttribute("r2"));

        File j = TestFileUtils.writeZipFile(new File(getWorkDir(), "cp.jar"), "other/x1:x1");
        TestFileUtils.writeFile(new File(src, "p/resources/x2"), "x2");
        ByteArrayOutputStream err = new ByteArrayOutputStream();
        boolean status = AnnotationProcessorTestUtils.runJavac(src, null, dest, new File[] {j, BaseUtilities.toFile(LayerBuilderTest.class.getProtectionDomain().getCodeSource().getLocation().toURI())}, err);
        String msgs = err.toString();
        assertFalse(msgs, status);
        assertTrue(msgs, msgs.contains("resourcez"));
        assertTrue(msgs, msgs.contains("r1=x1") ^ AnnotationProcessorTestUtils.searchClasspathBroken());
        AnnotationProcessorTestUtils.makeSource(src, "p.C", "@" + V.class.getCanonicalName() + "(r1=\"othr/x1\", r2=\"resources/x2\") public class C {}");
        err = new ByteArrayOutputStream();
        status = AnnotationProcessorTestUtils.runJavac(src, null, dest, new File[] {j, BaseUtilities.toFile(LayerBuilderTest.class.getProtectionDomain().getCodeSource().getLocation().toURI())}, err);
        msgs = err.toString();
        assertFalse(msgs, status ^ AnnotationProcessorTestUtils.searchClasspathBroken());
        assertTrue(msgs, msgs.contains("othr") ^ AnnotationProcessorTestUtils.searchClasspathBroken());




/*
 * 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 2009 Sun Microsystems, Inc.
 */

package org.netbeans.modules.openide.util;

import java.net.URLStreamHandler;
import java.net.URLStreamHandlerFactory;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.URLStreamHandlerRegistration;
import org.openide.util.lookup.Lookups;
import org.openide.util.lookup.ServiceProvider;

/**
 * @see URLStreamHandlerRegistration
 */
@ServiceProvider(service=URLStreamHandlerFactory.class)
public final class ProxyURLStreamHandlerFactory implements URLStreamHandlerFactory {
    /** prevents GC only */
    private final Map<String, Lookup.Result<URLStreamHandler>> results = new HashMap<String, Lookup.Result<URLStreamHandler>>();
    private final Map<String, URLStreamHandler> handlers = new HashMap<String, URLStreamHandler>();
    private static final Set<String> STANDARD_PROTOCOLS = new HashSet<String>(Arrays.asList("jar", "file", "http", "https", "resource")); // NOI18N

    public @Override synchronized URLStreamHandler createURLStreamHandler(final String protocol) {
        if (STANDARD_PROTOCOLS.contains(protocol)) {
            // Well-known handlers in JRE. Do not try to initialize lookup.
            return null;
        }
        if (!results.containsKey(protocol)) {
            final Lookup.Result<URLStreamHandler> result = Lookups.forPath("URLStreamHandler/" + protocol).lookupResult(URLStreamHandler.class);
            LookupListener listener = new LookupListener() {
                public @Override void resultChanged(LookupEvent ev) {
                    synchronized (ProxyURLStreamHandlerFactory.this) {
                        Collection<? extends URLStreamHandler> instances = result.allInstances();
                        handlers.put(protocol, instances.isEmpty() ? null : instances.iterator().next());
                    }
                }
            };
            result.addLookupListener(listener);
            listener.resultChanged(null);
            results.put(protocol, result);
        }
        return handlers.get(protocol);
    }
}




/*
 * 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 2009 Sun Microsystems, Inc.
 */

package org.openide.util;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.net.URL;
import java.net.URLStreamHandler;
import java.net.URLStreamHandlerFactory;
import org.openide.util.lookup.NamedServiceDefinition;

/**
 * Replacement for {@link URLStreamHandlerFactory} within the NetBeans platform.
 * (The JVM only permits one global factory to be set at a time,
 * whereas various independent modules may wish to register handlers.)
 * May be placed on a {@link URLStreamHandler} implementation to register it.
 * Your handler will be loaded and used if and when a URL of a matching protocol is created.
 * <p>A {@link URLStreamHandlerFactory} which uses these registrations may be found in {@link Lookup#getDefault}.
 * This factory is active whenever the module system is loaded.
 * You may also wish to call {@link URL#setURLStreamHandlerFactory}
 * from a unit test or otherwise without the module system active.
 * @since org.openide.util 7.31
 */
@NamedServiceDefinition(path="URLStreamHandler/@protocol()", serviceType=URLStreamHandler.class)
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface URLStreamHandlerRegistration {

    /**
     * URL protocol(s) which are handled.
     * {@link URLStreamHandler#openConnection} will be called with a matching {@link URL#getProtocol}.
     */
    String[] protocol();

    /**
     * An optional position in which to register this handler relative to others.
     * The lowest-numbered handler is used in favor of any others, including unnumbered handlers.
     */
    int position() default Integer.MAX_VALUE;

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 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 2011 Sun Microsystems, Inc.
 */

package org.openide.util.test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.netbeans.junit.NbTestCase;

// XXX could add methods to add a JAR manifest, include text or binary resources, ...

/**
 * Builder for compiling some source files and packing the result into a JAR.
 */
public final class JarBuilder {

    private final File src, dest, jar;
    private List<File> classpath;

    /**
     * @param workdir as in {@link NbTestCase#getWorkDir}
     */
    public JarBuilder(File workdir) throws Exception {
        jar = File.createTempFile("test", ".jar", workdir);
        String n = jar.getName().replaceAll("^test|[.]jar$", "");
        src = new File(workdir, "src" + n);
        dest = new File(workdir, "classes" + n);
    }

    /**
     * Optional classpath for compiling sources.
     * If unspecified, use Java classpath of test.)
     */
    public JarBuilder classpath(File... cp) {
        if (classpath == null) {
            classpath = new ArrayList<File>();
        }
        classpath.addAll(Arrays.asList(cp));
        return this;
    }

    /**
     * Adds a source file to compile.
     * @see AnnotationProcessorTestUtils#makeSource
     */
    public JarBuilder source(String clazz, String... content) throws Exception {
        AnnotationProcessorTestUtils.makeSource(src, clazz, content);
        return this;
    }

    /**
     * Compiles sources and creates resulting JAR.
     * @return the created JAR file
     */
    public File build() throws Exception {
        if (!AnnotationProcessorTestUtils.runJavac(src, null, dest, classpath != null ? classpath.toArray(new File[0]) : null, null)) {
            throw new Exception("compilation failed");
        }
        Map<String,byte[]> data = new TreeMap<String,byte[]>();
        scan(data, dest, "");
        OutputStream os = new FileOutputStream(jar);
        try {
            TestFileUtils.writeZipFile(os, data);
        } finally {
            os.close();
        }
        return jar;
    }

    private static void scan(Map<String,byte[]> data, File d, String prefix) throws Exception {
        for (File kid : d.listFiles()) {
            String prefixName = prefix + kid.getName();
            if (kid.isDirectory()) {
                scan(data, kid, prefixName + '/');
            } else {
                data.put(prefixName, TestFileUtils.readFileBin(kid));
            }
        }
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * 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.openide.util.test;

import junit.framework.AssertionFailedError;
import org.netbeans.junit.NbTestCase;
import org.netbeans.junit.RandomlyFails;
import org.openide.util.ChangeSupport;

public class MockChangeListenerTest extends NbTestCase {

    public MockChangeListenerTest(String n) {
        super(n);
    }

    Object source;
    ChangeSupport cs;
    MockChangeListener l;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        source = new Object();
        cs = new ChangeSupport(source);
        l = new MockChangeListener();
        cs.addChangeListener(l);
    }

    public void testBasicUsage() throws Exception {
        l.assertNoEvents();
        l.assertEventCount(0);
        try {
            l.assertEvent();
            assert false;
        } catch (AssertionFailedError e) {}
        try {
            l.assertEventCount(1);
            assert false;
        } catch (AssertionFailedError e) {}
        cs.fireChange();
        l.assertEvent();
        l.assertNoEvents();
        l.assertEventCount(0);
        cs.fireChange();
        cs.fireChange();
        l.assertEventCount(2);
        cs.fireChange();
        l.assertEvent();
        l.assertNoEvents();
        l.assertNoEvents();
        cs.fireChange();
        l.reset();
        l.assertNoEvents();
        cs.fireChange();
        cs.fireChange();
        assertEquals(2, l.allEvents().size());
    }

    public void testMessages() throws Exception {
        try {
            l.assertEvent();
            assert false;
        } catch (AssertionFailedError e) {}
        try {
            l.msg("stuff").assertEvent();
            assert false;
        } catch (AssertionFailedError e) {
            assertTrue(e.getMessage().contains("stuff"));
        }
        try {
            l.assertEvent();
            assert false;
        } catch (AssertionFailedError e) {
            assertFalse(String.valueOf(e.getMessage()).contains("stuff"));
        }
    }

    @RandomlyFails // NB-Core-Build #8154
    public void testExpect() throws Exception {
        l.expectNoEvents(1000);
        cs.fireChange();
        l.expectEvent(1000);
        l.assertNoEvents();
        new Thread() {
            @Override public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException x) {
                    assert false;
                }
                cs.fireChange();
            }
        }.start();
        try {
            l.expectEvent(1000);
            assert false;
        } catch (AssertionFailedError e) {}
        l.expectEvent(2000);
        l.assertNoEvents();
        l.expectNoEvents(1000);
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * 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.openide.util.test;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import static junit.framework.Assert.*;
import junit.framework.AssertionFailedError;

/**
 * A scriptable property change listener.
 */
public class MockPropertyChangeListener implements PropertyChangeListener {

    private final List<PropertyChangeEvent> events = new ArrayList<PropertyChangeEvent>();
    private final Set<String> whitelist;
    private final Set<String> blacklist = new HashSet<String>();
    private final Set<String> ignored = new HashSet<String>();
    private String msg;

    /**
     * Makes a fresh listener.
     * @param whiteListedPropertyNames an optional list of property names; if any others are received, an assertion will be thrown
     */
    public MockPropertyChangeListener(String... whitelistedPropertyNames) {
        whitelist = whitelistedPropertyNames.length > 0 ? new HashSet<String>(Arrays.asList(whitelistedPropertyNames)) : null;
    }

    /**
     * Marks certain property names as being definitely not expected.
     * If any are received henceforth, an assertion will be thrown.
     */
    public synchronized void blacklist(String... blacklistedPropertyNames) {
        assertNull("Meaningless to blacklist some properties while there is an active whitelist", whitelist);
        blacklist.addAll(Arrays.asList(blacklistedPropertyNames));
    }

    /**
     * Marks certain property names as being ignored.
     * If any are received henceforth, no action will be taken.
     */
    public synchronized void ignore(String... ignoredPropertyNames) {
        ignored.addAll(Arrays.asList(ignoredPropertyNames));
    }

    public synchronized void propertyChange(PropertyChangeEvent ev) {
        String propname = ev.getPropertyName();
        if (ignored.contains(propname)) {
            return;
        }
        assertTrue("Property name " + propname + " not expected", whitelist == null || whitelist.contains(propname));
        assertFalse("Property name " + propname + " not expected", blacklist.contains(propname));
        if (propname == null) {
            assertNull("null prop name -> null old value", ev.getOldValue());
            assertNull("null prop name -> null new value", ev.getNewValue());
        }
        events.add(ev);
        notifyAll();
    }

    /**
     * Specifies a failure message to use for the next assertion.
     * @return this object, for convenient chaining
     */
    public MockPropertyChangeListener msg(String msg) {
        this.msg = msg;
        return this;
    }

    private String compose(String msg) {
        return this.msg == null ? msg : msg + ": " + this.msg;
    }

    /**
     * Asserts that the set of property change event names fired matches an expected list.
     * (Order and multiplicity of events is not considered.)
     * After this call, the list of received events is reset, so each call checks events since the last call.
     */
    public synchronized void assertEvents(String... expectedPropertyNames) throws AssertionFailedError {
        try {
            Set<String> actualEvents = new TreeSet<String>();
            for (PropertyChangeEvent ev : events) {
                actualEvents.add(ev.getPropertyName());
            }
            assertEquals(msg, new TreeSet<String>(Arrays.asList(expectedPropertyNames)).toString(), actualEvents.toString());
        } finally {
            reset();
        }
    }

    /**
     * Asserts that a certain number of events have been received.
     * (Property name is not considered.)
     * After this call, the list of received events is reset, so each call checks events since the last call.
     */
    public synchronized void assertEventCount(int expectedCount) throws AssertionFailedError {
        try {
            assertEquals(msg, expectedCount, events.size());
        } finally {
            reset();
        }
    }

    /**
     * Asserts that some events were received with particular old and new values.
     * After this call, the list of received events is reset, so each call checks events since the last call.
     * @param expectedOldValues mapping from expected property names to old values (may be left null to skip this check)
     * @param expectedNewValues mapping from expected property names to new values
     */
    public synchronized void assertEventsAndValues(Map<String,?> expectedOldValues, Map<String,?> expectedNewValues) throws AssertionFailedError {
        try {
            if (expectedOldValues != null) {
                Map<String,Object> actualOldValues = new HashMap<String,Object>();
                for (PropertyChangeEvent ev : events) {
                    actualOldValues.put(ev.getPropertyName(), ev.getOldValue());
                }
                assertEquals(msg, expectedOldValues, actualOldValues);
            }
            Map<String,Object> actualNewValues = new HashMap<String,Object>();
            for (PropertyChangeEvent ev : events) {
                actualNewValues.put(ev.getPropertyName(), ev.getNewValue());
            }
            assertEquals(msg, expectedNewValues, actualNewValues);
        } finally {
            reset();
        }
    }

    /**
     * Expects a single event to be fired.
     * After this call, the list of received events is reset, so each call checks events since the last call.
     * @param propertyName optional property name which is expected (or null for any)
     * @param timeout a timeout in milliseconds (zero means no timeout)
     */
    public synchronized void expectEvent(String expectedPropertyName, long timeout) throws AssertionFailedError {
        try {
            if (events.isEmpty()) {
                try {
                    wait(timeout);
                } catch (InterruptedException x) {
                    fail(compose("Timed out waiting for event"));
                }
            }
            assertFalse(compose("Did not get event"), events.isEmpty());
            assertFalse(compose("Got too many events"), events.size() > 1);
            PropertyChangeEvent received = events.iterator().next();
            if (expectedPropertyName != null) {
                assertEquals(msg, expectedPropertyName, received.getPropertyName());
            }
        } finally {
            reset();
        }
    }

    /**
     * Gets a list of all received events, for special processing.
     * (For example, checking of source, ...)
     * After this call, the list of received events is reset, so each call checks events since the last call.
     */
    public synchronized List<PropertyChangeEvent> allEvents() {
        try {
            return new ArrayList<PropertyChangeEvent>(events);
        } finally {
            reset();
        }
    }

    /**
     * Simply resets the list of events without checking anything.
     * Also resets any failure message.
     */
    public synchronized void reset() {
        msg = null;
        events.clear();
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * 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.openide.util.test;

import java.beans.PropertyChangeSupport;
import java.util.Collections;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

public class MockPropertyChangeListenerTest extends TestCase {

    public MockPropertyChangeListenerTest(String n) {
        super(n);
    }

    Object source;
    PropertyChangeSupport pcs;
    MockPropertyChangeListener l;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        source = new Object();
        pcs = new PropertyChangeSupport(source);
        l = new MockPropertyChangeListener();
        pcs.addPropertyChangeListener(l);
    }

    // XXX test expect

    public void testBasicUsage() throws Exception {
        l.assertEvents();
        try {
            l.assertEvents("whatever");
            assert false;
        } catch (AssertionFailedError e) {}
        pcs.firePropertyChange("foo", null, null);
        l.assertEvents("foo");
        try {
            l.assertEvents("foo");
            assert false;
        } catch (AssertionFailedError e) {}
        l.assertEventCount(0);
        pcs.firePropertyChange("bar", null, null);
        pcs.firePropertyChange("baz", null, null);
        l.assertEventCount(2);
        try {
            l.assertEventCount(2);
            assert false;
        } catch (AssertionFailedError e) {}
        assertEquals(0, l.allEvents().size());
        pcs.firePropertyChange("bar", null, null);
        pcs.firePropertyChange("baz", null, null);
        assertEquals(2, l.allEvents().size());
        assertEquals(0, l.allEvents().size());
        pcs.firePropertyChange("foo", "old", "new");
        l.assertEventsAndValues(null, Collections.singletonMap("foo", "new"));
        pcs.firePropertyChange("foo", "old2", "new2");
        l.assertEventsAndValues(Collections.singletonMap("foo", "old2"), Collections.singletonMap("foo", "new2"));
        try {
            l.assertEventsAndValues(null, Collections.singletonMap("foo", "new2"));
            assert false;
        } catch (AssertionFailedError e) {}
        pcs.firePropertyChange("foo", null, null);
        l.reset();
        l.assertEvents();
        pcs.firePropertyChange("x", null, null);
        try {
            l.assertEvents();
            assert false;
        } catch (AssertionFailedError e) {}
        l.assertEvents();
    }

    public void testMessages() throws Exception {
        pcs.firePropertyChange("foo", null, null);
        try {
            l.assertEvents();
            assert false;
        } catch (AssertionFailedError e) {}
        pcs.firePropertyChange("foo", null, null);
        try {
            l.msg("stuff").assertEvents();
            assert false;
        } catch (AssertionFailedError e) {
            assertTrue(e.getMessage().contains("stuff"));
        }
        pcs.firePropertyChange("foo", null, null);
        try {
            l.assertEvents();
            assert false;
        } catch (AssertionFailedError e) {
            assertFalse(e.getMessage().contains("stuff"));
        }
    }

    public void testPropertyNameFiltering() throws Exception {
        l.ignore("irrelevant");
        l.blacklist("bad", "worse");
        pcs.firePropertyChange("relevant", null, null);
        l.assertEvents("relevant");
        pcs.firePropertyChange("irrelevant", null, null);
        l.assertEvents();
        try {
            pcs.firePropertyChange("bad", null, null);
            assert false;
        } catch (AssertionFailedError e) {}
        try {
            pcs.firePropertyChange("worse", null, null);
            assert false;
        } catch (AssertionFailedError e) {}
        pcs.removePropertyChangeListener(l);
        l = new MockPropertyChangeListener("expected1", "expected2");
        pcs.addPropertyChangeListener(l);
        l.ignore("irrelevant");
        pcs.firePropertyChange("expected1", null, null);
        pcs.firePropertyChange("expected2", null, null);
        l.assertEvents("expected1", "expected2");
        pcs.firePropertyChange("irrelevant", null, null);
        l.assertEvents();
        try {
            pcs.firePropertyChange("other", null, null);
            assert false;
        } catch (AssertionFailedError e) {}
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2007 Sun Microsystems, Inc.
 */

package org.openide.util.test;

import java.security.Permission;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

/**
 * Permits unit tests to limit creation of threads.
 * Unexpected thread creation can make tests fail randomly, which makes debugging difficult.
 * <p>Start off calling {@link #permitStandard} and {@link #forbidNewThreads}.
 * To determine which methods to permit, just try running the test;
 * if you see any {@link SecurityException}s which look like harmless thread creation
 * activities, just copy the appropriate part of the stack trace and pass to {@link #permit}.
 * <p>Use non-strict mode for {@link #forbidNewThreads} if you suspect some code
 * might be catching and not reporting {@link SecurityException}s; or you may prefer
 * to simply use non-strict mode while developing the test and then switch to strict
 * mode once it begins passing.
 * <p>Place calls to this class early in your test's initialization, e.g. in a static block.
 * (Not suitable for use from {@link junit.framework.TestCase#setUp}.)
 */
public class RestrictThreadCreation {

    private RestrictThreadCreation() {}

    private static Set<String> currentlyPermitted = new HashSet<String>();

    /**
     * Explicitly permits one or more thread creation idioms.
     * Each entry is of the form <samp>fully.qualified.Clazz.methodName</samp>
     * and if such a method can be found on the call stack the thread creation
     * is permitted.
     * @param permitted one or more fully qualified method names to accept
     */
    public static void permit(String... permitted) {
        currentlyPermitted.addAll(Arrays.asList(permitted));
    }

    /**
     * Permits a standard set of thread creation idioms which are normally harmless to unit tests.
     * Feel free to add to this list if it seems appropriate.
     */
    public static void permitStandard() {
        permit(// Found experimentally:
                "org.netbeans.junit.NbTestCase.runBare",
                "sun.java2d.Disposer.<clinit>",
                "java.awt.Toolkit.getDefaultToolkit",
                "java.util.logging.LogManager$Cleaner.<init>",
                "org.netbeans.ModuleManager$1.<init>",
                "org.netbeans.Stamps$Worker.<init>",
                "org.netbeans.core.startup.Splash$SplashComponent.setText",
                "org.netbeans.core.startup.preferences.NbPreferences.asyncInvocationOfFlushSpi",
                "org.openide.loaders.FolderInstance.waitFinished",
                "org.openide.loaders.FolderInstance.postCreationTask",
                "org.netbeans.modules.masterfs.filebasedfs.fileobjects.LockForFile.<clinit>",
                "org.netbeans.api.java.source.JavaSource.<clinit>",
                "org.netbeans.api.java.source.JavaSourceTaskFactory.fileObjectsChanged",
                "org.netbeans.modules.progress.spi.Controller.resetTimer",
                "org.netbeans.modules.project.ui.problems.BrokenProjectAnnotator.annotateIcon",
                "org.netbeans.modules.timers.InstanceWatcher$FinalizingToken.finalize",
                "org.openide.util.NbBundle.getBundleFast",
                "org.openide.util.RequestProcessor$TickTac.run",
                "org.openide.util.Utilities$ActiveQueue.ping",
                "javax.swing.JComponent.revalidate",
                "javax.swing.ImageIcon.<init>");
    }

    /**
     * Install a security manager which prevents new threads from being created
     * unless they were explicitly permitted.
     * @param strict if true, throw a security exception; if false, just print stack traces
     */
    public static void forbidNewThreads(final boolean strict) {
        System.setSecurityManager(new SecurityManager() {
            public @Override void checkAccess(ThreadGroup g) {
                boolean inThreadInit = false;
                for (StackTraceElement line : Thread.currentThread().getStackTrace()) {
                    String id = line.getClassName() + "." + line.getMethodName();
                    if (currentlyPermitted.contains(id)) {
                        return;
                    } else if (id.equals("java.lang.Thread.init") || id.equals("org.openide.util.RequestProcessor$Processor.checkAccess")) {
                        inThreadInit = true;
                    }
                }
                if (inThreadInit) {
                    SecurityException x = new SecurityException("Unauthorized thread creation");
                    if (strict) {
                        throw x;
                    } else {
                        x.printStackTrace();
                    }
                }
            }
            public @Override void checkPermission(Permission perm) {}
            public @Override void checkPermission(Permission perm, Object context) {}
        });
    }

}




/*
 * 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 2008 Sun Microsystems, Inc.
 */

package org.openide.util.test;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.zip.CRC32;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import junit.framework.Assert;

/**
 * Common utility methods for massaging and inspecting files from tests.
 */
public class TestFileUtils {

    private TestFileUtils() {}

    /**
     * Create a new data file with specified initial contents.
     * @param f a file to create (parents will be created automatically)
     * @param body the complete contents of the new file (in UTF-8 encoding)
     */
    public static File writeFile(File f, String body) throws IOException {
        f.getParentFile().mkdirs();
        OutputStream os = new FileOutputStream(f);
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
        pw.print(body);
        pw.flush();
        os.close();
        return f;
    }

    /**
     * Read the contents of a file as a single string.
     * @param a data file
     * @return its contents (in UTF-8 encoding)
     */
    public static String readFile(File file) throws IOException {
        InputStream is = new FileInputStream(file);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buf = new byte[4096];
        int read;
        while ((read = is.read(buf)) != -1) {
            baos.write(buf, 0, read);
        }
        is.close();
        return baos.toString("UTF-8");
    }

    /**
     * Read the contents of a file as a byte array.
     * @param a data file
     * @return its raw binary contents
     */
    public static byte[] readFileBin(File file) throws IOException {
        InputStream is = new FileInputStream(file);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buf = new byte[4096];
        int read;
        while ((read = is.read(buf)) != -1) {
            baos.write(buf, 0, read);
        }
        is.close();
        return baos.toByteArray();
    }

    /**
     * Create a new ZIP file.
     * @param jar the ZIP file to create
     * @param entries a list of entries in the form of "filename:UTF8-contents"; parent dirs created automatically
     * @return the {@code jar} parameter, for convenience
     * @throws IOException for the usual reasons
     */
    public static File writeZipFile(File jar, String... entries) throws IOException {
        jar.getParentFile().mkdirs();
        writeZipFile(new FileOutputStream(jar), entries);
        return jar;
    }

    /**
     * Create a new ZIP file.
     * @param os a stream to which the ZIP will be written
     * @param entries a list of entries in the form of "filename:UTF8-contents"; parent dirs created automatically
     * @throws IOException for the usual reasons
     */
    public static void writeZipFile(OutputStream os, String... entries) throws IOException {
        Map<String,byte[]> binary = new LinkedHashMap<String,byte[]>();
        for (String entry : entries) {
            int colon = entry.indexOf(':');
            assert colon != -1 : entry;
            binary.put(entry.substring(0, colon), entry.substring(colon + 1).getBytes("UTF-8"));
        }
        writeZipFile(os, binary);
    }

    /**
     * Create a new ZIP file.
     * @param os a stream to which the ZIP will be written
     * @param entries entries as maps from filename to binary contents;; parent dirs created automatically
     * @throws IOException for the usual reasons
     */
    public static void writeZipFile(OutputStream os, Map<String,byte[]> entries) throws IOException {
        ZipOutputStream zos = new ZipOutputStream(os);
        Set<String> parents = new HashSet<String>();
        if (entries.isEmpty()) {
            entries = Collections.singletonMap("PLACEHOLDER", new byte[0]);
        }
        for (Map.Entry<String,byte[]> entry : entries.entrySet()) {
            String name = entry.getKey();
            assert name.length() > 0 && !name.endsWith("/") && !name.startsWith("/") && name.indexOf("//") == -1 : name;
            for (int i = 0; i < name.length(); i++) {
                if (name.charAt(i) == '/') {
                    String parent = name.substring(0, i + 1);
                    if (parents.add(parent)) {
                        ZipEntry ze = new ZipEntry(parent);
                        ze.setMethod(ZipEntry.STORED);
                        ze.setSize(0);
                        ze.setCrc(0);
                        ze.setTime(0);
                        zos.putNextEntry(ze);
                        zos.closeEntry();
                    }
                }
            }
            byte[] data = entry.getValue();
            ZipEntry ze = new ZipEntry(name);
            ze.setMethod(ZipEntry.STORED);
            ze.setSize(data.length);
            CRC32 crc = new CRC32();
            crc.update(data);
            ze.setCrc(crc.getValue());
            ze.setTime(0);
            zos.putNextEntry(ze);
            zos.write(data, 0, data.length);
            zos.closeEntry();
        }
        zos.finish();
        zos.close();
        os.close();
    }

    /**
     * Unpacks a ZIP file to disk.
     * All entries are unpacked, even {@code META-INF/MANIFEST.MF} if present.
     * Parent directories are created as needed (even if not mentioned in the ZIP);
     * empty ZIP directories are created too.
     * Existing files are overwritten.
     * @param zip a ZIP file
     * @param dir the base directory in which to unpack (need not yet exist)
     * @throws IOException in case of problems
     */
    public static void unpackZipFile(File zip, File dir) throws IOException {
        byte[] buf = new byte[8192];
        InputStream is = new FileInputStream(zip);
        try {
            ZipInputStream zis = new ZipInputStream(is);
            ZipEntry entry;
            while ((entry = zis.getNextEntry()) != null) {
                String name = entry.getName();
                int slash = name.lastIndexOf('/');
                File d = new File(dir, name.substring(0, slash).replace('/', File.separatorChar));
                if (!d.isDirectory() && !d.mkdirs()) {
                    throw new IOException("could not make " + d);
                }
                if (slash != name.length() - 1) {
                    File f = new File(dir, name.replace('/', File.separatorChar));
                    OutputStream os = new FileOutputStream(f);
                    try {
                        int read;
                        while ((read = zis.read(buf)) != -1) {
                            os.write(buf, 0, read);
                        }
                    } finally {
                        os.close();
                    }
                }
            }
        } finally {
            is.close();
        }
    }

    /**
     * Make sure the timestamp on a file changes.
     * @param f a file to touch (make newer)
     * @param ref if not null, make f newer than this file; else make f newer than it was before
     */
    @SuppressWarnings("SleepWhileInLoop")
    public static void touch(File f, File ref) throws IOException, InterruptedException {
        long older = f.lastModified();
        if (ref != null) {
            older = Math.max(older, ref.lastModified());
        } else {
            older = Math.max(older, System.currentTimeMillis());
        }
        int maxPause = 9999;
        /* XXX consider this (as yet untested):
        long curr = System.currentTimeMillis();
        if (older > curr + maxPause) {
            throw new IllegalArgumentException("reference too far into the future, by " + (older - curr) + "msec");
        }
         */
        for (long pause = 1; pause < maxPause; pause *= 2) {
            Thread.sleep(pause);
            f.setLastModified(System.currentTimeMillis() + 1);  // plus 1 needed for FileObject tests (initially FO lastModified is set to currentTimeMillis)
            if (f.lastModified() > older) {
                while (f.lastModified() >= System.currentTimeMillis()) {
//                    LOG.log(Level.INFO, "Modification time is in future {0}", System.currentTimeMillis());
                    Thread.sleep(10);
                }
                return;
            }
        }
        Assert.fail("Did not manage to touch " + f);
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-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]"
 *
 * 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.
 */

/**
 * General utility classes useful for writing unit tests in various modules.
 */
package org.openide.util.test;




/*
 * 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 2009 Sun Microsystems, Inc.
 */

package org.netbeans.modules.openide.util;

import java.net.URLStreamHandler;
import java.net.URLStreamHandlerFactory;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.URLStreamHandlerRegistration;
import org.openide.util.lookup.Lookups;
import org.openide.util.lookup.ServiceProvider;

/**
 * @see URLStreamHandlerRegistration
 */
@ServiceProvider(service=URLStreamHandlerFactory.class)
public final class ProxyURLStreamHandlerFactory implements URLStreamHandlerFactory {
    /** prevents GC only */
    private final Map<String, Lookup.Result<URLStreamHandler>> results = new HashMap<String, Lookup.Result<URLStreamHandler>>();
    private final Map<String, URLStreamHandler> handlers = new HashMap<String, URLStreamHandler>();
    private static final Set<String> STANDARD_PROTOCOLS = new HashSet<String>(Arrays.asList("jar", "file", "http", "https", "resource")); // NOI18N

    public @Override synchronized URLStreamHandler createURLStreamHandler(final String protocol) {
        if (STANDARD_PROTOCOLS.contains(protocol)) {
            // Well-known handlers in JRE. Do not try to initialize lookup.
            return null;
        }
        if (!results.containsKey(protocol)) {
            final Lookup.Result<URLStreamHandler> result = Lookups.forPath("URLStreamHandler/" + protocol).lookupResult(URLStreamHandler.class);
            LookupListener listener = new LookupListener() {
                public @Override void resultChanged(LookupEvent ev) {
                    synchronized (ProxyURLStreamHandlerFactory.this) {
                        Collection<? extends URLStreamHandler> instances = result.allInstances();
                        handlers.put(protocol, instances.isEmpty() ? null : instances.iterator().next());
                    }
                }
            };
            result.addLookupListener(listener);
            listener.resultChanged(null);
            results.put(protocol, result);
        }
        return handlers.get(protocol);
    }
}




/*
 * 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 2009 Sun Microsystems, Inc.
 */

package org.openide.util;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.net.URL;
import java.net.URLStreamHandler;
import java.net.URLStreamHandlerFactory;
import org.openide.util.lookup.NamedServiceDefinition;

/**
 * Replacement for {@link URLStreamHandlerFactory} within the NetBeans platform.
 * (The JVM only permits one global factory to be set at a time,
 * whereas various independent modules may wish to register handlers.)
 * May be placed on a {@link URLStreamHandler} implementation to register it.
 * Your handler will be loaded and used if and when a URL of a matching protocol is created.
 * <p>A {@link URLStreamHandlerFactory} which uses these registrations may be found in {@link Lookup#getDefault}.
 * This factory is active whenever the module system is loaded.
 * You may also wish to call {@link URL#setURLStreamHandlerFactory}
 * from a unit test or otherwise without the module system active.
 * @since org.openide.util 7.31
 */
@NamedServiceDefinition(path="URLStreamHandler/@protocol()", serviceType=URLStreamHandler.class)
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface URLStreamHandlerRegistration {

    /**
     * URL protocol(s) which are handled.
     * {@link URLStreamHandler#openConnection} will be called with a matching {@link URL#getProtocol}.
     */
    String[] protocol();

    /**
     * An optional position in which to register this handler relative to others.
     * The lowest-numbered handler is used in favor of any others, including unnumbered handlers.
     */
    int position() default Integer.MAX_VALUE;

}

Lines 392-398 Link Here

(-)a/web.inspect/src/org/netbeans/modules/web/inspect/webkit/RemoteStyleSheetCache.java (-1 lines)
392	return null;	392	return null;
393	}	393	}
394		394
395	@Override
396	public SystemAction[] getActions() {	395	public SystemAction[] getActions() {
397	return new SystemAction[0];	396	return new SystemAction[0];
398	}	397	}

Return to bug 243683

Lines 358-368 Link Here

(-)a/dlight.remote.impl/src/org/netbeans/modules/remote/impl/fs/RemoteFileSystem.java (-6 / +1 lines)
358	}	358	}
359		359
360		360
361	@Override
362	public SystemAction[] getActions() {
363	return NO_SYSTEM_ACTIONS;
364	}
365
366	public void addPendingFile(RemoteFileObjectBase fo) {	361	public void addPendingFile(RemoteFileObjectBase fo) {
367	remoteFileSupport.addPendingFile(fo);	362	remoteFileSupport.addPendingFile(fo);
368	fireProblemListeners(fo.getPath());	363	fireProblemListeners(fo.getPath());
Lines 665-671 Link Here
665	}	660	}
666	}	661	}
667		662
668	@Override	663	// @Override -- overrides at runtime
669	public final SystemAction[] getActions(final Set<FileObject> foSet) {	664	public final SystemAction[] getActions(final Set<FileObject> foSet) {
670	SystemAction[] result = status.getActions (foSet);	665	SystemAction[] result = status.getActions (foSet);
671	SystemAction refreshAction = isManualRefresh() ? null : FileSystemRefreshAction.get(FileSystemRefreshAction.class);	666	SystemAction refreshAction = isManualRefresh() ? null : FileSystemRefreshAction.get(FileSystemRefreshAction.class);

Lines 1309-1314 Link Here

(-)a/nbbuild/templates/common.xml (+10 lines)
1309	<module codenamebase="org.openide.util" spec="9.0"/>	1309	<module codenamebase="org.openide.util" spec="9.0"/>
1310	<module codenamebase="org.openide.util.base" spec="9.0"/>	1310	<module codenamebase="org.openide.util.base" spec="9.0"/>
1311	</replace>	1311	</replace>
		1312
		1313	<replace codenamebase="org.openide.filesystems" addcompiletime="true">
		1314	<module codenamebase="org.openide.filesystems" spec="9.0"/>
		1315	<module codenamebase="org.openide.filesystems.nb" spec="9.0"/>
		1316	<module codenamebase="org.openide.filesystems.compat8" spec="9.0"/>
		1317	</replace>
		1318	<replace codenamebase="org.openide.execution" addcompiletime="true">
		1319	<module codenamebase="org.openide.execution" spec="9.0"/>
		1320	<module codenamebase="org.openide.execution.compat8" spec="9.0"/>
		1321	</replace>
1312	<fileset dir="nbproject" >	1322	<fileset dir="nbproject" >
1313	<include name="project.xml" />	1323	<include name="project.xml" />
1314	</fileset>	1324	</fileset>

Lines 54-59 Link Here

(-)a/core.osgi/src/org/netbeans/core/osgi/OSGiRepository.java (-1 / +2 lines)
54	import java.util.logging.Level;	54	import java.util.logging.Level;
55	import java.util.logging.Logger;	55	import java.util.logging.Logger;
56	import org.openide.filesystems.FileStatusListener;	56	import org.openide.filesystems.FileStatusListener;
		57	import org.openide.filesystems.FileSystem$Environment;
57	import org.openide.filesystems.FileSystem;	58	import org.openide.filesystems.FileSystem;
58	import org.openide.filesystems.FileUtil;	59	import org.openide.filesystems.FileUtil;
59	import org.openide.filesystems.LocalFileSystem;	60	import org.openide.filesystems.LocalFileSystem;
Lines 141-147 Link Here
141	private static final class SFS extends MultiFileSystem implements LookupListener {	142	private static final class SFS extends MultiFileSystem implements LookupListener {
142		143
143	static {	144	static {
144	@SuppressWarnings("deprecation") Object _1 = FileSystem.Environment.class; // FELIX-2128	145	@SuppressWarnings("deprecation") Object _1 = FileSystem$Environment.class; // FELIX-2128
145	@SuppressWarnings("deprecation") Object _2 = org.openide.filesystems.FileSystemCapability.class;	146	@SuppressWarnings("deprecation") Object _2 = org.openide.filesystems.FileSystemCapability.class;
146	Object _3 = FileStatusListener.class;	147	Object _3 = FileStatusListener.class;
147	Object _4 = LookupEvent.class; // FELIX-3477	148	Object _4 = LookupEvent.class; // FELIX-3477

Lines 118-124 Link Here

(-)a/core.startup/src/org/netbeans/core/startup/layers/SystemFileSystem.java (-8 lines)
118	home = fss.length > 1 ? (ModuleLayeredFileSystem) fss[1] : null;	118	home = fss.length > 1 ? (ModuleLayeredFileSystem) fss[1] : null;
119		119
120	setSystemName(SYSTEM_NAME);	120	setSystemName(SYSTEM_NAME);
121	setHidden(true);
122	addFileChangeListener(this);	121	addFileChangeListener(this);
123	}	122	}
124		123
Lines 188-200 Link Here
188	return super.createLocksOn (name);	187	return super.createLocksOn (name);
189	}	188	}
190		189
191	/** This filesystem cannot be removed from pool, it is persistent.
192	*/
193	@Deprecated
194	public @Override boolean isPersistent() {
195	return true;
196	}
197
198	/** Initializes and creates new repository. This repository's system fs is	190	/** Initializes and creates new repository. This repository's system fs is
199	* based on the content of ${HOME_DIR}/system and ${USER_DIR}/system directories	191	* based on the content of ${HOME_DIR}/system and ${USER_DIR}/system directories
200	*	192	*

Lines 237-248 Link Here

(-)a/masterfs/src/org/netbeans/modules/masterfs/filebasedfs/FileBasedFileSystem.java (-6 lines)
237	throw new IOException("Cannot create temporary file"); // NOI18N	237	throw new IOException("Cannot create temporary file"); // NOI18N
238	}	238	}
239		239
240	@Override
241	public SystemAction[] getActions() {
242	return new SystemAction[] {};
243	}
244
245	@Override
246	public final SystemAction[] getActions(final Set<FileObject> foSet) {	240	public final SystemAction[] getActions(final Set<FileObject> foSet) {
247	SystemAction[] some = status.getActions (foSet);	241	SystemAction[] some = status.getActions (foSet);
248	if (some != null) {	242	if (some != null) {

Line 0 Link Here

(-)a/openide.execution.compat8/nbproject/project.xml (+38 lines)
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<project xmlns="http://www.netbeans.org/ns/project/1">
	3	<type>org.netbeans.modules.apisupport.project</type>
	4	<configuration>
	5	<data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
	6	<code-name-base>org.openide.execution.compat8</code-name-base>
	7	<module-dependencies>
	8	<dependency>
	9	<code-name-base>org.openide.execution</code-name-base>
	10	<build-prerequisite/>
	11	<compile-dependency/>
	12	<run-dependency>
	13	<specification-version>9.0</specification-version>
	14	</run-dependency>
	15	</dependency>
	16	<dependency>
	17	<code-name-base>org.openide.filesystems</code-name-base>
	18	<build-prerequisite/>
	19	<compile-dependency/>
	20	<run-dependency>
	21	<specification-version>9.0</specification-version>
	22	</run-dependency>
	23	</dependency>
	24	<dependency>
	25	<code-name-base>org.openide.filesystems.compat8</code-name-base>
	26	<build-prerequisite/>
	27	<compile-dependency/>
	28	<run-dependency>
	29	<specification-version>9.0</specification-version>
	30	</run-dependency>
	31	</dependency>
	32	</module-dependencies>
	33	<public-packages>
	34	<package>org.openide.execution</package>
	35	</public-packages>
	36	</data>
	37	</configuration>
	38	</project>

Line 0 Link Here

(-)a/openide.execution.compat8/src/org/openide/execution/NbClassPathCompat.java (+115 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2014 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2014 Sun Microsystems, Inc.
		41	*/
		42
		43	package org.openide.execution;
		44
		45	import java.util.Enumeration;
		46	import java.util.LinkedList;
		47	import org.openide.filesystems.EnvironmentNotSupportedException;
		48	import org.openide.filesystems.FileSystem;
		49	import org.openide.filesystems.FileSystem$Environment;
		50	import org.openide.filesystems.FileSystemCapability;
		51	import org.openide.filesystems.FileSystemCompat;
		52
		53	/**
		54	* Backward binary compatibility support for deprecated/obsolete features
		55	* @author sdedic
		56	*/
		57	public class NbClassPathCompat {
		58
		59	/** Method to obtain class path for the current state of the repository.
		60	* The classpath should be scanned for all occured exception caused
		61	* by file systems that cannot be converted to class path by a call to
		62	* method getExceptions().
		63	*
		64	*
65	* @return class path for all reachable systems in the repository
66	* @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/api.html">ClassPath API</a> instead.
67	*/
68	@Deprecated
69	public static NbClassPath createRepositoryPath () {
70	Thread.dumpStack();
71	return createRepositoryPath (FileSystemCapability.ALL);
72	}
73
74	/** Method to obtain class path for the current state of the repository.
75	* The classpath should be scanned for all occured exception caused
76	* by file systems that cannot be converted to class path by a call to
77	* method getExceptions().
78	*
79	*
80	* @param cap the capability that must be satisfied by the file system
81	* added to the class path
82	* @return class path for all reachable systems in the repository
83	* @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/api.html">ClassPath API</a> instead.
84	*/
85	@Deprecated
86	public static NbClassPath createRepositoryPath (FileSystemCapability cap) {
87	Thread.dumpStack();
88	final LinkedList res = new LinkedList ();
89
90
91	final class Env extends FileSystem$Environment {
92	/* method of interface Environment */
93	public void addClassPath(String element) {
94	res.add (element);
95	}
96	}
97
98
99	Env env = new Env ();
100	Enumeration en = cap.fileSystems ();
101	while (en.hasMoreElements ()) {
102	try {
103	FileSystem fs = (FileSystem)en.nextElement ();
104	FileSystemCompat.compat(fs).prepareEnvironment((FileSystem$Environment)env);
105	} catch (EnvironmentNotSupportedException ex) {
106	// store the exception
107	res.add (ex);
108	}
109	}
110
111	// return it
112	return new NbClassPath (res.toArray ());
113	}
114
115	}

Lines 62-66 Link Here

(-)a/openide.execution/module-auto-deps.xml (+13 lines)
62	</implies>	62	</implies>
63	</transformation>	63	</transformation>
64	</transformationgroup>	64	</transformationgroup>
		65	<transformationgroup>
		66	<description>Removal of FileSystemCapability</description>
		67	<transformation>
		68	<trigger-dependency type="older">
		69	<module-dependency codenamebase="org.openide.execution" spec="9.0"/>
		70	</trigger-dependency>
		71	<implies>
		72	<result>
		73	<module-dependency codenamebase="org.openide.execution.compat8" spec="9.0"/>
		74	</result>
		75	</implies>
		76	</transformation>
		77	</transformationgroup>
65		78
66	</transformations>	79	</transformations>

Lines 85-91 Link Here

(-)a/openide.execution/src/org/openide/execution/NbClassPath.java (-55 / +1 lines)
85	/** Private constructor	85	/** Private constructor
86	* @param arr array of String and Exceptions	86	* @param arr array of String and Exceptions
87	*/	87	*/
88	private NbClassPath (Object[] arr) {	88	NbClassPath (Object[] arr) {
89	this.items = arr;	89	this.items = arr;
90	}	90	}
91		91
Lines 109-168 Link Here
109	}	109	}
110	}	110	}
111		111
112	/** Method to obtain class path for the current state of the repository.
113	* The classpath should be scanned for all occured exception caused
114	* by file systems that cannot be converted to class path by a call to
115	* method getExceptions().
116	*
117	*
118	* @return class path for all reachable systems in the repository
119	* @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/api.html">ClassPath API</a> instead.
120	*/
121	public static NbClassPath createRepositoryPath () {
122	Thread.dumpStack();
123	return createRepositoryPath (FileSystemCapability.ALL);
124	}
125
126	/** Method to obtain class path for the current state of the repository.
127	* The classpath should be scanned for all occured exception caused
128	* by file systems that cannot be converted to class path by a call to
129	* method getExceptions().
130	*
131	*
132	* @param cap the capability that must be satisfied by the file system
133	* added to the class path
134	* @return class path for all reachable systems in the repository
135	* @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/api.html">ClassPath API</a> instead.
136	*/
137	public static NbClassPath createRepositoryPath (FileSystemCapability cap) {
138	Thread.dumpStack();
139	final LinkedList res = new LinkedList ();
140
141
142	final class Env extends FileSystem.Environment {
143	/* method of interface Environment */
144	public void addClassPath(String element) {
145	res.add (element);
146	}
147	}
148
149
150	Env env = new Env ();
151	Enumeration en = cap.fileSystems ();
152	while (en.hasMoreElements ()) {
153	try {
154	FileSystem fs = (FileSystem)en.nextElement ();
155	fs.prepareEnvironment(env);
156	} catch (EnvironmentNotSupportedException ex) {
157	// store the exception
158	res.add (ex);
159	}
160	}
161
162	// return it
163	return new NbClassPath (res.toArray ());
164	}
165
166	/** Creates class path describing additional libraries needed by the system.	112	/** Creates class path describing additional libraries needed by the system.
167	* Never use this class path as part of a user project!	113	* Never use this class path as part of a user project!
168	* For more information consult the <a href="../doc-files/classpath.html">Module Class Path</a> document.	114	* For more information consult the <a href="../doc-files/classpath.html">Module Class Path</a> document.

Line 0 Link Here

(-)a/openide.filesystems.compat8/arch.xml (+337 lines)
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<!DOCTYPE api-answers PUBLIC "-//NetBeans//DTD Arch Answers//EN" "../nbbuild/antsrc/org/netbeans/nbbuild/Arch.dtd" [
		3	<!ENTITY api-questions SYSTEM "../nbbuild/antsrc/org/netbeans/nbbuild/Arch-api-questions.xml">
		4	]>
		5
		6	<api-answers
		7	question-version="1.29"
		8	author="sdedic@netbeans.org"
		9	>
		10
		11	&api-questions;
		12
		13	<answer id="arch-overall">
		14	<p>
		15	This module contains no public API. It only serves to provide binary backward compatibility
		16	for modules compiled against FileSystems API 8.x and earlier.
		17	</p>
		18	</answer>
		19
		20	<answer id="arch-quality">
		21	<p>
		22	Tests to ensure FileSystems 8.x features should be provided.
		23	</p>
		24	</answer>
		25
		26	<answer id="arch-time">
		27	<p>
		28	Already done.
		29	</p>
		30	</answer>
		31
		32	<answer id="arch-usecases">
		33	<p>
		34	Allows to run modules compiled against FileSystems 8.0 APIs
		35	</p>
		36	</answer>
		37
		38	<answer id="arch-what">
		39	<p>
		40	Preservation of compatibility
		41	</p>
		42	</answer>
		43
		44	<answer id="arch-where">
		45	<defaultanswer generate='here' />
		46	</answer>
		47
		48	<answer id="compat-deprecation">
		49	<p>
		50	APIs that relate to <a href="@TOP@/org/openide/filesystems/FileSystemCapability.html">FileSystemCapability</a> and
		51	<a href="@TOP@/org/openide/filesystems/FileSystem$Environment.html">FileSystem.Environment</a> are removed from the main API
		52	and provided here only for binary compatibility.
		53	</p>
		54	</answer>
		55
		56	<answer id="compat-i18n">
		57	<p>
		58	yes
		59	</p>
		60	</answer>
		61
		62	<answer id="compat-standards">
		63	<p>
		64	no
65	</p>
66	</answer>
67
68
69
70	<answer id="compat-version">
71	<p>
72	yes
73	</p>
74	</answer>
75
76	<answer id="dep-jre">
77	<p>
78	no dependency
79	</p>
80	</answer>
81
82	<answer id="dep-jrejdk">
83	<p>
84	JRE
85	</p>
86	</answer>
87
88	<answer id="dep-nb">
89	<defaultanswer generate='here' />
90	</answer>
91
92	<answer id="dep-non-nb">
93	<p>
94	None
95	</p>
96	</answer>
97
98	<answer id="dep-platform">
99	<p>
100	All
101	</p>
102	</answer>
103
104	<answer id="deploy-dependencies">
105	<p>
106	None
107	</p>
108	</answer>
109
110	<answer id="deploy-jar">
111	<p>
112	No.
113	</p>
114	</answer>
115
116	<!--
117	<question id="deploy-nbm" when="impl">
118	Can you deploy an NBM via the Update Center?
119	<hint>
120	If not why?
121	</hint>
122	</question>
123	-->
124	<answer id="deploy-nbm">
125	<p>
126	Yes
127	</p>
128	</answer>
129
130	<answer id="deploy-packages">
131	<p>
132	Yes, packages are only available to strictly defined friends
133	</p>
134	</answer>
135
136	<answer id="deploy-shared">
137	<p>
138	Shared location
139	</p>
140	</answer>
141
142	<answer id="exec-ant-tasks">
143	<p>
144	No
145	</p>
146	</answer>
147
148	<answer id="exec-classloader">
149	<p>
150	No.
151	</p>
152	</answer>
153
154	<answer id="exec-component">
155	<p>
156	No.
157	</p>
158	</answer>
159
160	<answer id="exec-introspection">
161	<p>
162	No.
163	</p>
164	</answer>
165
166	<answer id="exec-privateaccess">
167	<p>
168	None.
169	</p>
170	</answer>
171
172	<answer id="exec-process">
173	<p>
174	No.
175	</p>
176	</answer>
177
178	<answer id="exec-property">
179	<p>
180	No.
181	</p>
182	</answer>
183
184	<answer id="exec-reflection">
185	<p>
186	Not directly reflection. The code however relies on that it is deployed
187	to the same runtime package as FileSystems API and accessess its package
188	private parts.
189	</p>
190	</answer>
191
192	<answer id="exec-threading">
193	<p>
194	See Filesystems API
195	</p>
196	</answer>
197
198	<answer id="format-clipboard">
199	<p>
200	See Filesystems API
201	</p>
202	</answer>
203
204	<answer id="format-dnd">
205	<p>
206	See Filesystems API
207	</p>
208	</answer>
209
210	<answer id="format-types">
211	<p>
212	None.
213	</p>
214	</answer>
215
216	<answer id="lookup-lookup">
217	<p>
218	No.
219	</p>
220	</answer>
221
222	<answer id="lookup-register">
223	<p>
224	None.
225	</p>
226	</answer>
227
228	<answer id="lookup-remove">
229	<p>
230	No.
231	</p>
232	</answer>
233
234	<answer id="perf-exit">
235	<p>
236	No.
237	</p>
238	</answer>
239
240	<answer id="perf-huge_dialogs">
241	<p>
242	None.
243	</p>
244	</answer>
245
246	<answer id="perf-limit">
247	<p>
248	N/A
249	</p>
250	</answer>
251
252	<answer id="perf-mem">
253	<p>
254	N/A
255	</p>
256	</answer>
257
258	<answer id="perf-menus">
259	<p>
260	No menus
261	</p>
262	</answer>
263
264	<answer id="perf-progress">
265	<p>
266	No.
267	</p>
268	</answer>
269
270	<answer id="perf-scale">
271	<p>
272	See Filesystems API
273	</p>
274	</answer>
275
276	<answer id="perf-spi">
277	<p>
278	N/A
279	</p>
280	</answer>
281
282	<answer id="perf-startup">
283	<p>
284	No.
285	</p>
286	</answer>
287
288	<answer id="perf-wakeup">
289	<p>
290	No.
291	</p>
292	</answer>
293
294	<answer id="resources-file">
295	<p>
296	Yes, for initialization of <a href="@openide-filesystems@/org/openide/filesystems/LocalFileSystem.html">LocalFileSystem</a>
297	and <a href="@openide-filesystems@/org/openide/filesystems/JarFileSystem.html">JarFileSystem</a>
298	</p>
299	</answer>
300
301	<answer id="resources-layer">
302	<p>
303	No layer
304	</p>
305	</answer>
306
307	<answer id="resources-mask">
308	<p>
309	No.
310	</p>
311	</answer>
312
313	<answer id="resources-preferences">
314	<p>
315	No.
316	</p>
317	</answer>
318
319	<answer id="resources-read">
320	<p>
321	No.
322	</p>
323	</answer>
324
325	<answer id="security-grant">
326	<p>
327	No.
328	</p>
329	</answer>
330
331	<answer id="security-policy">
332	<p>
333	No.
334	</p>
335	</answer>
336
337	</api-answers>

Line 0 Link Here

(-)a/openide.filesystems.compat8/src/org/openide/filesystems/EnvironmentNotSupportedException.java (+86 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* Contributor(s):
		28	*
		29	* The Original Software is NetBeans. The Initial Developer of the Original
		30	* Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
		31	* Microsystems, Inc. All Rights Reserved.
		32	*
		33	* If you wish your version of this file to be governed by only the CDDL
		34	* or only the GPL Version 2, indicate your decision by adding
		35	* "[Contributor] elects to include this software in this distribution
		36	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		37	* single choice of license, a recipient has the option to distribute
		38	* your version of this file under either the CDDL, the GPL Version 2 or
		39	* to extend the choice of license to its licensees as provided above.
		40	* However, if you add GPL Version 2 code and therefore, elected the GPL
		41	* Version 2 license, then the option applies only if the new code is
		42	* made subject to such option by the copyright holder.
		43	*/
		44
		45	package org.openide.filesystems;
		46
		47	import java.io.IOException;
		48
		49	/** Exception thrown to signal that external
		50	* execution and compilation is not supported on a given filesystem.
		51	*
		52	* @author Jaroslav Tulach
		53	* @deprecated Please use the <a href="@org-netbeans-api-java-classpath@/org/netbeans/api/java/classpath/ClassPath.html">ClassPath API</a> instead.
		54	*/
		55	@Deprecated
		56	public class EnvironmentNotSupportedException extends IOException {
		57	/** generated Serialized Version UID */
		58	static final long serialVersionUID = -1138390681913514558L;
		59
		60	/** the throwing exception */
		61	private FileSystem fs;
		62
		63	/**
		64	* @param fs filesystem that caused the error
65	*/
66	public EnvironmentNotSupportedException(FileSystem fs) {
67	this.fs = fs;
68	assert false : "Deprecated.";
69	}
70
71	/**
72	* @param fs filesystem that caused the error
73	* @param reason text description for the error
74	*/
75	public EnvironmentNotSupportedException(FileSystem fs, String reason) {
76	super(reason);
77	this.fs = fs;
78	assert false : "Deprecated.";
79	}
80
81	/** Getter for the filesystem that does not support environment operations.
82	*/
83	public FileSystem getFileSystem() {
84	return fs;
85	}
86	}

Line 0 Link Here

(-)a/openide.filesystems.nb/src/org/netbeans/modules/openide/filesystems/FileFilterSupport.java (+470 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.openide.filesystems;
		43
		44	import java.io.File;
		45	import java.util.ArrayList;
		46	import java.util.Collections;
		47	import java.util.Comparator;
		48	import java.util.HashMap;
		49	import java.util.HashSet;
		50	import java.util.LinkedList;
		51	import java.util.List;
		52	import java.util.Map;
		53	import java.util.Set;
		54	import java.util.logging.Level;
		55	import java.util.logging.Logger;
		56	import java.util.regex.Matcher;
		57	import java.util.regex.Pattern;
		58	import javax.swing.filechooser.FileFilter;
		59	import org.openide.filesystems.FileObject;
		60	import org.openide.filesystems.FileUtil;
		61
		62	/**
		63	* Support methods for creation of registered {@link FileFilter file filters}.
		64	*/
65	public final class FileFilterSupport {
66
67	/**
68	* The logger.
69	*/
70	private static final Logger LOG = Logger.getLogger(
71	FileFilterSupport.class.getName());
72
73	/**
74	* Hide the default constructor.
75	*/
76	private FileFilterSupport() {
77	}
78
79	/**
80	* Construct description for {@link FileFilter} that accepts files with
81	* specified extension.
82	*
83	* @param displayName Human readable display name (e.g. "HTML files")
84	* @param elements List of accepted filter elements.
85	*
86	* @return Display name (description) for the filter.
87	*/
88	private static String constructFilterDisplayName(String displayName,
89	List<FilterElement> elements) {
90	StringBuilder sb = new StringBuilder(displayName);
91	boolean first = true;
92	sb.append(" ["); //NOI18N
93	for (FilterElement el : elements) {
94	if (first) {
95	first = false;
96	} else {
97	sb.append(", "); //NOI18N
98	}
99	sb.append(el.getName());
100	}
101	sb.append("]"); //NOI18N
102	return sb.toString();
103	}
104
105	/**
106	* Check whether passed file is accepted by filter for specified list of
107	* extensions.
108	*
109	* @param file File to be accepted or rejected.
110	* @param elements List of accepted filter elements.
111	*
112	* @return True if the file is accepted, false if it is rejected.
113	*
114	* @see FileFilterSupport
115	*/
116	private static boolean accept(File file, List<FilterElement> elements) {
117	if (file != null) {
118	if (file.isDirectory()) {
119	return true;
120	}
121	for (FilterElement elm : elements) {
122	if (elm.accept(file)) {
123	return true;
124	}
125	}
126	}
127	return false;
128	}
129
130	public static List<FileFilter> findRegisteredFileFilters() {
131	List<FileFilter> filters = new LinkedList<FileFilter>();
132	FileObject root = FileUtil.getConfigFile(
133	"Services/MIMEResolver"); //NOI18N
134	Map<String, Set<FileObject>> filterNameToResolversMap =
135	new HashMap<String, Set<FileObject>>();
136	for (FileObject child : root.getChildren()) {
137	if (child.isFolder()) {
138	continue;
139	}
140	int i = 0;
141	String f;
142	while ((f = (String) child.getAttribute("fileChooser." + i))//NOI18N
143	!= null) {
144	Set<FileObject> set = filterNameToResolversMap.get(f);
145	if (set == null) {
146	set = new HashSet<FileObject>();
147	filterNameToResolversMap.put(f, set);
148	}
149	set.add(child);
150	i++;
151	}
152	}
153	for (Map.Entry<String, Set<FileObject>> e :
154	filterNameToResolversMap.entrySet()) {
155	filters.add(createFilter(e.getKey(), e.getValue()));
156	}
157	return sortFiltersByDescription(filters);
158	}
159
160	private static FileFilter createFilter(final String name,
161	final Set<FileObject> resolvers) {
162	ArrayList<FilterElement> elems = new ArrayList<FilterElement>(3);
163	String lastAtt;
164	for (FileObject fo : resolvers) {
165	int i = 0;
166	while ((lastAtt = (String) fo.getAttribute(
167	"ext." + i)) != null) { //NOI18N
168	addExtensionToList(elems, lastAtt);
169	i++;
170	}
171	int n = 0;
172	while ((lastAtt = (String) fo.getAttribute("fileName." //NOI18N
173	+ (n++))) != null) {
174	addNameToList(elems, lastAtt);
175	}
176	String type;
177	if ((type = (String) fo.getAttribute("mimeType")) != null) {//NOI18N
178	addMimeTypeExts(elems, type);
179	}
180	int t = 0;
181	while ((type = (String) fo.getAttribute(
182	"mimeType." + (t++))) != null) { //NOI18N
183	addMimeTypeExts(elems, type);
184	}
185	}
186	sortFilterElements(elems);
187	return new FileFilterImpl(name, elems);
188	}
189
190	/**
191	* Add all extensions assigned to a MIME Type to the extension list.
192	*/
193	private static void addMimeTypeExts(List<FilterElement> exts, String type) {
194	addAllExtensionsToList(exts, FileUtil.getMIMETypeExtensions(type));
195	}
196
197	/**
198	* Add new items to list of extensions, prevent duplicates.
199	*
200	* @param list List of extensions to alter.
201	* @param toAdd List of extensions (without starting dot) to add.
202	*/
203	private static void addAllExtensionsToList(List<FilterElement> list,
204	List<String> toAdd) {
205	for (String s : toAdd) {
206	addExtensionToList(list, s);
207	}
208	}
209
210	/**
211	* Add new item to list of extensions, prevent duplacates.
212	*
213	* @param list List of extensions to alter.
214	* @param s Extensions without starting dot.
215	*/
216	private static void addExtensionToList(List<FilterElement> list,
217	String ext) {
218	addFilterElementToList(list, FilterElement.createForExtension(ext));
219	}
220
221	private static void addNameToList(List<FilterElement> list, String name) {
222	Pattern p = Pattern.compile(
223	"\\[([^,]+), (true\|false), (true\|false)\\](\\S*)"); //NOI18N
224	Matcher m = p.matcher(name);
225	if (m.find()) {
226	String fileName = m.group(1);
227	boolean substring = m.group(2).equals("true"); //NOI18N
228	boolean ignoreCase = m.group(3).equals("true"); //NOI18N
229	String extension = m.group(4);
230	addFilterElementToList(list, FilterElement.createForFileName(
231	fileName, extension, substring, ignoreCase));
232	} else {
233	LOG.log(Level.INFO, "Incorrect name pattern {0}", name); //NOI18N
234	}
235	}
236
237	private static void addFilterElementToList(List<FilterElement> list,
238	FilterElement newItem) {
239
240	for (int i = 0; i < list.size(); i++) {
241	FilterElement el = list.get(i);
242	FilterElement.ComparisonResult result = newItem.compare(el);
243	switch (result) {
244	case DIFFERENT:
245	continue;
246	case THE_SAME:
247	case WORSE:
248	return;
249	case BETTER:
250	list.set(i, newItem);
251	return;
252	}
253	}
254	list.add(newItem);
255	}
256
257	private static List<FileFilter> sortFiltersByDescription(
258	List<FileFilter> list) {
259
260	Collections.sort(list, new Comparator<FileFilter>() {
261	@Override
262	public int compare(FileFilter o1, FileFilter o2) {
263	return o1.getDescription().compareTo(o2.getDescription());
264	}
265	});
266	return list;
267	}
268
269	private static List<FilterElement> sortFilterElements(
270	List<FilterElement> elements) {
271	Collections.sort(elements, new Comparator<FilterElement>() {
272	@Override
273	public int compare(FilterElement o1, FilterElement o2) {
274	return o1.getName().compareTo(o2.getName());
275	}
276	});
277	return elements;
278	}
279
280	private static class FileFilterImpl extends FileFilter {
281
282	private final String name;
283	List<FilterElement> filterElements;
284
285	public FileFilterImpl(String name, List<FilterElement> elements) {
286	this.name = name;
287	this.filterElements = elements;
288	}
289
290	@Override
291	public boolean accept(File pathname) {
292	return FileFilterSupport.accept(pathname, filterElements);
293	}
294
295	@Override
296	public String getDescription() {
297	return FileFilterSupport.constructFilterDisplayName(
298	name, filterElements);
299	}
300	}
301
302	/**
303	* Element of File Filter. One accepted extension or file name pattern.
304	*/
305	private static abstract class FilterElement {
306
307	public abstract String getName();
308
309	public abstract boolean accept(File f);
310
311	/**
312	* Compare two filter elements. Correct implementation of this method
313	* prevents adding duplicite elements to the filter.
314	*/
315	public abstract ComparisonResult compare(FilterElement e);
316
317	public static FilterElement createForExtension(String ext) {
318	return new ExtensionBasedFilterElement(ext);
319	}
320
321	public static FilterElement createForFileName(String name,
322	String extension, boolean substring, boolean ignoreCase) {
323	return new NameBasedFilterElement(name, extension,
324	substring, ignoreCase);
325	}
326
327	public static enum ComparisonResult {
328
329	THE_SAME, BETTER, WORSE, DIFFERENT
330	}
331
332	private static class ExtensionBasedFilterElement extends FilterElement {
333
334	private final String extension;
335
336	public ExtensionBasedFilterElement(String extension) {
337	if (extension != null) {
338	this.extension = extension;
339	} else {
340	throw new NullPointerException();
341	}
342	}
343
344	@Override
345	public String getName() {
346	return "." + extension; //NOI18N
347	}
348
349	@Override
350	public boolean accept(File f) {
351	return f.getName().toLowerCase().endsWith(
352	"." + extension.toLowerCase()); //NOI18N
353	}
354
355	@Override
356	public ComparisonResult compare(FilterElement e) {
357	if (!(e instanceof ExtensionBasedFilterElement)) {
358	return ComparisonResult.DIFFERENT;
359	}
360	ExtensionBasedFilterElement x = (ExtensionBasedFilterElement) e;
361	if (x == null) {
362	throw new NullPointerException();
363	}
364	if (this.extension.equals(x.extension)) {
365	return ComparisonResult.THE_SAME;
366	} else if (this.extension.equalsIgnoreCase(x.extension)
367	&& this.extension.length() > 1) {
368	if (Character.isUpperCase(x.extension.charAt(0))) {
369	return ComparisonResult.BETTER; //this better, x worse
370	} else {
371	return ComparisonResult.WORSE; // this worse, x better
372	}
373	} else {
374	return ComparisonResult.DIFFERENT;
375	}
376	}
377	}
378
379	private static class NameBasedFilterElement extends FilterElement {
380
381	String name;
382	String ext;
383	boolean substring;
384	boolean ignoreCase;
385	Pattern p;
386
387	public NameBasedFilterElement(String name, String ext,
388	boolean substring, boolean ignoreCase) {
389	this.name = name;
390	this.ext = ext;
391	this.substring = substring;
392	this.ignoreCase = ignoreCase;
393	StringBuilder sb = new StringBuilder();
394	if (ignoreCase) {
395	sb.append("(?i)"); //NOI18N
396	}
397	if (substring) {
398	sb.append(".*"); //NOI18N
399	}
400	sb.append(name); //NOI18N
401	if (substring) {
402	sb.append(".*"); //NOI18N
403	}
404	if (!ext.isEmpty()) {
405	sb.append("\\."); //NOI18N
406	sb.append(ext);
407	}
408	p = Pattern.compile(sb.toString());
409	}
410
411	@Override
412	public String getName() {
413	return name + (ext.isEmpty() ? "" : "." + ext); //NOI18N
414	}
415
416	@Override
417	public boolean accept(File f) {
418	return p.matcher(f.getName()).matches();
419	}
420
421	@Override
422	public ComparisonResult compare(FilterElement e) {
423	if (e == null) {
424	throw new NullPointerException();
425	} else if (!(e instanceof NameBasedFilterElement)) {
426	return ComparisonResult.DIFFERENT;
427	}
428	NameBasedFilterElement x = (NameBasedFilterElement) e;
429	if (this.name.equals(x.name) && this.ext.equals(x.ext)) {
430	if (this.substring == x.substring
431	&& this.ignoreCase == x.ignoreCase) {
432	return ComparisonResult.THE_SAME;
433	} else {
434	return compareFlags(x);
435	}
436	} else if (this.ext.equalsIgnoreCase(x.ext)
437	&& this.name.equalsIgnoreCase(x.name)
438	&& (this.ignoreCase \|\| x.ignoreCase)) {
439	if (this.substring == x.substring
440	&& this.ignoreCase == x.ignoreCase) {
441	if (Character.isLowerCase(this.name.charAt(0))) {
442	return ComparisonResult.BETTER;
443	} else {
444	return ComparisonResult.WORSE;
445	}
446	} else {
447	return compareFlags(x);
448	}
449	} else {
450	return ComparisonResult.DIFFERENT;
451	}
452	}
453
454	private ComparisonResult compareFlags(NameBasedFilterElement x) {
455	if (this.substring == x.substring
456	&& this.ignoreCase) {
457	return ComparisonResult.BETTER;
458	} else if (this.ignoreCase == x.ignoreCase
459	&& this.substring) {
460	return ComparisonResult.BETTER;
461	} else if (this.substring != x.substring
462	&& this.ignoreCase != x.ignoreCase) {
463	return ComparisonResult.DIFFERENT;
464	} else {
465	return ComparisonResult.WORSE;
466	}
467	}
468	}
469	}
470	}

Line 0 Link Here

(-)a/openide.filesystems.nb/test/unit/src/org/netbeans/modules/openide/filesystems/FileFilterSupportTest.java (+113 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.openide.filesystems;
		43
		44	import java.io.File;
		45	import java.util.List;
		46	import javax.swing.filechooser.FileFilter;
		47	import org.netbeans.junit.NbTestCase;
		48	import org.openide.filesystems.MIMEResolver;
		49	import org.openide.util.NbBundle;
		50
		51	/**
		52	* Test registered FileFilters.
		53	*
		54	* @author jhavlin
		55	*/
		56	@NbBundle.Messages({
		57	"RESOLVER=Resolver",
		58	"FILECHOOSER=BNM Files"
		59	})
		60	@MIMEResolver.Registration(
		61	displayName = "#RESOLVER",
		62	resource = "mime-resolver-filechooser.xml",
		63	showInFileChooser = "#FILECHOOSER", position=543543)
		64	public class FileFilterSupportTest extends NbTestCase {
65
66	public FileFilterSupportTest(String name) {
67	super(name);
68	}
69
70	/**
71	* This test, although it is quite short, tests a lot of ascpects of default
72	* file filters. The resolver definition XML file contains several
73	* duplicities, which are detected and ignored. If this detection fails,
74	* filter description and {@code accept} method is changed, and it is cought
75	* by this test.
76	*/
77	public void testRegisteredFilters() {
78	List<FileFilter> list = FileFilterSupport.findRegisteredFileFilters();
79	assertNotNull(list);
80	assertFalse(list.isEmpty());
81
82	boolean found = false;
83	for (FileFilter filter : list) {
84
85	if (filter.getDescription().startsWith("BNM Files")) {
86	found = true;
87	checkBnmFilesFilter(filter);
88	}
89	}
90	assertTrue("Registered File Filter was not found.", found);
91	}
92
93	private void checkBnmFilesFilter(FileFilter f) {
94	assertEquals("BNM Files [.bnm, bnmHelp, bnmProject, bnminfo, bnmsettings]",
95	f.getDescription());
96	assertTrue(f.accept(new File("first.bnm")));
97	assertTrue(f.accept(new File("second.BNM")));
98	assertTrue(f.accept(new File("third.bNm")));
99	assertTrue(f.accept(new File("bnmProject")));
100	assertTrue(f.accept(new File("PREFIXbnmProjectAndSuFfIx")));
101	assertFalse(f.accept(new File("bnmproject")));
102	assertTrue(f.accept(new File("bnmSettings")));
103	assertTrue(f.accept(new File("BNMSETTINGS")));
104	assertFalse(f.accept(new File("bnmSettingsX")));
105	assertTrue(f.accept(new File("bnmInfo")));
106	assertTrue(f.accept(new File("AbnmInfoB")));
107	assertTrue(f.accept(new File("aBNMINFOb")));
108	assertTrue(f.accept(new File("bnmHelp")));
109	assertFalse(f.accept(new File("bnmhelp")));
110	assertFalse(f.accept(new File("bnmHelpX")));
111	assertFalse(f.accept(new File("foo.txt")));
112	}
113	}

Line 0 Link Here

(-)a/openide.filesystems.nb/test/unit/src/org/netbeans/modules/openide/filesystems/mime-resolver-filechooser.xml (+63 lines)
	1	<?xml version="1.0"?>
	2	<MIME-resolver>
	3	<file>
	4	<ext name="bnm"/>
	5	<resolver mime="text/x-bnm"/>
	6	</file>
	7
	8	<!-- BNM PROJECT -->
	9	<file>
	10	<!--
	11	Duplicite resolver that accept less files than the following one.
	12	Should not be used in the filter.
	13	-->
	14	<ext name=""/>
	15	<name name="bnmProject" substring="false" ignorecase="false" />
	16	<resolver mime="text/x-bnm-project"/>
	17	</file>
	18	<file>
	19	<ext name=""/>
	20	<name name="bnmProject" substring="true" ignorecase="false" />
	21	<resolver mime="text/x-bnm-project"/>
	22	</file>
	23
	24	<!-- BNM SETTINGS -->
	25	<file>
	26	<ext name=""/>
	27	<name name="bnmSettings" substring="false" />
	28	<resolver mime="text/x-bnm-settings"/>
	29	</file>
	30	<file>
	31	<!--
	32	Duplicite resolver that accept less files than the previous one.
	33	Should not be used in the filter.
	34	-->
	35	<ext name=""/>
	36	<name name="bnmSettings" substring="false" ignorecase="true" />
	37	<resolver mime="text/x-bnm-settings"/>
	38	</file>
	39
	40	<!-- BNM INFO -->
	41	<file>
	42	<ext name=""/>
	43	<name name="bnmInfo" substring="true" />
	44	<resolver mime="text/x-bnm-info"/>
	45	</file>
	46	<file>
	47	<!--
	48	Duplicite resolver that accept the same files as the previous one,
	49	only differs in case of file name, that is ignored.
	50	Should not be used in the filter.
	51	-->
	52	<ext name=""/>
	53	<name name="BNMInfo" substring="true" />
	54	<resolver mime="text/x-bnm-info"/>
	55	</file>
	56
	57	<!-- BNM HELP -->
	58	<file>
	59	<ext name=""/>
	60	<name name="bnmHelp" substring="false" ignorecase="false" />
	61	<resolver mime="text/x-bnm-help"/>
	62	</file>
	63	</MIME-resolver>

Line 0 Link Here

(-)a/openide.filesystems.nb/test/unit/src/org/openide/filesystems/FileChooserBuilderTest.java (+417 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2010 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2008 Sun Microsystems, Inc.
		41	*/
		42
		43	package org.openide.filesystems;
		44
		45	import java.awt.Component;
		46	import java.awt.Dialog;
		47	import javax.swing.UIManager;
		48	import javax.swing.JRootPane;
		49	import java.util.concurrent.atomic.AtomicReference;
		50	import java.lang.reflect.InvocationTargetException;
		51	import java.util.concurrent.CountDownLatch;
		52	import java.awt.Container;
		53	import java.awt.EventQueue;
		54	import java.io.File;
		55	import java.io.IOException;
		56	import java.util.Arrays;
		57	import java.util.HashSet;
		58	import java.util.Set;
		59	import javax.swing.AbstractButton;
		60	import javax.swing.JFileChooser;
		61	import javax.swing.RootPaneContainer;
		62	import javax.swing.UnsupportedLookAndFeelException;
		63	import javax.swing.event.AncestorEvent;
		64	import javax.swing.event.AncestorListener;
65	import javax.swing.filechooser.FileFilter;
66	import javax.swing.plaf.metal.MetalLookAndFeel;
67	import org.netbeans.junit.NbTestCase;
68	import org.openide.util.RequestProcessor;
69	import static org.junit.Assert.*;
70	import org.netbeans.junit.RandomlyFails;
71
72	/**
73	* @author tim
74	*/
75	public class FileChooserBuilderTest extends NbTestCase {
76
77	public FileChooserBuilderTest(String name) {
78	super(name);
79	}
80
81	/**
82	* Test of setDirectoriesOnly method, of class FileChooserBuilder.
83	*/
84	public void testSetDirectoriesOnly() {
85	FileChooserBuilder instance = new FileChooserBuilder("x");
86	boolean dirsOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY;
87	assertFalse(dirsOnly);
88	instance.setDirectoriesOnly(true);
89	dirsOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY;
90	assertTrue(dirsOnly);
91	}
92
93	/**
94	* Test of setFilesOnly method, of class FileChooserBuilder.
95	*/
96	public void testSetFilesOnly() {
97	FileChooserBuilder instance = new FileChooserBuilder("y");
98	boolean filesOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.FILES_ONLY;
99	assertFalse(filesOnly);
100	instance.setFilesOnly(true);
101	filesOnly = instance.createFileChooser().getFileSelectionMode() == JFileChooser.FILES_ONLY;
102	assertTrue(filesOnly);
103	}
104
105	/**
106	* Test of setTitle method, of class FileChooserBuilder.
107	*/
108	public void testSetTitle() {
109	FileChooserBuilder instance = new FileChooserBuilder("a");
110	assertNull(instance.createFileChooser().getDialogTitle());
111	instance.setTitle("foo");
112	assertEquals("foo", instance.createFileChooser().getDialogTitle());
113	}
114
115	/**
116	* Test of setApproveText method, of class FileChooserBuilder.
117	*/
118	public void testSetApproveText() {
119	FileChooserBuilder instance = new FileChooserBuilder("b");
120	assertNull(instance.createFileChooser().getDialogTitle());
121	instance.setApproveText("bar");
122	assertEquals("bar", instance.createFileChooser().getApproveButtonText());
123	}
124
125	/**
126	* Test of setFileFilter method, of class FileChooserBuilder.
127	*/
128	public void testSetFileFilter() {
129	FileFilter filter = new FileFilter() {
130
131	@Override
132	public boolean accept(File f) {
133	return true;
134	}
135
136	@Override
137	public String getDescription() {
138	return "X";
139	}
140	};
141	FileChooserBuilder instance = new FileChooserBuilder("c");
142	instance.setFileFilter(filter);
143	assertEquals(filter, instance.createFileChooser().getFileFilter());
144	}
145
146	/**
147	* Test of setDefaultWorkingDirectory method, of class FileChooserBuilder.
148	*/
149	public void testSetDefaultWorkingDirectory() throws IOException {
150	FileChooserBuilder instance = new FileChooserBuilder("d");
151	File dir = getWorkDir();
152	assertTrue("tmpdir is not sane", dir.exists() && dir.isDirectory());
153	instance.setDefaultWorkingDirectory(dir);
154	assertEquals(dir, instance.createFileChooser().getCurrentDirectory());
155	}
156
157	/**
158	* Test of setFileHiding method, of class FileChooserBuilder.
159	*/
160	public void testSetFileHiding() {
161	FileChooserBuilder instance = new FileChooserBuilder("e");
162	assertFalse(instance.createFileChooser().isFileHidingEnabled());
163	instance.setFileHiding(true);
164	assertTrue(instance.createFileChooser().isFileHidingEnabled());
165	}
166
167	/**
168	* Test of setControlButtonsAreShown method, of class FileChooserBuilder.
169	*/
170	public void testSetControlButtonsAreShown() {
171	FileChooserBuilder instance = new FileChooserBuilder("f");
172	assertTrue(instance.createFileChooser().getControlButtonsAreShown());
173	instance.setControlButtonsAreShown(false);
174	assertFalse(instance.createFileChooser().getControlButtonsAreShown());
175	}
176
177	/**
178	* Test of setAccessibleDescription method, of class FileChooserBuilder.
179	*/
180	public void testSetAccessibleDescription() {
181	FileChooserBuilder instance = new FileChooserBuilder("g");
182	String desc = "desc";
183	instance.setAccessibleDescription(desc);
184	assertEquals(desc, instance.createFileChooser().getAccessibleContext().getAccessibleDescription());
185	}
186
187	/**
188	* Test of createFileChooser method, of class FileChooserBuilder.
189	*/
190	public void testCreateFileChooser() {
191	FileChooserBuilder instance = new FileChooserBuilder("h");
192	assertNotNull(instance.createFileChooser());
193	}
194
195	public void testSetSelectionApprover() throws Exception {
196	FileChooserBuilder instance = new FileChooserBuilder("i");
197	File tmp = new File(System.getProperty("java.io.tmpdir"));
198	assertTrue ("Environment is insane", tmp.exists() && tmp.isDirectory());
199	File sel = new File("tmp" + System.currentTimeMillis());
200	if (!sel.exists()) {
201	assertTrue (sel.createNewFile());
202	}
203	instance.setDefaultWorkingDirectory(tmp);
204	SA sa = new SA();
205	instance.setSelectionApprover(sa);
206	JFileChooser ch = instance.createFileChooser();
207	ch.setSelectedFile(sel);
208	ch.approveSelection();
209	sa.assertApproveInvoked(sel);
210	}
211
212	public void testAddFileFilter() {
213	FileChooserBuilder instance = new FileChooserBuilder("j");
214	FF one = new FF ("a");
215	FF two = new FF ("b");
216	instance.addFileFilter(one);
217	instance.addFileFilter(two);
218	JFileChooser ch = instance.createFileChooser();
219	Set<FileFilter> ff = new HashSet<FileFilter>(Arrays.asList(one, two));
220	Set<FileFilter> actual = new HashSet<FileFilter>(Arrays.asList(ch.getChoosableFileFilters()));
221	assertTrue (actual.containsAll(ff));
222	//actual should also contain JFileChooser.getAcceptAllFileFilter()
223	assertEquals (ff.size() + 1, actual.size());
224	}
225
226	public void testSetAcceptAllFileFilterUsed() {
227	FileChooserBuilder instance = new FileChooserBuilder("k");
228	assertTrue(instance.createFileChooser().isAcceptAllFileFilterUsed());
229	instance.setAcceptAllFileFilterUsed(false);
230	assertFalse(instance.createFileChooser().isAcceptAllFileFilterUsed());
231	}
232
233	private static final class FF extends FileFilter {
234	private String x;
235	FF(String x) {
236	this.x = x;
237	}
238
239	@Override
240	public boolean accept(File f) {
241	return f.getName().endsWith(x);
242	}
243
244	@Override
245	public String getDescription() {
246	return x;
247	}
248
249	}
250
251	private static final class SA implements FileChooserBuilder.SelectionApprover {
252	private File[] selection;
253	@Override
254	public boolean approve(File[] selection) {
255	this.selection = selection;
256	return true;
257	}
258
259	void assertApproveInvoked(File selected) {
260	assertNotNull ("approve method called", selection);
261	assertEquals("One selected file", 1, selection.length);
262	assertEquals("It is the one", selected, selection[0]);
263	}
264	}
265
266	private static AbstractButton findDefaultButton(Container c, String txt) {
267	if (c instanceof RootPaneContainer) {
268	JRootPane root = ((RootPaneContainer) c).getRootPane();
269	if (root == null) {
270	return null;
271	}
272	AbstractButton btn = root.getDefaultButton();
273	if (btn == null) {
274	//Metal L&F does not set default button for JFileChooser
275	Container parent = c;
276	while (parent.getParent() != null && !(parent instanceof Dialog)) {
277	parent = parent.getParent();
278	}
279	if (parent instanceof Dialog) {
280	return findFileChooserAcceptButton ((Dialog) parent, txt);
281	}
282	} else {
283	return btn;
284	}
285	}
286	return null;
287	}
288
289	private static AbstractButton findFileChooserAcceptButton(Dialog dlg, String txt) {
290	for (Component c : dlg.getComponents()) {
291	if (c instanceof Container) {
292	AbstractButton result = scanForButton((Container) c, txt);
293	if (result != null) {
294	return result;
295	}
296	}
297	}
298	return null;
299	}
300
301	private static AbstractButton scanForButton(Container container, String txt) {
302	assertNotNull (container);
303	assertNotNull (txt);
304	if (container instanceof AbstractButton) {
305	if (txt.equals(((AbstractButton) container).getText())) {
306	return ((AbstractButton) container);
307	}
308	} else {
309	for (Component c : container.getComponents()) {
310	if (c instanceof Container) {
311	AbstractButton b = scanForButton ((Container) c, txt);
312	if (b != null) {
313	return b;
314	}
315	}
316	}
317	}
318	return null;
319	}
320
321	@RandomlyFails // NB-Core-Build #8038: Button is visible
322	public void testForceUseOfDefaultWorkingDirectory() throws InterruptedException, IOException, InvocationTargetException, UnsupportedLookAndFeelException {
323	UIManager.setLookAndFeel(new MetalLookAndFeel());
324	FileChooserBuilder instance = new FileChooserBuilder("i").setApproveText("__OK");
325	instance.setDirectoriesOnly(true);
326	final File toDir = getWorkDir();
327	final File selDir = new File(toDir, "sel" + System.currentTimeMillis());
328	if (!selDir.exists()) {
329	assertTrue(selDir.mkdirs());
330	}
331
332	final JFileChooser ch = instance.createFileChooser();
333	assertEquals ("__OK", ch.getApproveButtonText());
334	final CountDownLatch showLatch = new CountDownLatch(1);
335	ch.addAncestorListener (new AncestorListener() {
336
337	@Override
338	public void ancestorAdded(AncestorEvent event) {
339	if (ch.isShowing()) {
340	ch.removeAncestorListener(this);
341	showLatch.countDown();
342	}
343	}
344
345	@Override
346	public void ancestorRemoved(AncestorEvent event) {
347
348	}
349
350	@Override
351	public void ancestorMoved(AncestorEvent event) {
352
353	}
354
355	});
356
357	final AtomicReference<Object> chooserRes = new AtomicReference<Object>();
358	RequestProcessor.Task task = RequestProcessor.getDefault().post(new Runnable() {
359
360	@Override
361	public void run() {
362	Object r = ch.showOpenDialog(null);
363	chooserRes.set(r);
364	}
365
366	});
367
368
369	showLatch.await();
370	EventQueue.invokeAndWait (new Runnable() {
371	@Override
372	public void run() {
373	ch.setCurrentDirectory(toDir);
374	}
375	});
376	EventQueue.invokeAndWait (new Runnable() {
377	@Override
378	public void run() {
379	ch.setSelectedFile (selDir);
380	}
381	});
382	assertTrue ("Button is visible: " + ch, ch.isShowing());
383	final AtomicReference<AbstractButton> btn = new AtomicReference<AbstractButton>();
384	EventQueue.invokeAndWait(new Runnable() {
385
386	@Override
387	public void run() {
388	AbstractButton defButton = findDefaultButton(ch.getTopLevelAncestor(), ch.getApproveButtonText());
389	btn.set(defButton);
390	}
391
392	});
393	assertNotNull("have a button", btn.get());
394	assertTrue(btn.get().isEnabled());
395	EventQueue.invokeAndWait(new Runnable() {
396	@Override
397	public void run() {
398	AbstractButton defButton = btn.get();
399	defButton.doClick();
400	}
401	});
402
403	task.waitFinished();
404	assertEquals(JFileChooser.APPROVE_OPTION, chooserRes.get());
405
406	assertEquals(toDir, ch.getCurrentDirectory());
407
408	instance = new FileChooserBuilder("i");
409	assertEquals("Directory not retained", toDir, instance.createFileChooser().getCurrentDirectory());
410
411	File userHome = new File(System.getProperty("user.home"));
412	assertTrue("Environment not sane", userHome.exists() && userHome.isDirectory());
413	instance.forceUseOfDefaultWorkingDirectory(true).setDefaultWorkingDirectory(userHome);
414
415	assertEquals(userHome, instance.createFileChooser().getCurrentDirectory());
416	}
417	}

Lines 49-54 Link Here

(-)a/openide.filesystems/apichanges.xml (+75 lines)
49	<apidef name="filesystems">Filesystems API</apidef>	49	<apidef name="filesystems">Filesystems API</apidef>
50	</apidefs>	50	</apidefs>
51	<changes>	51	<changes>
		52	<change id="FileSystemStatus.icons">
		53	<api name="filesystems"/>
		54	<summary>FileSystem.Status icon annotation moved</summary>
		55	<version major="9" minor="0"/>
		56	<date year="2014" month="4" day="11"/>
		57	<author login="sdedic"/>
		58	<compatibility modification="yes" addition="yes" binary="compatible" source="compatible" semantic="incompatible"/>
		59	<description>
		60	<p>
		61	The default implementation of FileSystem.Status annotated file's icon using ImageUtilities
		62	which uses AWT graphics etc. Such dependency is not desirable in a standalone FileSystem API
		63	library.
		64	</p>
		65	<p>
		66	The builtin implementation now does not work with the icon at all and returns null. A proper
		67	implementation for FileSystem.Status is looked up in default Lookup and is implemented
		68	properly (with Icon annotations) in <code>openide.filesystems.nb</code> module.
		69	</p>
		70	</description>
		71	<issue number="243561"/>
		72	</change>
		73	<change id="SharedClassObject.separate">
		74	<api name="filesystems"/>
		75	<summary>Removed dependency on SharedClassObject</summary>
		76	<version major="9" minor="0"/>
		77	<date year="2014" month="4" day="11"/>
		78	<author login="sdedic"/>
		79	<compatibility modification="yes" addition="yes" binary="compatible" source="compatible" semantic="incompatible"/>
		80	<description>
		81	<p>
		82	If the FileSystems API encounters a <a href="@openide-util@/org/openide/util/SharedClassObject.html#find">SharedClassObject</a> subclass in the <code>instanceClass</code> attribute,
		83	or derives the subclass from FileObject's name, it does not create the instance using the default
		84	constructor, but rather using <a href="@openide-util@/org/openide/util/SharedClassObject.html#find">SharedClassObject.find</a>
		85	method.
		86	The <code>SharedClassObject</code> is long deprecated and adds unwanted dependency on desktop
		87	utilities to FileSystems API.
		88	</p>
		89	<p>
		90	A new SPI, <a href="@TOP@/org/openide/filesystems/spi/CustomInstanceFactory.html">CustomInstanceFactory</a> is created
		91	to create instances based on the type. The instance is searched for in the default Lookup.
		92	The NetBeans Platform will provide an implementation that handles <code>SharedClassObjects</code>,
		93	but FileSystems API library no longer implements that behaviour. A compatible implementation
		94	of <code>CustomInstanceFactory</code> is provided by the <code>openide.filesystems.nb</code>
		95	module.
		96	</p>
		97	</description>
		98	<issue number="243561"/>
		99	</change>
		100	<change id="RemoveDeprecatedAndObsolete.8">
		101	<api name="filesystems"/>
		102	<summary>Remove dependency on Swing (SystemAction) and obsolete APIs</summary>
		103	<version major="9" minor="0"/>
		104	<date year="2014" month="4" day="11"/>
		105	<author login="sdedic"/>
		106	<compatibility modification="yes" binary="compatible" source="incompatible" deletion="yes" semantic="compatible"/>
		107	<description>
		108	<p>
		109	The primary goal of the change is to remove dependencies on Swing APIs - FileSystems should not depend
		110	or directly use <code>SystemAction</code> extends <code>javax.swing.Action</code>. At the same time,
		111	methods or classes which are long @deprecated and have no semantic value are removed from the APIs.
		112	</p>
		113	<p>
		114	The changes are binary-compatible; a compatibility module is created as <code>org.openide.filesystems.compat8</code>.
		115	Live code (<a href="@openide-filesystems-compat8@/org/openide/filesystems/FileChooserBuilder.html">FileChooserBuilder</a>
116	is moved to a new module <code>org.openide.filesystems.nb</code> with automatic dependency in place for client which
117	use filesystems in their old API version.
118	</p>
119	<p>
120	It's strongly discouraged to compile against the <code>compat8</code> module. Its contents will be maintained only to
121	ensure binary compatibility with FileSystems API 8.x, API users should not rely on any contract exposed directly by the compat8
122	module.
123	</p>
124	</description>
125	<issue number="243561"/>
126	</change>
52	<change id="MultiFileObject.revealEntriesAttribute">	127	<change id="MultiFileObject.revealEntriesAttribute">
53	<api name="filesystems"/>	128	<api name="filesystems"/>
54	<summary>Allowed to reveal deleted files, or original files overriden by writable layer</summary>	129	<summary>Allowed to reveal deleted files, or original files overriden by writable layer</summary>

Lines 544-550 Link Here

(-)a/openide.filesystems/arch.xml (-2 / +10 lines)
544	</question>	544	</question>
545	-->	545	-->
546	<answer id="lookup-lookup">	546	<answer id="lookup-lookup">
547	Implementations of MIMEResolver and URLMapper are looked up .	547	The following services are looked up:
		548	<ul>
		549	<li>Implementations of MIMEResolver and URLMapper are looked up</li>
		550	<li>instance of <a href="@TOP@/org/openide/filesystems/FileSystem.Status.html">FileSystem.Status</a> which is
		551	used as the Status of the <b>default</b> FileSystem</li>
		552	<li>instance of <a href="@TOP@/org/openide/filesystems/spi/CustomInstanceFactory.html">CustomInstanceFactory</a>
		553	which is used to create instances for FileSystem files without <code>instanceCreate</code> attribute</li>
		554	</ul>
548	</answer>	555	</answer>
549		556
550		557
Lines 560-566 Link Here
560	</question>	567	</question>
561	-->	568	-->
562	<answer id="lookup-register">	569	<answer id="lookup-register">
563	No	570	<code>URLStreamHandlerFactory</code> implementations for <b>nbfs:</b> and
		571	<b>memory:</b> protocols are registered as named services.
564	</answer>	572	</answer>
565		573
566		574

Lines 61-64 Link Here

(-)a/openide.filesystems/module-auto-deps.xml (+15 lines)
61	</transformation>	61	</transformation>
62	</transformationgroup>	62	</transformationgroup>
63		63
		64	<transformationgroup>
		65	<description>Separation of desktop and cleanup</description>
		66	<transformation>
		67	<trigger-dependency type="older">
		68	<module-dependency codenamebase="org.openide.filesystems" spec="9.0"/>
		69	</trigger-dependency>
		70	<implies>
		71	<result>
		72	<module-dependency codenamebase="org.openide.filesystems.nb"/>
		73	<module-dependency codenamebase="org.openide.filesystems.compat8"/>
		74	</result>
		75	</implies>
		76	</transformation>
		77	</transformationgroup>
		78
64	</transformations>	79	</transformations>

Lines 50-63 Link Here

(-)a/openide.filesystems/nbproject/project.xml (-9 / +7 lines)
50	<code-name-base>org.openide.filesystems</code-name-base>	50	<code-name-base>org.openide.filesystems</code-name-base>
51	<module-dependencies>	51	<module-dependencies>
52	<dependency>	52	<dependency>
53	<code-name-base>org.openide.util</code-name-base>
54	<build-prerequisite/>
55	<compile-dependency/>
56	<run-dependency>
57	<specification-version>9.0</specification-version>
58	</run-dependency>
59	</dependency>
60	<dependency>
61	<code-name-base>org.openide.util.base</code-name-base>	53	<code-name-base>org.openide.util.base</code-name-base>
62	<build-prerequisite/>	54	<build-prerequisite/>
63	<compile-dependency/>	55	<compile-dependency/>
Lines 91-98 Link Here
91	<recursive/>	83	<recursive/>
92	<compile-dependency/>	84	<compile-dependency/>
93	</test-dependency>	85	</test-dependency>
		86	<!-- <test-dependency>
		87	<code-name-base>org.openide.util</code-name-base>
		88	<compile-dependency/>
		89	<test/>
		90	</test-dependency>-->
94	<test-dependency>	91	<test-dependency>
95	<code-name-base>org.openide.util</code-name-base>	92	<code-name-base>org.openide.util.base</code-name-base>
96	<compile-dependency/>	93	<compile-dependency/>
97	<test/>	94	<test/>
98	</test-dependency>	95	</test-dependency>
Lines 106-111 Link Here
106	<public-packages>	103	<public-packages>
107	<package>org.openide.filesystems</package>	104	<package>org.openide.filesystems</package>
108	<package>org.openide.filesystems.annotations</package>	105	<package>org.openide.filesystems.annotations</package>
		106	<package>org.openide.filesystems.spi</package>
109	</public-packages>	107	</public-packages>
110	</data>	108	</data>
111	</configuration>	109	</configuration>

Lines 30-42 Link Here

(-)a/openide.filesystems/src/org/netbeans/modules/openide/filesystems/RecognizeInstanceFiles.java (-9 / +71 lines)
30	* Software is Sun Microsystems, Inc.	30	* Software is Sun Microsystems, Inc.
31	*	31	*
32	* Portions Copyrighted 2007 Sun Microsystems, Inc.	32	* Portions Copyrighted 2007 Sun Microsystems, Inc.
		33	//
		34	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		35	*
		36	* Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
		37	*
		38	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		39	* Other names may be trademarks of their respective owners.
		40	*
		41	* The contents of this file are subject to the terms of either the GNU
		42	* General Public License Version 2 only ("GPL") or the Common
		43	* Development and Distribution License("CDDL") (collectively, the
		44	* "License"). You may not use this file except in compliance with the
		45	* License. You can obtain a copy of the License at
		46	* http://www.netbeans.org/cddl-gplv2.html
		47	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		48	* specific language governing permissions and limitations under the
		49	* License. When distributing the software, include this License Header
		50	* Notice in each file and include the License file at
		51	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		52	* particular file as subject to the "Classpath" exception as provided
		53	* by Oracle in the GPL Version 2 section of the License file that
		54	* accompanied this code. If applicable, add the following below the
		55	* License Header, with the fields enclosed by brackets [] replaced by
		56	* your own identifying information:
		57	* "Portions Copyrighted [year] [name of copyright owner]"
		58	*
		59	* Contributor(s):
		60	*
		61	* The Original Software is NetBeans. The Initial Developer of the Original
		62	* Software is Sun Microsystems, Inc.
		63	*
		64	* Portions Copyrighted 2007 Sun Microsystems, Inc.
33	*/	65	*/
34		66
35	package org.netbeans.modules.openide.filesystems;	67	package org.netbeans.modules.openide.filesystems;
36		68
37	import java.lang.ref.Reference;	69	import java.lang.ref.Reference;
38	import java.lang.ref.WeakReference;	70	import java.lang.ref.WeakReference;
		71	import java.lang.reflect.Constructor;
		72	import java.lang.reflect.InvocationTargetException;
39	import java.util.ArrayList;	73	import java.util.ArrayList;
		74	import java.util.Collection;
40	import java.util.Collections;	75	import java.util.Collections;
41	import java.util.Enumeration;	76	import java.util.Enumeration;
42	import java.util.LinkedHashMap;	77	import java.util.LinkedHashMap;
Lines 53-62 Link Here
53	import org.openide.filesystems.FileStateInvalidException;	88	import org.openide.filesystems.FileStateInvalidException;
54	import org.openide.filesystems.FileSystem;	89	import org.openide.filesystems.FileSystem;
55	import org.openide.filesystems.FileUtil;	90	import org.openide.filesystems.FileUtil;
		91	import org.openide.filesystems.spi.CustomInstanceFactory;
		92	import org.openide.util.BaseUtilities;
56	import org.openide.util.Exceptions;	93	import org.openide.util.Exceptions;
57	import org.openide.util.Lookup;	94	import org.openide.util.Lookup;
58	import org.openide.util.SharedClassObject;
59	import org.openide.util.Utilities;
60	import org.openide.util.lookup.AbstractLookup;	95	import org.openide.util.lookup.AbstractLookup;
61	import org.openide.util.lookup.Lookups;	96	import org.openide.util.lookup.Lookups;
62	import org.openide.util.lookup.ProxyLookup;	97	import org.openide.util.lookup.ProxyLookup;
Lines 200-205 Link Here
200	}	235	}
201	} // end of OverFiles	236	} // end of OverFiles
202		237
		238	private static volatile Lookup.Result<CustomInstanceFactory> factories;
		239
		240	private static Collection<? extends CustomInstanceFactory> getInstanceFactories() {
		241	Lookup.Result<CustomInstanceFactory> fr;
		242
		243	if ((fr = factories) == null) {
		244	factories = fr = Lookup.getDefault().lookupResult(CustomInstanceFactory.class);
		245	}
		246	return fr.allInstances();
		247	}
		248
		249	public static final <T> T createInstance(Class<T> type) throws InstantiationException,
		250	IllegalAccessException, InvocationTargetException, NoSuchMethodException {
		251	T r = null;
		252	for (CustomInstanceFactory fif : getInstanceFactories()) {
		253	r = (T)fif.createInstance(type);
		254	if (r != null) {
		255	break;
		256	}
		257	}
		258	if (r == null) {
		259	Constructor<T> init = type.getDeclaredConstructor();
		260	init.setAccessible(true);
		261	r = init.newInstance();
		262	}
		263	return r;
		264	}
203		265
204	private static final class FOItem extends AbstractLookup.Pair<Object> {	266	private static final class FOItem extends AbstractLookup.Pair<Object> {
205	private static Reference<Object> EMPTY = new WeakReference<Object>(null);	267	private static Reference<Object> EMPTY = new WeakReference<Object>(null);
Lines 257-271 Link Here
257	if (type == null) {	319	if (type == null) {
258	return null;	320	return null;
259	}	321	}
260	if (SharedClassObject.class.isAssignableFrom(type)) {	322	r = createInstance(type);
261	r = SharedClassObject.findObject(type.asSubclass(SharedClassObject.class), true);
262	} else {
263	r = type.newInstance();
264	}
265	} catch (InstantiationException ex) {	323	} catch (InstantiationException ex) {
266	Exceptions.printStackTrace(ex);	324	Exceptions.printStackTrace(ex);
267	} catch (IllegalAccessException ex) {	325	} catch (IllegalAccessException ex) {
268	Exceptions.printStackTrace(ex);	326	Exceptions.printStackTrace(ex);
		327	} catch (InvocationTargetException ex) {
		328	Exceptions.printStackTrace(ex);
		329	} catch (NoSuchMethodException ex) {
		330	Exceptions.printStackTrace(ex);
269	}	331	}
270	}	332	}
271	return resultType.isInstance(r) ? resultType.cast(r) : null;	333	return resultType.isInstance(r) ? resultType.cast(r) : null;
Lines 312-318 Link Here
312	// first of all try "instanceClass" property of the primary file	374	// first of all try "instanceClass" property of the primary file
313	Object attr = fo.getAttribute ("instanceClass");	375	Object attr = fo.getAttribute ("instanceClass");
314	if (attr instanceof String) {	376	if (attr instanceof String) {
315	return Utilities.translate((String) attr);	377	return BaseUtilities.translate((String) attr);
316	} else if (attr != null) {	378	} else if (attr != null) {
317	LOG.warning(	379	LOG.warning(
318	"instanceClass was a " + attr.getClass().getName()); // NOI18N	380	"instanceClass was a " + attr.getClass().getName()); // NOI18N
Lines 350-356 Link Here
350	}	412	}
351		413
352	name = name.replace ('-', '.');	414	name = name.replace ('-', '.');
353	name = Utilities.translate(name);	415	name = BaseUtilities.translate(name);
354		416
355	//System.out.println ("Original: " + getPrimaryFile ().getName () + " new one: " + name); // NOI18N	417	//System.out.println ("Original: " + getPrimaryFile ().getName () + " new one: " + name); // NOI18N
356	return name;	418	return name;

Lines 1233-1276 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/AbstractFileObject.java (-40 lines)
1233	}	1233	}
1234	}	1234	}
1235	// end of Invalid	1235	// end of Invalid
1236
1237	/** Replace that stores name of fs and file.
1238	* @deprecated In favor of AbstractFolder.Replace.
1239	*/
1240	@Deprecated
1241	static final class Replace extends Object implements Serializable {
1242	/** generated Serialized Version UID */
1243	static final long serialVersionUID = -8543432135435542113L;
1244	private String fsName;
1245	private String fileName;
1246
1247	/** Constructor
1248	*/
1249	public Replace(String fsName, String fileName) {
1250	this.fsName = fsName;
1251	this.fileName = fileName;
1252	}
1253
1254	/** Finds the right file.
1255	*/
1256	public Object readResolve() {
1257	Repository rep = Repository.getDefault();
1258	@SuppressWarnings("deprecation") // FileSystem.systemName historical part of serial form
1259	FileSystem fs = rep.findFileSystem(fsName);
1260	FileObject fo = null;
1261
1262	if (fs != null) {
1263	// scan desired system
1264	fo = fs.findResource(fileName);
1265	}
1266
1267	if (fo == null) {
1268	// create invalid file instead
1269	return new Invalid(fsName, fileName);
1270	}
1271
1272	return fo;
1273	}
1274	}
1275	// end of Replace
1276	}	1236	}

Lines 57-67 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/AbstractFileSystem.java (-75 lines)
57	import java.util.Date;	57	import java.util.Date;
58	import java.util.Enumeration;	58	import java.util.Enumeration;
59	import java.util.StringTokenizer;	59	import java.util.StringTokenizer;
60	import org.openide.util.Enumerations;
61	import org.openide.util.Lookup;
62	import org.openide.util.NbCollections;	60	import org.openide.util.NbCollections;
63	import org.openide.util.SharedClassObject;
64	import org.openide.util.actions.SystemAction;
65		61
66	/**	62	/**
67	* This convenience implementation does much of the hard work of	63	* This convenience implementation does much of the hard work of
Lines 126-137 Link Here
126	/** generated Serialized Version UID */	122	/** generated Serialized Version UID */
127	private static final long serialVersionUID = -3345098214331282438L;	123	private static final long serialVersionUID = -3345098214331282438L;
128		124
129	/** system actions for this FS if it has refreshTime != 0 */
130	private static SystemAction[] SYSTEM_ACTIONS;
131
132	/** system actions for this FS */
133	private static final SystemAction[] NO_SYSTEM_ACTIONS = new SystemAction[] { };
134
135	/** cached last value of Enumeration which holds resource name (enumeration like StringTokenizer)*/	125	/** cached last value of Enumeration which holds resource name (enumeration like StringTokenizer)*/
136	static transient private PathElements lastEnum;	126	static transient private PathElements lastEnum;
137		127
Lines 181-218 Link Here
181	return getAbstractRoot();	171	return getAbstractRoot();
182	}	172	}
183		173
184	/* Finds file when its name is provided.
185	*
186	* @param aPackage package name where each package is separated by a dot
187	* @param name name of the file (without dots) or <CODE>null</CODE> if
188	* one want to obtain name of package and not file in it
189	* @param ext extension of the file or <CODE>null</CODE> if one needs
190	* package and not file name
191	*
192	* @warning when one of name or ext is <CODE>null</CODE> then name and
193	* ext should be ignored and scan should look only for a package
194	*
195	* @return FileObject that represents file with given name or
196	* <CODE>null</CODE> if the file does not exist
197	*/
198	@Deprecated
199	public FileObject find(String aPackage, String name, String ext) {
200	// create enumeration of name to look for
201	Enumeration<String> st = NbCollections.checkedEnumerationByFilter(new StringTokenizer(aPackage, "."), String.class, true); // NOI18N
202
203	if ((name == null) \|\| (ext == null)) {
204	// search for folder, return the object only if it is folder
205	FileObject fo = getAbstractRoot().find(st);
206
207	return ((fo != null) && fo.isFolder()) ? fo : null;
208	} else {
209	Enumeration<String> en = Enumerations.concat(st, Enumerations.singleton(name + '.' + ext));
210
211	// tries to find it (can return null)
212	return getAbstractRoot().find(en);
213	}
214	}
215
216	/* Finds file when its resource name is given.	174	/* Finds file when its resource name is given.
217	* The name has the usual format for the {@link ClassLoader#getResource(String)}	175	* The name has the usual format for the {@link ClassLoader#getResource(String)}
218	* method. So it may consist of "package1/package2/filename.ext".	176	* method. So it may consist of "package1/package2/filename.ext".
Lines 270-308 Link Here
270	return (refresher != null);	228	return (refresher != null);
271	}	229	}
272		230
273	/* Action for this filesystem.
274	*
275	* @return refresh action
276	*/
277	public SystemAction[] getActions() {
278	if (!isEnabledRefreshFolder()) {
279	return NO_SYSTEM_ACTIONS;
280	} else {
281	if (SYSTEM_ACTIONS == null) {
282	try {
283	ClassLoader l = Lookup.getDefault().lookup(ClassLoader.class);
284
285	if (l == null) {
286	l = getClass().getClassLoader();
287	}
288
289	Class<?> c = Class.forName("org.openide.actions.FileSystemRefreshAction", true, l); // NOI18N
290	SystemAction ra = SharedClassObject.findObject(c.asSubclass(SystemAction.class), true);
291
292	// initialize the SYSTEM_ACTIONS
293	SYSTEM_ACTIONS = new SystemAction[] { ra };
294	} catch (Exception ex) {
295	// ok, we are probably running in standalone mode and
296	// classes needed to initialize the RefreshAction are
297	// not available
298	SYSTEM_ACTIONS = NO_SYSTEM_ACTIONS;
299	}
300	}
301
302	return SYSTEM_ACTIONS;
303	}
304	}
305
306	/** Set the number of milliseconds between automatic	231	/** Set the number of milliseconds between automatic
307	* refreshes of the directory structure.	232	* refreshes of the directory structure.
308	*	233	*

Lines 73-79 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/DefaultAttributes.java (-3 / +3 lines)
73	import javax.xml.parsers.ParserConfigurationException;	73	import javax.xml.parsers.ParserConfigurationException;
74	import org.openide.util.Enumerations;	74	import org.openide.util.Enumerations;
75	import org.openide.util.NbBundle;	75	import org.openide.util.NbBundle;
76	import org.openide.util.Utilities;	76	import org.openide.util.BaseUtilities;
77	import org.openide.util.io.NbMarshalledObject;	77	import org.openide.util.io.NbMarshalledObject;
78	import org.openide.xml.XMLUtil;	78	import org.openide.xml.XMLUtil;
79	import org.xml.sax.Attributes;	79	import org.xml.sax.Attributes;
Lines 238-244 Link Here
238	// However, OpenVMS now supports a file name beginning with "."	238	// However, OpenVMS now supports a file name beginning with "."
239	// So we now have to copy the existing "_nbattrs." file into ".nbattrs"	239	// So we now have to copy the existing "_nbattrs." file into ".nbattrs"
240	//	240	//
241	if ((Utilities.getOperatingSystem() == Utilities.OS_VMS) && (arr[0] != null) && (f != null)) {	241	if ((BaseUtilities.getOperatingSystem() == BaseUtilities.OS_VMS) && (arr[0] != null) && (f != null)) {
242	if (arr[0].equalsIgnoreCase("_nbattrs.")) {	242	if (arr[0].equalsIgnoreCase("_nbattrs.")) {
243	try {	243	try {
244	deleteFile(f + "/" + arr[0]); // NOI18N	244	deleteFile(f + "/" + arr[0]); // NOI18N
Lines 264-270 Link Here
264	// However, OpenVMS now supports a file name beginning with "."	264	// However, OpenVMS now supports a file name beginning with "."
265	// So we now have to copy the existing "_nbattrs." file into ".nbattrs"	265	// So we now have to copy the existing "_nbattrs." file into ".nbattrs"
266	//	266	//
267	if ((Utilities.getOperatingSystem() == Utilities.OS_VMS) && (arr[i] != null) && (f != null)) {	267	if ((BaseUtilities.getOperatingSystem() == BaseUtilities.OS_VMS) && (arr[i] != null) && (f != null)) {
268	if (arr[i].equalsIgnoreCase("_nbattrs.")) {	268	if (arr[i].equalsIgnoreCase("_nbattrs.")) {
269	try {	269	try {
270	File fp = new File(f + "/" + ".nbattrs");	270	File fp = new File(f + "/" + ".nbattrs");

Lines 84-99 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/FileUtil.java (-137 / +17 lines)
84	import java.util.jar.JarInputStream;	84	import java.util.jar.JarInputStream;
85	import java.util.logging.Level;	85	import java.util.logging.Level;
86	import java.util.logging.Logger;	86	import java.util.logging.Logger;
87	import javax.swing.Icon;
88	import javax.swing.JFileChooser;
89	import javax.swing.filechooser.FileSystemView;
90	import org.netbeans.modules.openide.filesystems.declmime.MIMEResolverImpl;	87	import org.netbeans.modules.openide.filesystems.declmime.MIMEResolverImpl;
91	import org.openide.filesystems.FileSystem.AtomicAction;	88	import org.openide.filesystems.FileSystem.AtomicAction;
92	import org.openide.util.Exceptions;	89	import org.openide.util.Exceptions;
93	import org.openide.util.NbBundle;	90	import org.openide.util.NbBundle;
94	import org.openide.util.Parameters;	91	import org.openide.util.Parameters;
95	import org.openide.util.RequestProcessor;	92	import org.openide.util.RequestProcessor;
96	import org.openide.util.Utilities;	93	import org.openide.util.BaseUtilities;
97	import org.openide.util.WeakListeners;	94	import org.openide.util.WeakListeners;
98	import org.openide.util.lookup.implspi.NamedServicesProvider;	95	import org.openide.util.lookup.implspi.NamedServicesProvider;
99		96
Lines 835-844 Link Here
835	}	832	}
836		833
837	if ((fileURL != null) && "file".equals(fileURL.getProtocol())) {	834	if ((fileURL != null) && "file".equals(fileURL.getProtocol())) {
838	retVal = Utilities.toFile(URI.create(fileURL.toExternalForm()));	835	retVal = BaseUtilities.toFile(URI.create(fileURL.toExternalForm()));
839	}	836	}
840	}	837	}
841	assert assertNormalized(retVal, Utilities.isMac()); // #240180	838	assert assertNormalized(retVal, BaseUtilities.isMac()); // #240180
842	return retVal;	839	return retVal;
843	}	840	}
844		841
Lines 885-891 Link Here
885		882
886	FileObject retVal = null;	883	FileObject retVal = null;
887	try {	884	try {
888	URL url = Utilities.toURI(file).toURL();	885	URL url = BaseUtilities.toURI(file).toURL();
889	retVal = URLMapper.findFileObject(url);	886	retVal = URLMapper.findFileObject(url);
890		887
891	/probably temporary piece of code to catch the cause of #46630/	888	/probably temporary piece of code to catch the cause of #46630/
Lines 928-934 Link Here
928	}	925	}
929		926
930	try {	927	try {
931	URL url = (Utilities.toURI(file).toURL());	928	URL url = (BaseUtilities.toURI(file).toURL());
932	retVal = URLMapper.findFileObjects(url);	929	retVal = URLMapper.findFileObjects(url);
933	} catch (MalformedURLException e) {	930	} catch (MalformedURLException e) {
934	retVal = null;	931	retVal = null;
Lines 1212-1218 Link Here
1212	* @return true, if such name does not exists	1209	* @return true, if such name does not exists
1213	*/	1210	*/
1214	private static boolean checkFreeName(FileObject fo, String name, String ext) {	1211	private static boolean checkFreeName(FileObject fo, String name, String ext) {
1215	if ((Utilities.isWindows() \|\| (Utilities.getOperatingSystem() == Utilities.OS_OS2)) \|\| Utilities.isMac()) {	1212	if ((BaseUtilities.isWindows() \|\| (BaseUtilities.getOperatingSystem() == BaseUtilities.OS_OS2)) \|\| BaseUtilities.isMac()) {
1216	// case-insensitive, do some special check	1213	// case-insensitive, do some special check
1217	Enumeration<? extends FileObject> en = fo.getChildren(false);	1214	Enumeration<? extends FileObject> en = fo.getChildren(false);
1218		1215
Lines 1607-1615 Link Here
1607	LOG.log(Level.FINE, "FileUtil.normalizeFile for {0}", file); // NOI18N	1604	LOG.log(Level.FINE, "FileUtil.normalizeFile for {0}", file); // NOI18N
1608		1605
1609	long now = System.currentTimeMillis();	1606	long now = System.currentTimeMillis();
1610	if ((Utilities.isWindows() \|\| (Utilities.getOperatingSystem() == Utilities.OS_OS2))) {	1607	if ((BaseUtilities.isWindows() \|\| (BaseUtilities.getOperatingSystem() == BaseUtilities.OS_OS2))) {
1611	retFile = normalizeFileOnWindows(file);	1608	retFile = normalizeFileOnWindows(file);
1612	} else if (Utilities.isMac()) {	1609	} else if (BaseUtilities.isMac()) {
1613	retFile = normalizeFileOnMac(file);	1610	retFile = normalizeFileOnMac(file);
1614	} else {	1611	} else {
1615	retFile = normalizeFileOnUnixAlike(file);	1612	retFile = normalizeFileOnUnixAlike(file);
Lines 1625-1631 Link Here
1625	private static File normalizeFileOnUnixAlike(File file) {	1622	private static File normalizeFileOnUnixAlike(File file) {
1626	// On Unix, do not want to traverse symlinks.	1623	// On Unix, do not want to traverse symlinks.
1627	// URI.normalize removes ../ and ./ sequences nicely.	1624	// URI.normalize removes ../ and ./ sequences nicely.
1628	file = Utilities.toFile(Utilities.toURI(file).normalize()).getAbsoluteFile();	1625	file = BaseUtilities.toFile(BaseUtilities.toURI(file).normalize()).getAbsoluteFile();
1629	while (file.getAbsolutePath().startsWith("/../")) { // NOI18N	1626	while (file.getAbsolutePath().startsWith("/../")) { // NOI18N
1630	file = new File(file.getAbsolutePath().substring(3));	1627	file = new File(file.getAbsolutePath().substring(3));
1631	}	1628	}
Lines 1641-1647 Link Here
1641		1638
1642	try {	1639	try {
1643	// URI.normalize removes ../ and ./ sequences nicely.	1640	// URI.normalize removes ../ and ./ sequences nicely.
1644	File absoluteFile = Utilities.toFile(Utilities.toURI(file).normalize());	1641	File absoluteFile = BaseUtilities.toFile(BaseUtilities.toURI(file).normalize());
1645	File canonicalFile = file.getCanonicalFile();	1642	File canonicalFile = file.getCanonicalFile();
1646	String absolutePath = absoluteFile.getAbsolutePath();	1643	String absolutePath = absoluteFile.getAbsolutePath();
1647	if (absolutePath.equals("/..")) { // NOI18N	1644	if (absolutePath.equals("/..")) { // NOI18N
Lines 1738-1744 Link Here
1738	}	1735	}
1739	}	1736	}
1740	// #135547 - on Windows Vista map "Documents and Settings\<username>\My Documents" to "Users\<username>\Documents"	1737	// #135547 - on Windows Vista map "Documents and Settings\<username>\My Documents" to "Users\<username>\Documents"
1741	if((Utilities.getOperatingSystem() & Utilities.OS_WINVISTA) != 0) {	1738	if((BaseUtilities.getOperatingSystem() & BaseUtilities.OS_WINVISTA) != 0) {
1742	if(retVal == null) {	1739	if(retVal == null) {
1743	retVal = file.getAbsoluteFile();	1740	retVal = file.getAbsoluteFile();
1744	}	1741	}
Lines 1987-1993 Link Here
1987	do {	1984	do {
1988	wasDir = entry.isDirectory();	1985	wasDir = entry.isDirectory();
1989	LOG.finest("urlForArchiveOrDir:toURI:entry"); //NOI18N	1986	LOG.finest("urlForArchiveOrDir:toURI:entry"); //NOI18N
1990	u = Utilities.toURI(entry).toURL();	1987	u = BaseUtilities.toURI(entry).toURL();
1991	isDir = entry.isDirectory();	1988	isDir = entry.isDirectory();
1992	} while (wasDir ^ isDir);	1989	} while (wasDir ^ isDir);
1993	if (isArchiveFile(u) \|\| entry.isFile() && entry.length() < 4) {	1990	if (isArchiveFile(u) \|\| entry.isFile() && entry.length() < 4) {
Lines 2022-2030 Link Here
2022	public static File archiveOrDirForURL(URL entry) {	2019	public static File archiveOrDirForURL(URL entry) {
2023	String u = entry.toString();	2020	String u = entry.toString();
2024	if (u.startsWith("jar:file:") && u.endsWith("!/")) { // NOI18N	2021	if (u.startsWith("jar:file:") && u.endsWith("!/")) { // NOI18N
2025	return Utilities.toFile(URI.create(u.substring(4, u.length() - 2)));	2022	return BaseUtilities.toFile(URI.create(u.substring(4, u.length() - 2)));
2026	} else if (u.startsWith("file:")) { // NOI18N	2023	} else if (u.startsWith("file:")) { // NOI18N
2027	return Utilities.toFile(URI.create(u));	2024	return BaseUtilities.toFile(URI.create(u));
2028	} else {	2025	} else {
2029	return null;	2026	return null;
2030	}	2027	}
Lines 2034-2047 Link Here
2034	* Make sure that a JFileChooser does not traverse symlinks on Unix.	2031	* Make sure that a JFileChooser does not traverse symlinks on Unix.
2035	* @param chooser a file chooser	2032	* @param chooser a file chooser
2036	* @param currentDirectory if not null, a file to set as the current directory	2033	* @param currentDirectory if not null, a file to set as the current directory
2037	* using {@link JFileChooser#setCurrentDirectory} without canonicalizing	2034	* using {@link javax.swing.JFileChooser#setCurrentDirectory} without canonicalizing
2038	* @see <a href="http://www.netbeans.org/issues/show_bug.cgi?id=46459">Issue #46459</a>	2035	* @see <a href="http://www.netbeans.org/issues/show_bug.cgi?id=46459">Issue #46459</a>
2039	* @see <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4906607">JRE bug #4906607</a>	2036	* @see <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4906607">JRE bug #4906607</a>
2040	* @since org.openide/1 4.42	2037	* @since org.openide/1 4.42
2041	* @deprecated Just use {@link JFileChooser#setCurrentDirectory}. JDK 6 does not have this bug.	2038	* @deprecated Just use {@link javax.swing.JFileChooser#setCurrentDirectory}. JDK 6 does not have this bug.
2042	*/	2039	*/
2043	@Deprecated	2040	@Deprecated
2044	public static void preventFileChooserSymlinkTraversal(JFileChooser chooser, File currentDirectory) {	2041	public static void preventFileChooserSymlinkTraversal(javax.swing.JFileChooser chooser, File currentDirectory) {
2045	chooser.setCurrentDirectory(currentDirectory);	2042	chooser.setCurrentDirectory(currentDirectory);
2046	}	2043	}
2047		2044
Lines 2211-2333 Link Here
2211	}	2208	}
2212	}	2209	}
2213		2210
2214	private static final class NonCanonicalizingFileSystemView extends FileSystemView {
2215	private final FileSystemView delegate = FileSystemView.getFileSystemView();
2216
2217	public NonCanonicalizingFileSystemView() {
2218	}
2219
2220	@Override
2221	public boolean isFloppyDrive(File dir) {
2222	return delegate.isFloppyDrive(dir);
2223	}
2224
2225	@Override
2226	public boolean isComputerNode(File dir) {
2227	return delegate.isComputerNode(dir);
2228	}
2229
2230	public File createNewFolder(File containingDir)
2231	throws IOException {
2232	return wrapFileNoCanonicalize(delegate.createNewFolder(containingDir));
2233	}
2234
2235	@Override
2236	public boolean isDrive(File dir) {
2237	return delegate.isDrive(dir);
2238	}
2239
2240	@Override
2241	public boolean isFileSystemRoot(File dir) {
2242	return delegate.isFileSystemRoot(dir);
2243	}
2244
2245	@Override
2246	public File getHomeDirectory() {
2247	return wrapFileNoCanonicalize(delegate.getHomeDirectory());
2248	}
2249
2250	@Override
2251	public File createFileObject(File dir, String filename) {
2252	return wrapFileNoCanonicalize(delegate.createFileObject(dir, filename));
2253	}
2254
2255	@Override
2256	public Boolean isTraversable(File f) {
2257	return delegate.isTraversable(f);
2258	}
2259
2260	@Override
2261	public boolean isFileSystem(File f) {
2262	return delegate.isFileSystem(f);
2263	}
2264
2265	/*
2266	protected File createFileSystemRoot(File f) {
2267	return translate(delegate.createFileSystemRoot(f));
2268	}
2269	*/
2270	@Override
2271	public File getChild(File parent, String fileName) {
2272	return wrapFileNoCanonicalize(delegate.getChild(parent, fileName));
2273	}
2274
2275	@Override
2276	public File getParentDirectory(File dir) {
2277	return wrapFileNoCanonicalize(delegate.getParentDirectory(dir));
2278	}
2279
2280	@Override
2281	public Icon getSystemIcon(File f) {
2282	return delegate.getSystemIcon(f);
2283	}
2284
2285	@Override
2286	public boolean isParent(File folder, File file) {
2287	return delegate.isParent(folder, file);
2288	}
2289
2290	@Override
2291	public String getSystemTypeDescription(File f) {
2292	return delegate.getSystemTypeDescription(f);
2293	}
2294
2295	@Override
2296	public File getDefaultDirectory() {
2297	return wrapFileNoCanonicalize(delegate.getDefaultDirectory());
2298	}
2299
2300	@Override
2301	public String getSystemDisplayName(File f) {
2302	return delegate.getSystemDisplayName(f);
2303	}
2304
2305	@Override
2306	public File[] getRoots() {
2307	return wrapFilesNoCanonicalize(delegate.getRoots());
2308	}
2309
2310	@Override
2311	public boolean isHiddenFile(File f) {
2312	return delegate.isHiddenFile(f);
2313	}
2314
2315	@Override
2316	public File[] getFiles(File dir, boolean useFileHiding) {
2317	return wrapFilesNoCanonicalize(delegate.getFiles(dir, useFileHiding));
2318	}
2319
2320	@Override
2321	public boolean isRoot(File f) {
2322	return delegate.isRoot(f);
2323	}
2324
2325	@Override
2326	public File createFileObject(String path) {
2327	return wrapFileNoCanonicalize(delegate.createFileObject(path));
2328	}
2329	}
2330
2331	private static FileSystem getDiskFileSystem() {	2211	private static FileSystem getDiskFileSystem() {
2332	synchronized (FileUtil.class) {	2212	synchronized (FileUtil.class) {
2333	return diskFileSystem;	2213	return diskFileSystem;

Lines 65-73 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/XMLMapAttr.java (-12 / +5 lines)
65	import java.util.TreeSet;	65	import java.util.TreeSet;
66	import java.util.concurrent.atomic.AtomicBoolean;	66	import java.util.concurrent.atomic.AtomicBoolean;
67	import java.util.logging.Level;	67	import java.util.logging.Level;
		68	import org.netbeans.modules.openide.filesystems.RecognizeInstanceFiles;
68	import org.openide.util.NbBundle;	69	import org.openide.util.NbBundle;
69	import org.openide.util.SharedClassObject;	70	import org.openide.util.BaseUtilities;
70	import org.openide.util.Utilities;
71	import org.openide.util.io.NbMarshalledObject;	71	import org.openide.util.io.NbMarshalledObject;
72	import org.openide.util.io.NbObjectInputStream;	72	import org.openide.util.io.NbObjectInputStream;
73		73
Lines 824-830 Link Here
824	case 11:	824	case 11:
825	return URL.class;	825	return URL.class;
826	case 12:	826	case 12:
827	return ExternalUtil.findClass(Utilities.translate(value));	827	return ExternalUtil.findClass(BaseUtilities.translate(value));
828	case 13:	828	case 13:
829	return String.class;	829	return String.class;
830	}	830	}
Lines 967-981 Link Here
967	return new URL(value);	967	return new URL(value);
968	case 12:	968	case 12:
969	// special support for singletons	969	// special support for singletons
970	Class cls = ExternalUtil.findClass(Utilities.translate(value));	970	Class cls = ExternalUtil.findClass(BaseUtilities.translate(value));
971		971	return RecognizeInstanceFiles.createInstance(cls);
972	if (SharedClassObject.class.isAssignableFrom(cls)) {
973	return SharedClassObject.findObject(cls, true);
974	} else {
975	Constructor<?> init = cls.getDeclaredConstructor();
976	init.setAccessible(true);
977	return init.newInstance((Object[]) null);
978	}
979	case 13:	972	case 13:
980	String[] arr = value.split("#", 2); // NOI18N	973	String[] arr = value.split("#", 2); // NOI18N
981	return NbBundle.getBundle(arr[0]).getObject(arr[1]);	974	return NbBundle.getBundle(arr[0]).getObject(arr[1]);

Lines 48-54 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/FileUtilTestHidden.java (-4 / +4 lines)
48	import java.net.URL;	48	import java.net.URL;
49	import java.util.List;	49	import java.util.List;
50	import java.util.ArrayList;	50	import java.util.ArrayList;
51	import org.openide.util.Utilities;	51	import org.openide.util.BaseUtilities;
52		52
53	public class FileUtilTestHidden extends TestBaseHid {	53	public class FileUtilTestHidden extends TestBaseHid {
54		54
Lines 144-150 Link Here
144	file2 = FileUtil.normalizeFile(file);	144	file2 = FileUtil.normalizeFile(file);
145	assertEquals(file2, file);	145	assertEquals(file2, file);
146		146
147	if (Utilities.isUnix()) {	147	if (BaseUtilities.isUnix()) {
148	assertEquals(new File("/"), FileUtil.normalizeFile(new File("/..")));	148	assertEquals(new File("/"), FileUtil.normalizeFile(new File("/..")));
149	assertEquals(new File("/"), FileUtil.normalizeFile(new File("/../.")));	149	assertEquals(new File("/"), FileUtil.normalizeFile(new File("/../.")));
150	assertEquals(new File("/tmp"), FileUtil.normalizeFile(new File("/../../tmp")));	150	assertEquals(new File("/tmp"), FileUtil.normalizeFile(new File("/../../tmp")));
Lines 152-158 Link Here
152	}	152	}
153		153
154	public void testNormalizeFile2() throws Exception {	154	public void testNormalizeFile2() throws Exception {
155	if (!Utilities.isWindows()) {	155	if (!BaseUtilities.isWindows()) {
156	return;	156	return;
157	}	157	}
158	File rootFile = FileUtil.toFile(root);	158	File rootFile = FileUtil.toFile(root);
Lines 182-188 Link Here
182	}	182	}
183		183
184	public void testIsArchiveFile() throws Exception {	184	public void testIsArchiveFile() throws Exception {
185	final String base = Utilities.toURI(getWorkDir()).toURL().toExternalForm();	185	final String base = BaseUtilities.toURI(getWorkDir()).toURL().toExternalForm();
186	URL url = new URL(base + "test.jar"); //NOI18N	186	URL url = new URL(base + "test.jar"); //NOI18N
187	assertTrue("test.jar has to be an archive", FileUtil.isArchiveFile(url)); //NOI18N	187	assertTrue("test.jar has to be an archive", FileUtil.isArchiveFile(url)); //NOI18N
188	url = new URL(base + ".hidden.jar"); //NOI18N	188	url = new URL(base + ".hidden.jar"); //NOI18N

Lines 58-64 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/TestUtilHid.java (-3 / +3 lines)
58	import java.util.Iterator;	58	import java.util.Iterator;
59	import java.util.Map;	59	import java.util.Map;
60	import java.util.StringTokenizer;	60	import java.util.StringTokenizer;
61	import org.openide.util.Utilities;	61	import org.openide.util.BaseUtilities;
62		62
63	/**	63	/**
64	* @author rm111737	64	* @author rm111737
Lines 178-184 Link Here
178		178
179	XMLFileSystem xfs = new XMLFileSystem ();	179	XMLFileSystem xfs = new XMLFileSystem ();
180	try {	180	try {
181	xfs.setXmlUrl(Utilities.toURI(xmlFile).toURL());	181	xfs.setXmlUrl(BaseUtilities.toURI(xmlFile).toURL());
182	} catch (Exception ex) {}	182	} catch (Exception ex) {}
183		183
184	return xfs;	184	return xfs;
Lines 189-195 Link Here
189		189
190	XMLFileSystem xfs = new XMLFileSystem ();	190	XMLFileSystem xfs = new XMLFileSystem ();
191	try {	191	try {
192	xfs.setXmlUrl(Utilities.toURI(xmlFile).toURL());	192	xfs.setXmlUrl(BaseUtilities.toURI(xmlFile).toURL());
193	} catch (Exception ex) {}	193	} catch (Exception ex) {}
194		194
195	return xfs;	195	return xfs;

Lines 46-56 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/URLMapper50852Test.java (-3 / +2 lines)
46		46
47		47
48	import org.netbeans.junit.*;	48	import org.netbeans.junit.*;
49	import org.openide.util.Lookup;
50		49
51	import java.net.URL;	50	import java.net.URL;
52	import java.io.File;	51	import java.io.File;
53	import org.openide.util.Utilities;	52	import org.openide.util.BaseUtilities;
54		53
55	/**	54	/**
56	* Simulates issue 50852.	55	* Simulates issue 50852.
Lines 77-83 Link Here
77	*/	76	*/
78	protected void setUp() throws Exception {	77	protected void setUp() throws Exception {
79	File workdir = getWorkDir();	78	File workdir = getWorkDir();
80	testURL = Utilities.toURI(workdir).toURL();	79	testURL = BaseUtilities.toURI(workdir).toURL();
81	System.setProperty("org.openide.util.Lookup", "org.openide.filesystems.URLMapper50852Test$Lkp");	80	System.setProperty("org.openide.util.Lookup", "org.openide.filesystems.URLMapper50852Test$Lkp");
82	MAPPER_INSTANCE = new MyURLMapper ();	81	MAPPER_INSTANCE = new MyURLMapper ();
83	Lkp lkp = (Lkp)org.openide.util.Lookup.getDefault();	82	Lkp lkp = (Lkp)org.openide.util.Lookup.getDefault();

Lines 62-68 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/XMLFileSystemTestHid.java (-41 / +41 lines)
62	import java.util.jar.JarEntry;	62	import java.util.jar.JarEntry;
63	import java.util.jar.JarOutputStream;	63	import java.util.jar.JarOutputStream;
64	import org.openide.util.Enumerations;	64	import org.openide.util.Enumerations;
65	import org.openide.util.Utilities;	65	import org.openide.util.BaseUtilities;
66		66
67	public class XMLFileSystemTestHid extends TestBaseHid {	67	public class XMLFileSystemTestHid extends TestBaseHid {
68	/** Factory for all filesystems that want to use TCK in this class.	68	/** Factory for all filesystems that want to use TCK in this class.
Lines 107-113 Link Here
107		107
108	resources = new String[] {"a/b/c","a/b1/c"};	108	resources = new String[] {"a/b/c","a/b1/c"};
109		109
110	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, Utilities.toURI(createXMLLayer()).toURL())) {	110	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(createXMLLayer()).toURL())) {
111	// OK, unsupported	111	// OK, unsupported
112	return;	112	return;
113	}	113	}
Lines 120-126 Link Here
120	@Override	120	@Override
121	protected void setUp() throws Exception {	121	protected void setUp() throws Exception {
122	File f = createXMLLayer();	122	File f = createXMLLayer();
123	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	123	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
124	this.testedFS = xfs;	124	this.testedFS = xfs;
125	this.allTestedFS = new FileSystem[] { xfs };	125	this.allTestedFS = new FileSystem[] { xfs };
126	super.setUp();	126	super.setUp();
Lines 152-164 Link Here
152		152
153		153
154		154
155	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	155	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
156		156
157	FileObject fo = xfs.findResource ("TestModule/sample.txt");	157	FileObject fo = xfs.findResource ("TestModule/sample.txt");
158	assertEquals ("Four bytes there", 4, fo.getSize ());	158	assertEquals ("Four bytes there", 4, fo.getSize ());
159	registerDefaultListener (fo);	159	registerDefaultListener (fo);
160		160
161	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, Utilities.toURI(f2).toURL())) {	161	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(f2).toURL())) {
162	// OK, unsupported	162	// OK, unsupported
163	return;	163	return;
164	}	164	}
Lines 191-203 Link Here
191		191
192		192
193		193
194	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	194	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
195		195
196	FileObject fo = xfs.findResource ("TestModule/sample.txt");	196	FileObject fo = xfs.findResource ("TestModule/sample.txt");
197	assertEquals ("Four bytes there", 4, fo.getSize ());	197	assertEquals ("Four bytes there", 4, fo.getSize ());
198	registerDefaultListener (fo);	198	registerDefaultListener (fo);
199		199
200	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, Utilities.toURI(f2).toURL())) {	200	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(f2).toURL())) {
201	// OK, unsupported	201	// OK, unsupported
202	return;	202	return;
203	}	203	}
Lines 231-243 Link Here
231		231
232		232
233		233
234	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	234	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
235		235
236	FileObject fo = xfs.findResource ("TestModule/sample.txt");	236	FileObject fo = xfs.findResource ("TestModule/sample.txt");
237	assertEquals("Old value is in the attribute", "old", fo.getAttribute("value"));	237	assertEquals("Old value is in the attribute", "old", fo.getAttribute("value"));
238	registerDefaultListener (fo);	238	registerDefaultListener (fo);
239		239
240	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, Utilities.toURI(f2).toURL())) {	240	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(f2).toURL())) {
241	// OK, unsupported	241	// OK, unsupported
242	return;	242	return;
243	}	243	}
Lines 265-277 Link Here
265		265
266		266
267		267
268	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	268	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
269		269
270	FileObject fo = xfs.findResource("TestModule/sample.txt");	270	FileObject fo = xfs.findResource("TestModule/sample.txt");
271	assertEquals("Four bytes there", 4, fo.getSize());	271	assertEquals("Four bytes there", 4, fo.getSize());
272	registerDefaultListener(fo);	272	registerDefaultListener(fo);
273		273
274	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, Utilities.toURI(f2).toURL())) {	274	if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, BaseUtilities.toURI(f2).toURL())) {
275	// OK, unsupported	275	// OK, unsupported
276	return;	276	return;
277	}	277	}
Lines 301-307 Link Here
301	f.lastModified() < f2.lastModified()	301	f.lastModified() < f2.lastModified()
302	);	302	);
303	}	303	}
304	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	304	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
305	FileObject fo = xfs.findResource ("TestModule/sample.txt");	305	FileObject fo = xfs.findResource ("TestModule/sample.txt");
306	assertNotNull(fo);	306	assertNotNull(fo);
307	assertEquals(fo.lastModified().getTime(), f.lastModified());	307	assertEquals(fo.lastModified().getTime(), f.lastModified());
Lines 326-332 Link Here
326	"</filesystem>\n"	326	"</filesystem>\n"
327	);	327	);
328		328
329	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	329	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
330	FileObject fo = xfs.findResource ("TestModule/sample.txt");	330	FileObject fo = xfs.findResource ("TestModule/sample.txt");
331	assertNotNull(fo);	331	assertNotNull(fo);
332		332
Lines 350-356 Link Here
350	+ " </folder>\n"	350	+ " </folder>\n"
351	+ "</filesystem>");	351	+ "</filesystem>");
352		352
353	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	353	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
354	final LocalFileSystem lfs = new LocalFileSystem();	354	final LocalFileSystem lfs = new LocalFileSystem();
355	lfs.setRootDirectory(getWorkDir());	355	lfs.setRootDirectory(getWorkDir());
356	MultiFileSystem mfs = new MultiFileSystem(lfs, xfs);	356	MultiFileSystem mfs = new MultiFileSystem(lfs, xfs);
Lines 377-383 Link Here
377	);	377	);
378	Count.cnt = 0;	378	Count.cnt = 0;
379		379
380	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	380	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
381	/** the following is a fake implementation of filesystem that	381	/** the following is a fake implementation of filesystem that
382	* allows us to prevent calls to fileObject.getAttributes()	382	* allows us to prevent calls to fileObject.getAttributes()
383	*/	383	*/
Lines 500-506 Link Here
500	"</filesystem>\n"	500	"</filesystem>\n"
501	);	501	);
502		502
503	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	503	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
504	FileObject fo = xfs.findResource ("TestModule/sample.txt");	504	FileObject fo = xfs.findResource ("TestModule/sample.txt");
505	assertNotNull(fo);	505	assertNotNull(fo);
506		506
Lines 525-531 Link Here
525	"</filesystem>\n"	525	"</filesystem>\n"
526	);	526	);
527		527
528	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	528	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
529	FileObject fo = xfs.findResource ("TestModule/sample.txt");	529	FileObject fo = xfs.findResource ("TestModule/sample.txt");
530	assertNotNull(fo);	530	assertNotNull(fo);
531		531
Lines 550-556 Link Here
550	"</filesystem>\n"	550	"</filesystem>\n"
551	);	551	);
552		552
553	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	553	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
554	FileObject fo = xfs.findResource ("TestModule/sample.txt");	554	FileObject fo = xfs.findResource ("TestModule/sample.txt");
555	assertNotNull(fo);	555	assertNotNull(fo);
556		556
Lines 580-590 Link Here
580	"</filesystem>\n"	580	"</filesystem>\n"
581	);	581	);
582		582
583	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	583	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
584	FileObject fo = xfs.findResource ("TestModule/sample.txt");	584	FileObject fo = xfs.findResource ("TestModule/sample.txt");
585	assertNotNull(fo);	585	assertNotNull(fo);
586		586
587	XMLFileSystem realXMLFS = new XMLFileSystem(Utilities.toURI(f).toURL());	587	XMLFileSystem realXMLFS = new XMLFileSystem(BaseUtilities.toURI(f).toURL());
588	FileObject realfo = realXMLFS.findResource("TestModule/sample.txt");	588	FileObject realfo = realXMLFS.findResource("TestModule/sample.txt");
589	assertNotNull(realfo);	589	assertNotNull(realfo);
590		590
Lines 621-627 Link Here
621	"</filesystem>\n"	621	"</filesystem>\n"
622	);	622	);
623		623
624	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	624	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
625	FileObject fo = xfs.findResource ("TestModule/sample.txt");	625	FileObject fo = xfs.findResource ("TestModule/sample.txt");
626	FileObject snd = xfs.findResource ("TestModule/snd.txt");	626	FileObject snd = xfs.findResource ("TestModule/snd.txt");
627	assertNotNull(fo);	627	assertNotNull(fo);
Lines 722-728 Link Here
722	"</filesystem>\n"	722	"</filesystem>\n"
723	);	723	);
724		724
725	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	725	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
726	FileObject fo = xfs.findResource ("TestModule/sample.txt");	726	FileObject fo = xfs.findResource ("TestModule/sample.txt");
727	assertNotNull(fo);	727	assertNotNull(fo);
728		728
Lines 771-778 Link Here
771	)	771	)
772	);	772	);
773		773
774	URL url1 = new URL("jar:" + Utilities.toURI(jar1) + "!/layer.xml");	774	URL url1 = new URL("jar:" + BaseUtilities.toURI(jar1) + "!/layer.xml");
775	URL url2 = new URL("jar:" + Utilities.toURI(jar2) + "!/layer.xml");	775	URL url2 = new URL("jar:" + BaseUtilities.toURI(jar2) + "!/layer.xml");
776		776
777	FileSystem xfs1 = FileSystemFactoryHid.createXMLSystem(getName(), this, url1);	777	FileSystem xfs1 = FileSystemFactoryHid.createXMLSystem(getName(), this, url1);
778	FileObject fo1 = xfs1.findResource("dir/file");	778	FileObject fo1 = xfs1.findResource("dir/file");
Lines 902-908 Link Here
902	File f2 = changeOfAnAttributeInLayerIsFiredgenerateLayer("Folder", "java.awt.Button");	902	File f2 = changeOfAnAttributeInLayerIsFiredgenerateLayer("Folder", "java.awt.Button");
903	File f3 = changeOfAnAttributeInLayerIsFiredgenerateLayer("NoChange", "nochange");	903	File f3 = changeOfAnAttributeInLayerIsFiredgenerateLayer("NoChange", "nochange");
904		904
905	fs.setXmlUrls (new URL[] { Utilities.toURI(f1).toURL(), Utilities.toURI(f3).toURL() } );	905	fs.setXmlUrls (new URL[] { BaseUtilities.toURI(f1).toURL(), BaseUtilities.toURI(f3).toURL() } );
906		906
907	FileObject file = fs.findResource("Folder/empty.xml");	907	FileObject file = fs.findResource("Folder/empty.xml");
908	assertNotNull("File found in layer", file);	908	assertNotNull("File found in layer", file);
Lines 918-924 Link Here
918	assertAttr("The first value is list", file, "value", "java.awt.List");	918	assertAttr("The first value is list", file, "value", "java.awt.List");
919	assertAttr("Imutable value is nochange", nochange, "value", "nochange");	919	assertAttr("Imutable value is nochange", nochange, "value", "nochange");
920		920
921	fs.setXmlUrls (new URL[] { Utilities.toURI(f2).toURL(), Utilities.toURI(f3).toURL() } );	921	fs.setXmlUrls (new URL[] { BaseUtilities.toURI(f2).toURL(), BaseUtilities.toURI(f3).toURL() } );
922	String v2 = (String) file.getAttribute("value");	922	String v2 = (String) file.getAttribute("value");
923	assertEquals("The second value is button", "java.awt.Button", v2);	923	assertEquals("The second value is button", "java.awt.Button", v2);
924		924
Lines 953-959 Link Here
953	LocalFileSystem target = new LocalFileSystem();	953	LocalFileSystem target = new LocalFileSystem();
954	target.setRootDirectory(r);	954	target.setRootDirectory(r);
955		955
956	FileSystem source = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f).toURL());	956	FileSystem source = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f).toURL());
957	FileObject template = source.findResource("Templates/Other/special");	957	FileObject template = source.findResource("Templates/Other/special");
958	assertNotNull("template found", template);	958	assertNotNull("template found", template);
959	FileObject foTested = target.getRoot().createData("copiedTemplate");	959	FileObject foTested = target.getRoot().createData("copiedTemplate");
Lines 1078-1084 Link Here
1078	w.close();	1078	w.close();
1079	}	1079	}
1080		1080
1081	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f1).toURL(), Utilities.toURI(f2).toURL());	1081	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f1).toURL(), BaseUtilities.toURI(f2).toURL());
1082		1082
1083		1083
1084	FileObject just1 = xfs.findResource("just1/empty.xml");	1084	FileObject just1 = xfs.findResource("just1/empty.xml");
Lines 1090-1108 Link Here
1090	String layers2 = layers(just2);	1090	String layers2 = layers(just2);
1091	String layersB = layers(both);	1091	String layersB = layers(both);
1092		1092
1093	if (!layersR.contains(Utilities.toURI(f1).toString())) {	1093	if (!layersR.contains(BaseUtilities.toURI(f1).toString())) {
1094	fail("Missing " + Utilities.toURI(f1).toString() + "\ninside: " + layersR);	1094	fail("Missing " + BaseUtilities.toURI(f1).toString() + "\ninside: " + layersR);
1095	}	1095	}
1096	if (!layersR.contains(Utilities.toURI(f2).toString())) {	1096	if (!layersR.contains(BaseUtilities.toURI(f2).toString())) {
1097	fail("Missing " + Utilities.toURI(f2).toString() + "\ninside: " + layersR);	1097	fail("Missing " + BaseUtilities.toURI(f2).toString() + "\ninside: " + layersR);
1098	}	1098	}
1099		1099
1100	assertEquals(Utilities.toURI(f1).toString(), layers1);	1100	assertEquals(BaseUtilities.toURI(f1).toString(), layers1);
1101	assertEquals(Utilities.toURI(f2).toString(), layers2);	1101	assertEquals(BaseUtilities.toURI(f2).toString(), layers2);
1102	if (!layersB.contains(Utilities.toURI(f1).toString())) {	1102	if (!layersB.contains(BaseUtilities.toURI(f1).toString())) {
1103	fail("Missing " + f1 + "\ninside: " + layersB);	1103	fail("Missing " + f1 + "\ninside: " + layersB);
1104	}	1104	}
1105	if (!layersB.contains(Utilities.toURI(f2).toString())) {	1105	if (!layersB.contains(BaseUtilities.toURI(f2).toString())) {
1106	fail("Missing " + f2 + "\ninside: " + layersB);	1106	fail("Missing " + f2 + "\ninside: " + layersB);
1107	}	1107	}
1108	}	1108	}
Lines 1120-1126 Link Here
1120	+ "</filesystem>");	1120	+ "</filesystem>");
1121	w.close();	1121	w.close();
1122		1122
1123	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(layer).toURL());	1123	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(layer).toURL());
1124		1124
1125	FileObject fo = xfs.findResource("f/empty.xml");	1125	FileObject fo = xfs.findResource("f/empty.xml");
1126	assertNotNull("File found", fo);	1126	assertNotNull("File found", fo);
Lines 1143-1167 Link Here
1143	File f1 = writeFile("layer1.xml",	1143	File f1 = writeFile("layer1.xml",
1144	"<filesystem>\n" +	1144	"<filesystem>\n" +
1145	"<folder name='d'>\n" +	1145	"<folder name='d'>\n" +
1146	"<file name='f' url='" + Utilities.toURI(c1) + "'/>" +	1146	"<file name='f' url='" + BaseUtilities.toURI(c1) + "'/>" +
1147	"</folder>\n" +	1147	"</folder>\n" +
1148	"</filesystem>\n"	1148	"</filesystem>\n"
1149	);	1149	);
1150	File f2 = writeFile("layer2.xml",	1150	File f2 = writeFile("layer2.xml",
1151	"<filesystem>\n" +	1151	"<filesystem>\n" +
1152	"<folder name='d'>\n" +	1152	"<folder name='d'>\n" +
1153	"<file name='f' url='" + Utilities.toURI(c2) + "'>" +	1153	"<file name='f' url='" + BaseUtilities.toURI(c2) + "'>" +
1154	" <attr name='weight' intvalue='100'/>" +	1154	" <attr name='weight' intvalue='100'/>" +
1155	"</file>\n" +	1155	"</file>\n" +
1156	"</folder>\n" +	1156	"</folder>\n" +
1157	"</filesystem>\n"	1157	"</filesystem>\n"
1158	);	1158	);
1159		1159
1160	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f2).toURL(), Utilities.toURI(f1).toURL());	1160	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f2).toURL(), BaseUtilities.toURI(f1).toURL());
1161	FileObject fo = xfs.findResource("d/f");	1161	FileObject fo = xfs.findResource("d/f");
1162	assertNotNull(fo);	1162	assertNotNull(fo);
1163	assertEquals(6, fo.getSize());	1163	assertEquals(6, fo.getSize());
1164	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, Utilities.toURI(f1).toURL(), Utilities.toURI(f2).toURL());	1164	xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, BaseUtilities.toURI(f1).toURL(), BaseUtilities.toURI(f2).toURL());
1165	fo = xfs.findResource("d/f");	1165	fo = xfs.findResource("d/f");
1166	assertNotNull(fo);	1166	assertNotNull(fo);
1167	assertEquals(6, fo.getSize());	1167	assertEquals(6, fo.getSize());

Line 0 Link Here

(-)a/openide.util.base/src/org/netbeans/modules/openide/util/ProxyURLStreamHandlerFactory.java (+91 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2010 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2009 Sun Microsystems, Inc.
		41	*/
		42
		43	package org.netbeans.modules.openide.util;
		44
		45	import java.net.URLStreamHandler;
		46	import java.net.URLStreamHandlerFactory;
		47	import java.util.Arrays;
		48	import java.util.Collection;
		49	import java.util.HashMap;
		50	import java.util.HashSet;
		51	import java.util.Map;
		52	import java.util.Set;
		53	import org.openide.util.Lookup;
		54	import org.openide.util.LookupEvent;
		55	import org.openide.util.LookupListener;
		56	import org.openide.util.URLStreamHandlerRegistration;
		57	import org.openide.util.lookup.Lookups;
		58	import org.openide.util.lookup.ServiceProvider;
		59
		60	/**
		61	* @see URLStreamHandlerRegistration
		62	*/
		63	@ServiceProvider(service=URLStreamHandlerFactory.class)
		64	public final class ProxyURLStreamHandlerFactory implements URLStreamHandlerFactory {
65	/** prevents GC only */
66	private final Map<String, Lookup.Result<URLStreamHandler>> results = new HashMap<String, Lookup.Result<URLStreamHandler>>();
67	private final Map<String, URLStreamHandler> handlers = new HashMap<String, URLStreamHandler>();
68	private static final Set<String> STANDARD_PROTOCOLS = new HashSet<String>(Arrays.asList("jar", "file", "http", "https", "resource")); // NOI18N
69
70	public @Override synchronized URLStreamHandler createURLStreamHandler(final String protocol) {
71	if (STANDARD_PROTOCOLS.contains(protocol)) {
72	// Well-known handlers in JRE. Do not try to initialize lookup.
73	return null;
74	}
75	if (!results.containsKey(protocol)) {
76	final Lookup.Result<URLStreamHandler> result = Lookups.forPath("URLStreamHandler/" + protocol).lookupResult(URLStreamHandler.class);
77	LookupListener listener = new LookupListener() {
78	public @Override void resultChanged(LookupEvent ev) {
79	synchronized (ProxyURLStreamHandlerFactory.this) {
80	Collection<? extends URLStreamHandler> instances = result.allInstances();
81	handlers.put(protocol, instances.isEmpty() ? null : instances.iterator().next());
82	}
83	}
84	};
85	result.addLookupListener(listener);
86	listener.resultChanged(null);
87	results.put(protocol, result);
88	}
89	return handlers.get(protocol);
90	}
91	}

Line 0 Link Here

(-)a/openide.util.base/src/org/openide/util/URLStreamHandlerRegistration.java (+83 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2010 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2009 Sun Microsystems, Inc.
		41	*/
		42
		43	package org.openide.util;
		44
		45	import java.lang.annotation.ElementType;
		46	import java.lang.annotation.Retention;
		47	import java.lang.annotation.RetentionPolicy;
		48	import java.lang.annotation.Target;
		49	import java.net.URL;
		50	import java.net.URLStreamHandler;
		51	import java.net.URLStreamHandlerFactory;
		52	import org.openide.util.lookup.NamedServiceDefinition;
		53
		54	/**
		55	* Replacement for {@link URLStreamHandlerFactory} within the NetBeans platform.
		56	* (The JVM only permits one global factory to be set at a time,
		57	* whereas various independent modules may wish to register handlers.)
		58	* May be placed on a {@link URLStreamHandler} implementation to register it.
		59	* Your handler will be loaded and used if and when a URL of a matching protocol is created.
		60	* <p>A {@link URLStreamHandlerFactory} which uses these registrations may be found in {@link Lookup#getDefault}.
		61	* This factory is active whenever the module system is loaded.
		62	* You may also wish to call {@link URL#setURLStreamHandlerFactory}
		63	* from a unit test or otherwise without the module system active.
		64	* @since org.openide.util 7.31
65	*/
66	@NamedServiceDefinition(path="URLStreamHandler/@protocol()", serviceType=URLStreamHandler.class)
67	@Retention(RetentionPolicy.SOURCE)
68	@Target(ElementType.TYPE)
69	public @interface URLStreamHandlerRegistration {
70
71	/**
72	* URL protocol(s) which are handled.
73	* {@link URLStreamHandler#openConnection} will be called with a matching {@link URL#getProtocol}.
74	*/
75	String[] protocol();
76
77	/**
78	* An optional position in which to register this handler relative to others.
79	* The lowest-numbered handler is used in favor of any others, including unnumbered handlers.
80	*/
81	int position() default Integer.MAX_VALUE;
82
83	}

Line 0 Link Here

(-)a/openide.util.base/test/unit/src/org/openide/util/test/JarBuilder.java (+126 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2011 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
		41	*/
		42
		43	package org.openide.util.test;
		44
		45	import java.io.File;
		46	import java.io.FileOutputStream;
		47	import java.io.OutputStream;
		48	import java.util.ArrayList;
		49	import java.util.Arrays;
		50	import java.util.List;
		51	import java.util.Map;
		52	import java.util.TreeMap;
		53	import org.netbeans.junit.NbTestCase;
		54
		55	// XXX could add methods to add a JAR manifest, include text or binary resources, ...
		56
		57	/**
		58	* Builder for compiling some source files and packing the result into a JAR.
		59	*/
		60	public final class JarBuilder {
		61
		62	private final File src, dest, jar;
		63	private List<File> classpath;
		64
65	/**
66	* @param workdir as in {@link NbTestCase#getWorkDir}
67	*/
68	public JarBuilder(File workdir) throws Exception {
69	jar = File.createTempFile("test", ".jar", workdir);
70	String n = jar.getName().replaceAll("^test\|[.]jar$", "");
71	src = new File(workdir, "src" + n);
72	dest = new File(workdir, "classes" + n);
73	}
74
75	/**
76	* Optional classpath for compiling sources.
77	* If unspecified, use Java classpath of test.)
78	*/
79	public JarBuilder classpath(File... cp) {
80	if (classpath == null) {
81	classpath = new ArrayList<File>();
82	}
83	classpath.addAll(Arrays.asList(cp));
84	return this;
85	}
86
87	/**
88	* Adds a source file to compile.
89	* @see AnnotationProcessorTestUtils#makeSource
90	*/
91	public JarBuilder source(String clazz, String... content) throws Exception {
92	AnnotationProcessorTestUtils.makeSource(src, clazz, content);
93	return this;
94	}
95
96	/**
97	* Compiles sources and creates resulting JAR.
98	* @return the created JAR file
99	*/
100	public File build() throws Exception {
101	if (!AnnotationProcessorTestUtils.runJavac(src, null, dest, classpath != null ? classpath.toArray(new File[0]) : null, null)) {
102	throw new Exception("compilation failed");
103	}
104	Map<String,byte[]> data = new TreeMap<String,byte[]>();
105	scan(data, dest, "");
106	OutputStream os = new FileOutputStream(jar);
107	try {
108	TestFileUtils.writeZipFile(os, data);
109	} finally {
110	os.close();
111	}
112	return jar;
113	}
114
115	private static void scan(Map<String,byte[]> data, File d, String prefix) throws Exception {
116	for (File kid : d.listFiles()) {
117	String prefixName = prefix + kid.getName();
118	if (kid.isDirectory()) {
119	scan(data, kid, prefixName + '/');
120	} else {
121	data.put(prefixName, TestFileUtils.readFileBin(kid));
122	}
123	}
124	}
125
126	}