<change id="FileChooserBuilder.SelectionApprover">

            <api name="filesystems"/>

            <summary>Added FileChooserBuilder.setSelectionApprover(FileChooserBuilder.SelectionApprover) and FileChooserBuilder.addFileFilter()</summary>

            <version major="7" minor="26"/>

            <date day="16" month="9" year="2009"/>

            <author login="tboudreau"/>

            <compatibility modification="yes">

                <p>

                    Added FileChooserBuilder.setSelectionApprover(),

                    FileChooserBuilder.addFileFilter() and the interface

                    FileChooserBuilder.SelectionApprover.

                </p>

            </compatibility>

            <description>

                <p>

                    Added FileChooserBuilder.setSelectionApprover() which enables

                    JFileChoosers created by a FileChooserBuilder to intercept

                    JFileChooser.approveSelection() (for example, to ask the user

                    if it is ok to overwrite a file);  added

                    FileChooserBuilder.addFileFilter() which operates similarly

                    to JFileChooser.addChoosableFileFilter(), so JFileChoosers

                    created by a FileChooserBuilder can be given user-selectable

                    file filters.

                </p>

            </description>

            <class package="org.openide.filesystems" name="FileChooserBuilder"/>

            <issue number="171928"/>

        </change>

import java.util.ArrayList;

import java.util.List;

    private SelectionApprover approver;

    private final List<FileFilter> filters = new ArrayList<FileFilter>(3);

        if (!filters.isEmpty()) {

            for (FileFilter f : filters) {

                chooser.addChoosableFileFilter(f);

            }

        }

    }

    /**

     * 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;

    }

    /**

     * Set a selection approver which can display an "Overwrite file?"

     * 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

         * "Overwrite File X?" 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);

            this.approver = approver;

        public void approveSelection() {

            if (approver != null) {

                boolean approved = approver.approve(getSelectedFiles());

                if (approved) {

                    super.approveSelection();

                }

            } else {

                super.approveSelection();

            }

        }

        @Override

import java.util.Arrays;

import java.util.HashSet;

import java.util.Set;

    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.approveSelection();

        sa.assertApproveInvoked();

    }

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

    }

    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 boolean approveInvoked;

        public boolean approve(File[] selection) {

            approveInvoked = true;

            return true;

        }

        void assertApproveInvoked() {

            assertTrue (approveInvoked);

        }

    }