Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

DxD [Herramienta Generadora de Diccionarios]

  • 8 Respuestas
  • 5840 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado rollth

  • *
  • Underc0der
  • Mensajes: 876
  • Actividad:
    0%
  • Reputación 16
  • El conocimiento es libre.
    • Ver Perfil
    • Whateversec
    • Email
  • Twitter: @RoloMijan
« en: Mayo 01, 2018, 11:47:39 am »
Muy buenas Underc0deres,

hoy vengo a presentaros una nueva herramienta que he programado que, aunque no este completada ya es funcional. De tal forma iré avisando de nuevas actualizaciones hasta llegar al punto al que quiero llevar la herramienta.

Se trata de DxD, esta herramienta se encarga de realizar un Diccionario personalizado a partir de la información obtenida de una persona (y en un futuro de una empresa).

La idea es que a partir de los terminos introducidos, en una nueva actualización busque términos relacionados y de esta forma poder crear diccionarios más personalizados.

Por ejemplo en el casual de que a la persona le gustase el fútbol que añadiera palabras como arbitro o messi a la RainBow Table.



Permite la posibilidad de guardar y cargar perfiles de las personas para su posterior uso y modificación de estas. Con la extesión de archivos ".dxd"





Una vez creado el diccionario generaría un diccionario como el siguiente.

https://pastebin.com/cshMU1Un

PROXIMAS FUNCIONALIDADES:

- Generador de Diccionarios sobre Perfiles de Empresas.
- Añadir al diccionario búsquedas relacionadas sobre los terminos introducidos.
- Añadir apartado musical para buscar canciones respectivas.
- Modificar posibilidad numérica para generar mejores diccionarios

Link de descarga: https://mega.nz/#!FYllHbRa!5KHshe4EgwjJA5liCNrcdBEv-cHSN0ITzcvnRHjIaJY

También me pueden seguir en Twitter si les hace ilusión: @RoloMijan

Source.

El código está muy sucio de momento, pero lo dejo por aquí y ya o limpiaré en un futuro.

GUI.java

Código: Java
  1. /*
  2.  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
  3.  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  4.  *
  5.  *
  6.  *
  7.  *
  8.  *
  9.  *
  10.  *
  11.  *
  12.  *
  13.  *
  14.  *
  15.  *
  16.  *
  17.  *
  18.  *
  19.  *
  20.  *
  21.  *
  22.  *
  23.  *
  24.  */
  25.  
  26. package javax.swing;
  27.  
  28. import javax.swing.event.*;
  29. import javax.swing.filechooser.*;
  30. import javax.swing.plaf.FileChooserUI;
  31.  
  32. import javax.accessibility.*;
  33.  
  34. import java.io.File;
  35. import java.io.ObjectOutputStream;
  36. import java.io.IOException;
  37.  
  38. import java.util.Vector;
  39. import java.awt.AWTEvent;
  40. import java.awt.Component;
  41. import java.awt.Container;
  42. import java.awt.BorderLayout;
  43. import java.awt.Window;
  44. import java.awt.Dialog;
  45. import java.awt.Frame;
  46. import java.awt.GraphicsEnvironment;
  47. import java.awt.HeadlessException;
  48. import java.awt.EventQueue;
  49. import java.awt.Toolkit;
  50. import java.awt.event.*;
  51. import java.beans.PropertyChangeListener;
  52. import java.beans.PropertyChangeEvent;
  53. import java.lang.ref.WeakReference;
  54.  
  55. /**
  56.  * <code>JFileChooser</code> provides a simple mechanism for the user to
  57.  * choose a file.
  58.  * For information about using <code>JFileChooser</code>, see
  59.  * <a
  60.  href="https://docs.oracle.com/javase/tutorial/uiswing/components/filechooser.html">How to Use File Choosers</a>,
  61.  * a section in <em>The Java Tutorial</em>.
  62.  *
  63.  * <p>
  64.  *
  65.  * The following code pops up a file chooser for the user's home directory that
  66.  * sees only .jpg and .gif images:
  67.  * <pre>
  68.  *    JFileChooser chooser = new JFileChooser();
  69.  *    FileNameExtensionFilter filter = new FileNameExtensionFilter(
  70.  *        "JPG &amp; GIF Images", "jpg", "gif");
  71.  *    chooser.setFileFilter(filter);
  72.  *    int returnVal = chooser.showOpenDialog(parent);
  73.  *    if(returnVal == JFileChooser.APPROVE_OPTION) {
  74.  *       System.out.println("You chose to open this file: " +
  75.  *            chooser.getSelectedFile().getName());
  76.  *    }
  77.  * </pre>
  78.  * <p>
  79.  * <strong>Warning:</strong> Swing is not thread safe. For more
  80.  * information see <a
  81.  * href="package-summary.html#threading">Swing's Threading
  82.  * Policy</a>.
  83.  *
  84.  * @beaninfo
  85.  *   attribute: isContainer false
  86.  * description: A component which allows for the interactive selection of a file.
  87.  *
  88.  * @author Jeff Dinkins
  89.  *
  90.  */
  91. public class JFileChooser extends JComponent implements Accessible {
  92.  
  93.     /**
  94.      * @see #getUIClassID
  95.      * @see #readObject
  96.      */
  97.     private static final String uiClassID = "FileChooserUI";
  98.  
  99.     // ************************
  100.     // ***** Dialog Types *****
  101.     // ************************
  102.  
  103.     /**
  104.      * Type value indicating that the <code>JFileChooser</code> supports an
  105.      * "Open" file operation.
  106.      */
  107.     public static final int OPEN_DIALOG = 0;
  108.  
  109.     /**
  110.      * Type value indicating that the <code>JFileChooser</code> supports a
  111.      * "Save" file operation.
  112.      */
  113.     public static final int SAVE_DIALOG = 1;
  114.  
  115.     /**
  116.      * Type value indicating that the <code>JFileChooser</code> supports a
  117.      * developer-specified file operation.
  118.      */
  119.     public static final int CUSTOM_DIALOG = 2;
  120.  
  121.  
  122.     // ********************************
  123.     // ***** Dialog Return Values *****
  124.     // ********************************
  125.  
  126.     /**
  127.      * Return value if cancel is chosen.
  128.      */
  129.     public static final int CANCEL_OPTION = 1;
  130.  
  131.     /**
  132.      * Return value if approve (yes, ok) is chosen.
  133.      */
  134.     public static final int APPROVE_OPTION = 0;
  135.  
  136.     /**
  137.      * Return value if an error occurred.
  138.      */
  139.     public static final int ERROR_OPTION = -1;
  140.  
  141.  
  142.     // **********************************
  143.     // ***** JFileChooser properties *****
  144.     // **********************************
  145.  
  146.  
  147.     /** Instruction to display only files. */
  148.     public static final int FILES_ONLY = 0;
  149.  
  150.     /** Instruction to display only directories. */
  151.     public static final int DIRECTORIES_ONLY = 1;
  152.  
  153.     /** Instruction to display both files and directories. */
  154.     public static final int FILES_AND_DIRECTORIES = 2;
  155.  
  156.     /** Instruction to cancel the current selection. */
  157.     public static final String CANCEL_SELECTION = "CancelSelection";
  158.  
  159.     /**
  160.      * Instruction to approve the current selection
  161.      * (same as pressing yes or ok).
  162.      */
  163.     public static final String APPROVE_SELECTION = "ApproveSelection";
  164.  
  165.     /** Identifies change in the text on the approve (yes, ok) button. */
  166.     public static final String APPROVE_BUTTON_TEXT_CHANGED_PROPERTY = "ApproveButtonTextChangedProperty";
  167.  
  168.     /**
  169.      * Identifies change in the tooltip text for the approve (yes, ok)
  170.      * button.
  171.      */
  172.     public static final String APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY = "ApproveButtonToolTipTextChangedProperty";
  173.  
  174.     /** Identifies change in the mnemonic for the approve (yes, ok) button. */
  175.     public static final String APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY = "ApproveButtonMnemonicChangedProperty";
  176.  
  177.     /** Instruction to display the control buttons. */
  178.     public static final String CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY = "ControlButtonsAreShownChangedProperty";
  179.  
  180.     /** Identifies user's directory change. */
  181.     public static final String DIRECTORY_CHANGED_PROPERTY = "directoryChanged";
  182.  
  183.     /** Identifies change in user's single-file selection. */
  184.     public static final String SELECTED_FILE_CHANGED_PROPERTY = "SelectedFileChangedProperty";
  185.  
  186.     /** Identifies change in user's multiple-file selection. */
  187.     public static final String SELECTED_FILES_CHANGED_PROPERTY = "SelectedFilesChangedProperty";
  188.  
  189.     /** Enables multiple-file selections. */
  190.     public static final String MULTI_SELECTION_ENABLED_CHANGED_PROPERTY = "MultiSelectionEnabledChangedProperty";
  191.  
  192.     /**
  193.      * Says that a different object is being used to find available drives
  194.      * on the system.
  195.      */
  196.     public static final String FILE_SYSTEM_VIEW_CHANGED_PROPERTY = "FileSystemViewChanged";
  197.  
  198.     /**
  199.      * Says that a different object is being used to retrieve file
  200.      * information.
  201.      */
  202.     public static final String FILE_VIEW_CHANGED_PROPERTY = "fileViewChanged";
  203.  
  204.     /** Identifies a change in the display-hidden-files property. */
  205.     public static final String FILE_HIDING_CHANGED_PROPERTY = "FileHidingChanged";
  206.  
  207.     /** User changed the kind of files to display. */
  208.     public static final String FILE_FILTER_CHANGED_PROPERTY = "fileFilterChanged";
  209.  
  210.     /**
  211.      * Identifies a change in the kind of selection (single,
  212.      * multiple, etc.).
  213.      */
  214.     public static final String FILE_SELECTION_MODE_CHANGED_PROPERTY = "fileSelectionChanged";
  215.  
  216.     /**
  217.      * Says that a different accessory component is in use
  218.      * (for example, to preview files).
  219.      */
  220.     public static final String ACCESSORY_CHANGED_PROPERTY = "AccessoryChangedProperty";
  221.  
  222.     /**
  223.      * Identifies whether a the AcceptAllFileFilter is used or not.
  224.      */
  225.     public static final String ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY = "acceptAllFileFilterUsedChanged";
  226.  
  227.     /** Identifies a change in the dialog title. */
  228.     public static final String DIALOG_TITLE_CHANGED_PROPERTY = "DialogTitleChangedProperty";
  229.  
  230.     /**
  231.      * Identifies a change in the type of files displayed (files only,
  232.      * directories only, or both files and directories).
  233.      */
  234.     public static final String DIALOG_TYPE_CHANGED_PROPERTY = "DialogTypeChangedProperty";
  235.  
  236.     /**
  237.      * Identifies a change in the list of predefined file filters
  238.      * the user can choose from.
  239.      */
  240.     public static final String CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY = "ChoosableFileFilterChangedProperty";
  241.  
  242.     // ******************************
  243.     // ***** instance variables *****
  244.     // ******************************
  245.  
  246.     private String dialogTitle = null;
  247.     private String approveButtonText = null;
  248.     private String approveButtonToolTipText = null;
  249.     private int approveButtonMnemonic = 0;
  250.  
  251.     private Vector<FileFilter> filters = new Vector<FileFilter>(5);
  252.     private JDialog dialog = null;
  253.     private int dialogType = OPEN_DIALOG;
  254.     private int returnValue = ERROR_OPTION;
  255.     private JComponent accessory = null;
  256.  
  257.     private FileView fileView = null;
  258.  
  259.     private boolean controlsShown = true;
  260.  
  261.     private boolean useFileHiding = true;
  262.     private static final String SHOW_HIDDEN_PROP = "awt.file.showHiddenFiles";
  263.  
  264.     // Listens to changes in the native setting for showing hidden files.
  265.     // The Listener is removed and the native setting is ignored if
  266.     // setFileHidingEnabled() is ever called.
  267.     private transient PropertyChangeListener showFilesListener = null;
  268.  
  269.     private int fileSelectionMode = FILES_ONLY;
  270.  
  271.     private boolean multiSelectionEnabled = false;
  272.  
  273.     private boolean useAcceptAllFileFilter = true;
  274.  
  275.     private boolean dragEnabled = false;
  276.  
  277.     private FileFilter fileFilter = null;
  278.  
  279.     private FileSystemView fileSystemView = null;
  280.  
  281.     private File currentDirectory = null;
  282.     private File selectedFile = null;
  283.     private File[] selectedFiles;
  284.  
  285.     // *************************************
  286.     // ***** JFileChooser Constructors *****
  287.     // *************************************
  288.  
  289.     /**
  290.      * Constructs a <code>JFileChooser</code> pointing to the user's
  291.      * default directory. This default depends on the operating system.
  292.      * It is typically the "My Documents" folder on Windows, and the
  293.      * user's home directory on Unix.
  294.      */
  295.     public JFileChooser() {
  296.         this((File) null, (FileSystemView) null);
  297.     }
  298.  
  299.     /**
  300.      * Constructs a <code>JFileChooser</code> using the given path.
  301.      * Passing in a <code>null</code>
  302.      * string causes the file chooser to point to the user's default directory.
  303.      * This default depends on the operating system. It is
  304.      * typically the "My Documents" folder on Windows, and the user's
  305.      * home directory on Unix.
  306.      *
  307.      * @param currentDirectoryPath  a <code>String</code> giving the path
  308.      *                          to a file or directory
  309.      */
  310.     public JFileChooser(String currentDirectoryPath) {
  311.         this(currentDirectoryPath, (FileSystemView) null);
  312.     }
  313.  
  314.     /**
  315.      * Constructs a <code>JFileChooser</code> using the given <code>File</code>
  316.      * as the path. Passing in a <code>null</code> file
  317.      * causes the file chooser to point to the user's default directory.
  318.      * This default depends on the operating system. It is
  319.      * typically the "My Documents" folder on Windows, and the user's
  320.      * home directory on Unix.
  321.      *
  322.      * @param currentDirectory  a <code>File</code> object specifying
  323.      *                          the path to a file or directory
  324.      */
  325.     public JFileChooser(File currentDirectory) {
  326.         this(currentDirectory, (FileSystemView) null);
  327.     }
  328.  
  329.     /**
  330.      * Constructs a <code>JFileChooser</code> using the given
  331.      * <code>FileSystemView</code>.
  332.      */
  333.     public JFileChooser(FileSystemView fsv) {
  334.         this((File) null, fsv);
  335.     }
  336.  
  337.  
  338.     /**
  339.      * Constructs a <code>JFileChooser</code> using the given current directory
  340.      * and <code>FileSystemView</code>.
  341.      */
  342.     public JFileChooser(File currentDirectory, FileSystemView fsv) {
  343.         setup(fsv);
  344.         setCurrentDirectory(currentDirectory);
  345.     }
  346.  
  347.     /**
  348.      * Constructs a <code>JFileChooser</code> using the given current directory
  349.      * path and <code>FileSystemView</code>.
  350.      */
  351.     public JFileChooser(String currentDirectoryPath, FileSystemView fsv) {
  352.         setup(fsv);
  353.         if(currentDirectoryPath == null) {
  354.             setCurrentDirectory(null);
  355.         } else {
  356.             setCurrentDirectory(fileSystemView.createFileObject(currentDirectoryPath));
  357.         }
  358.     }
  359.  
  360.     /**
  361.      * Performs common constructor initialization and setup.
  362.      */
  363.     protected void setup(FileSystemView view) {
  364.         installShowFilesListener();
  365.         installHierarchyListener();
  366.  
  367.         if(view == null) {
  368.             view = FileSystemView.getFileSystemView();
  369.         }
  370.         setFileSystemView(view);
  371.         updateUI();
  372.         if(isAcceptAllFileFilterUsed()) {
  373.             setFileFilter(getAcceptAllFileFilter());
  374.         }
  375.         enableEvents(AWTEvent.MOUSE_EVENT_MASK);
  376.     }
  377.  
  378.     private void installHierarchyListener() {
  379.         addHierarchyListener(new HierarchyListener() {
  380.             @Override
  381.             public void hierarchyChanged(HierarchyEvent e) {
  382.                 if ((e.getChangeFlags() & HierarchyEvent.PARENT_CHANGED)
  383.                         == HierarchyEvent.PARENT_CHANGED) {
  384.                     JFileChooser fc = JFileChooser.this;
  385.                     JRootPane rootPane = SwingUtilities.getRootPane(fc);
  386.                     if (rootPane != null) {
  387.                         rootPane.setDefaultButton(fc.getUI().getDefaultButton(fc));
  388.                     }
  389.                 }
  390.             }
  391.         });
  392.     }
  393.  
  394.     private void installShowFilesListener() {
  395.         // Track native setting for showing hidden files
  396.         Toolkit tk = Toolkit.getDefaultToolkit();
  397.         Object showHiddenProperty = tk.getDesktopProperty(SHOW_HIDDEN_PROP);
  398.         if (showHiddenProperty instanceof Boolean) {
  399.             useFileHiding = !((Boolean)showHiddenProperty).booleanValue();
  400.             showFilesListener = new WeakPCL(this);
  401.             tk.addPropertyChangeListener(SHOW_HIDDEN_PROP, showFilesListener);
  402.         }
  403.     }
  404.  
  405.     /**
  406.      * Sets the <code>dragEnabled</code> property,
  407.      * which must be <code>true</code> to enable
  408.      * automatic drag handling (the first part of drag and drop)
  409.      * on this component.
  410.      * The <code>transferHandler</code> property needs to be set
  411.      * to a non-<code>null</code> value for the drag to do
  412.      * anything.  The default value of the <code>dragEnabled</code>
  413.      * property
  414.      * is <code>false</code>.
  415.      *
  416.      * <p>
  417.      *
  418.      * When automatic drag handling is enabled,
  419.      * most look and feels begin a drag-and-drop operation
  420.      * whenever the user presses the mouse button over an item
  421.      * and then moves the mouse a few pixels.
  422.      * Setting this property to <code>true</code>
  423.      * can therefore have a subtle effect on
  424.      * how selections behave.
  425.      *
  426.      * <p>
  427.      *
  428.      * Some look and feels might not support automatic drag and drop;
  429.      * they will ignore this property.  You can work around such
  430.      * look and feels by modifying the component
  431.      * to directly call the <code>exportAsDrag</code> method of a
  432.      * <code>TransferHandler</code>.
  433.      *
  434.      * @param b the value to set the <code>dragEnabled</code> property to
  435.      * @exception HeadlessException if
  436.      *            <code>b</code> is <code>true</code> and
  437.      *            <code>GraphicsEnvironment.isHeadless()</code>
  438.      *            returns <code>true</code>
  439.      * @see java.awt.GraphicsEnvironment#isHeadless
  440.      * @see #getDragEnabled
  441.      * @see #setTransferHandler
  442.      * @see TransferHandler
  443.      * @since 1.4
  444.      *
  445.      * @beaninfo
  446.      *  description: determines whether automatic drag handling is enabled
  447.      *        bound: false
  448.      */
  449.     public void setDragEnabled(boolean b) {
  450.         if (b && GraphicsEnvironment.isHeadless()) {
  451.             throw new HeadlessException();
  452.         }
  453.         dragEnabled = b;
  454.     }
  455.  
  456.     /**
  457.      * Gets the value of the <code>dragEnabled</code> property.
  458.      *
  459.      * @return  the value of the <code>dragEnabled</code> property
  460.      * @see #setDragEnabled
  461.      * @since 1.4
  462.      */
  463.     public boolean getDragEnabled() {
  464.         return dragEnabled;
  465.     }
  466.  
  467.     // *****************************
  468.     // ****** File Operations ******
  469.     // *****************************
  470.  
  471.     /**
  472.      * Returns the selected file. This can be set either by the
  473.      * programmer via <code>setSelectedFile</code> or by a user action, such as
  474.      * either typing the filename into the UI or selecting the
  475.      * file from a list in the UI.
  476.      *
  477.      * @see #setSelectedFile
  478.      * @return the selected file
  479.      */
  480.     public File getSelectedFile() {
  481.         return selectedFile;
  482.     }
  483.  
  484.     /**
  485.      * Sets the selected file. If the file's parent directory is
  486.      * not the current directory, changes the current directory
  487.      * to be the file's parent directory.
  488.      *
  489.      * @beaninfo
  490.      *   preferred: true
  491.      *       bound: true
  492.      *
  493.      * @see #getSelectedFile
  494.      *
  495.      * @param file the selected file
  496.      */
  497.     public void setSelectedFile(File file) {
  498.         File oldValue = selectedFile;
  499.         selectedFile = file;
  500.         if(selectedFile != null) {
  501.             if (file.isAbsolute() && !getFileSystemView().isParent(getCurrentDirectory(), selectedFile)) {
  502.                 setCurrentDirectory(selectedFile.getParentFile());
  503.             }
  504.             if (!isMultiSelectionEnabled() || selectedFiles == null || selectedFiles.length == 1) {
  505.                 ensureFileIsVisible(selectedFile);
  506.             }
  507.         }
  508.         firePropertyChange(SELECTED_FILE_CHANGED_PROPERTY, oldValue, selectedFile);
  509.     }
  510.  
  511.     /**
  512.      * Returns a list of selected files if the file chooser is
  513.      * set to allow multiple selection.
  514.      */
  515.     public File[] getSelectedFiles() {
  516.         if(selectedFiles == null) {
  517.             return new File[0];
  518.         } else {
  519.             return selectedFiles.clone();
  520.         }
  521.     }
  522.  
  523.     /**
  524.      * Sets the list of selected files if the file chooser is
  525.      * set to allow multiple selection.
  526.      *
  527.      * @beaninfo
  528.      *       bound: true
  529.      * description: The list of selected files if the chooser is in multiple selection mode.
  530.      */
  531.     public void setSelectedFiles(File[] selectedFiles) {
  532.         File[] oldValue = this.selectedFiles;
  533.         if (selectedFiles == null || selectedFiles.length == 0) {
  534.             selectedFiles = null;
  535.             this.selectedFiles = null;
  536.             setSelectedFile(null);
  537.         } else {
  538.             this.selectedFiles = selectedFiles.clone();
  539.             setSelectedFile(this.selectedFiles[0]);
  540.         }
  541.         firePropertyChange(SELECTED_FILES_CHANGED_PROPERTY, oldValue, selectedFiles);
  542.     }
  543.  
  544.     /**
  545.      * Returns the current directory.
  546.      *
  547.      * @return the current directory
  548.      * @see #setCurrentDirectory
  549.      */
  550.     public File getCurrentDirectory() {
  551.         return currentDirectory;
  552.     }
  553.  
  554.     /**
  555.      * Sets the current directory. Passing in <code>null</code> sets the
  556.      * file chooser to point to the user's default directory.
  557.      * This default depends on the operating system. It is
  558.      * typically the "My Documents" folder on Windows, and the user's
  559.      * home directory on Unix.
  560.      *
  561.      * If the file passed in as <code>currentDirectory</code> is not a
  562.      * directory, the parent of the file will be used as the currentDirectory.
  563.      * If the parent is not traversable, then it will walk up the parent tree
  564.      * until it finds a traversable directory, or hits the root of the
  565.      * file system.
  566.      *
  567.      * @beaninfo
  568.      *   preferred: true
  569.      *       bound: true
  570.      * description: The directory that the JFileChooser is showing files of.
  571.      *
  572.      * @param dir the current directory to point to
  573.      * @see #getCurrentDirectory
  574.      */
  575.     public void setCurrentDirectory(File dir) {
  576.         File oldValue = currentDirectory;
  577.  
  578.         if (dir != null && !dir.exists()) {
  579.             dir = currentDirectory;
  580.         }
  581.         if (dir == null) {
  582.             dir = getFileSystemView().getDefaultDirectory();
  583.         }
  584.         if (currentDirectory != null) {
  585.             /* Verify the toString of object */
  586.             if (this.currentDirectory.equals(dir)) {
  587.                 return;
  588.             }
  589.         }
  590.  
  591.         File prev = null;
  592.         while (!isTraversable(dir) && prev != dir) {
  593.             prev = dir;
  594.             dir = getFileSystemView().getParentDirectory(dir);
  595.         }
  596.         currentDirectory = dir;
  597.  
  598.         firePropertyChange(DIRECTORY_CHANGED_PROPERTY, oldValue, currentDirectory);
  599.     }
  600.  
  601.     /**
  602.      * Changes the directory to be set to the parent of the
  603.      * current directory.
  604.      *
  605.      * @see #getCurrentDirectory
  606.      */
  607.     public void changeToParentDirectory() {
  608.         selectedFile = null;
  609.         File oldValue = getCurrentDirectory();
  610.         setCurrentDirectory(getFileSystemView().getParentDirectory(oldValue));
  611.     }
  612.  
  613.     /**
  614.      * Tells the UI to rescan its files list from the current directory.
  615.      */
  616.     public void rescanCurrentDirectory() {
  617.         getUI().rescanCurrentDirectory(this);
  618.     }
  619.  
  620.     /**
  621.      * Makes sure that the specified file is viewable, and
  622.      * not hidden.
  623.      *
  624.      * @param f  a File object
  625.      */
  626.     public void ensureFileIsVisible(File f) {
  627.         getUI().ensureFileIsVisible(this, f);
  628.     }
  629.  
  630.     // **************************************
  631.     // ***** JFileChooser Dialog methods *****
  632.     // **************************************
  633.  
  634.     /**
  635.      * Pops up an "Open File" file chooser dialog. Note that the
  636.      * text that appears in the approve button is determined by
  637.      * the L&amp;F.
  638.      *
  639.      * @param    parent  the parent component of the dialog,
  640.      *                  can be <code>null</code>;
  641.      *                  see <code>showDialog</code> for details
  642.      * @return   the return state of the file chooser on popdown:
  643.      * <ul>
  644.      * <li>JFileChooser.CANCEL_OPTION
  645.      * <li>JFileChooser.APPROVE_OPTION
  646.      * <li>JFileChooser.ERROR_OPTION if an error occurs or the
  647.      *                  dialog is dismissed
  648.      * </ul>
  649.      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
  650.      * returns true.
  651.      * @see java.awt.GraphicsEnvironment#isHeadless
  652.      * @see #showDialog
  653.      */
  654.     public int showOpenDialog(Component parent) throws HeadlessException {
  655.         setDialogType(OPEN_DIALOG);
  656.         return showDialog(parent, null);
  657.     }
  658.  
  659.     /**
  660.      * Pops up a "Save File" file chooser dialog. Note that the
  661.      * text that appears in the approve button is determined by
  662.      * the L&amp;F.
  663.      *
  664.      * @param    parent  the parent component of the dialog,
  665.      *                  can be <code>null</code>;
  666.      *                  see <code>showDialog</code> for details
  667.      * @return   the return state of the file chooser on popdown:
  668.      * <ul>
  669.      * <li>JFileChooser.CANCEL_OPTION
  670.      * <li>JFileChooser.APPROVE_OPTION
  671.      * <li>JFileChooser.ERROR_OPTION if an error occurs or the
  672.      *                  dialog is dismissed
  673.      * </ul>
  674.      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
  675.      * returns true.
  676.      * @see java.awt.GraphicsEnvironment#isHeadless
  677.      * @see #showDialog
  678.      */
  679.     public int showSaveDialog(Component parent) throws HeadlessException {
  680.         setDialogType(SAVE_DIALOG);
  681.         return showDialog(parent, null);
  682.     }
  683.  
  684.     /**
  685.      * Pops a custom file chooser dialog with a custom approve button.
  686.      * For example, the following code
  687.      * pops up a file chooser with a "Run Application" button
  688.      * (instead of the normal "Save" or "Open" button):
  689.      * <pre>
  690.      * filechooser.showDialog(parentFrame, "Run Application");
  691.      * </pre>
  692.      *
  693.      * Alternatively, the following code does the same thing:
  694.      * <pre>
  695.      *    JFileChooser chooser = new JFileChooser(null);
  696.      *    chooser.setApproveButtonText("Run Application");
  697.      *    chooser.showDialog(parentFrame, null);
  698.      * </pre>
  699.      *
  700.      * <!--PENDING(jeff) - the following method should be added to the api:
  701.      *      showDialog(Component parent);-->
  702.      * <!--PENDING(kwalrath) - should specify modality and what
  703.      *      "depends" means.-->
  704.      *
  705.      * <p>
  706.      *
  707.      * The <code>parent</code> argument determines two things:
  708.      * the frame on which the open dialog depends and
  709.      * the component whose position the look and feel
  710.      * should consider when placing the dialog.  If the parent
  711.      * is a <code>Frame</code> object (such as a <code>JFrame</code>)
  712.      * then the dialog depends on the frame and
  713.      * the look and feel positions the dialog
  714.      * relative to the frame (for example, centered over the frame).
  715.      * If the parent is a component, then the dialog
  716.      * depends on the frame containing the component,
  717.      * and is positioned relative to the component
  718.      * (for example, centered over the component).
  719.      * If the parent is <code>null</code>, then the dialog depends on
  720.      * no visible window, and it's placed in a
  721.      * look-and-feel-dependent position
  722.      * such as the center of the screen.
  723.      *
  724.      * @param   parent  the parent component of the dialog;
  725.      *                  can be <code>null</code>
  726.      * @param   approveButtonText the text of the <code>ApproveButton</code>
  727.      * @return  the return state of the file chooser on popdown:
  728.      * <ul>
  729.      * <li>JFileChooser.CANCEL_OPTION
  730.      * <li>JFileChooser.APPROVE_OPTION
  731.      * <li>JFileChooser.ERROR_OPTION if an error occurs or the
  732.      *                  dialog is dismissed
  733.      * </ul>
  734.      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
  735.      * returns true.
  736.      * @see java.awt.GraphicsEnvironment#isHeadless
  737.      */
  738.     public int showDialog(Component parent, String approveButtonText)
  739.         throws HeadlessException {
  740.         if (dialog != null) {
  741.             // Prevent to show second instance of dialog if the previous one still exists
  742.             return JFileChooser.ERROR_OPTION;
  743.         }
  744.  
  745.         if(approveButtonText != null) {
  746.             setApproveButtonText(approveButtonText);
  747.             setDialogType(CUSTOM_DIALOG);
  748.         }
  749.         dialog = createDialog(parent);
  750.         dialog.addWindowListener(new WindowAdapter() {
  751.             public void windowClosing(WindowEvent e) {
  752.                 returnValue = CANCEL_OPTION;
  753.             }
  754.         });
  755.         returnValue = ERROR_OPTION;
  756.         rescanCurrentDirectory();
  757.  
  758.         dialog.show();
  759.         firePropertyChange("JFileChooserDialogIsClosingProperty", dialog, null);
  760.  
  761.         // Remove all components from dialog. The MetalFileChooserUI.installUI() method (and other LAFs)
  762.         // registers AWT listener for dialogs and produces memory leaks. It happens when
  763.         // installUI invoked after the showDialog method.
  764.         dialog.getContentPane().removeAll();
  765.         dialog.dispose();
  766.         dialog = null;
  767.         return returnValue;
  768.     }
  769.  
  770.     /**
  771.      * Creates and returns a new <code>JDialog</code> wrapping
  772.      * <code>this</code> centered on the <code>parent</code>
  773.      * in the <code>parent</code>'s frame.
  774.      * This method can be overriden to further manipulate the dialog,
  775.      * to disable resizing, set the location, etc. Example:
  776.      * <pre>
  777.      *     class MyFileChooser extends JFileChooser {
  778.      *         protected JDialog createDialog(Component parent) throws HeadlessException {
  779.      *             JDialog dialog = super.createDialog(parent);
  780.      *             dialog.setLocation(300, 200);
  781.      *             dialog.setResizable(false);
  782.      *             return dialog;
  783.      *         }
  784.      *     }
  785.      * </pre>
  786.      *
  787.      * @param   parent  the parent component of the dialog;
  788.      *                  can be <code>null</code>
  789.      * @return a new <code>JDialog</code> containing this instance
  790.      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
  791.      * returns true.
  792.      * @see java.awt.GraphicsEnvironment#isHeadless
  793.      * @since 1.4
  794.      */
  795.     protected JDialog createDialog(Component parent) throws HeadlessException {
  796.         FileChooserUI ui = getUI();
  797.         String title = ui.getDialogTitle(this);
  798.         putClientProperty(AccessibleContext.ACCESSIBLE_DESCRIPTION_PROPERTY,
  799.                           title);
  800.  
  801.         JDialog dialog;
  802.         Window window = JOptionPane.getWindowForComponent(parent);
  803.         if (window instanceof Frame) {
  804.             dialog = new JDialog((Frame)window, title, true);
  805.         } else {
  806.             dialog = new JDialog((Dialog)window, title, true);
  807.         }
  808.         dialog.setComponentOrientation(this.getComponentOrientation());
  809.  
  810.         Container contentPane = dialog.getContentPane();
  811.         contentPane.setLayout(new BorderLayout());
  812.         contentPane.add(this, BorderLayout.CENTER);
  813.  
  814.         if (JDialog.isDefaultLookAndFeelDecorated()) {
  815.             boolean supportsWindowDecorations =
  816.             UIManager.getLookAndFeel().getSupportsWindowDecorations();
  817.             if (supportsWindowDecorations) {
  818.                 dialog.getRootPane().setWindowDecorationStyle(JRootPane.FILE_CHOOSER_DIALOG);
  819.             }
  820.         }
  821.         dialog.pack();
  822.         dialog.setLocationRelativeTo(parent);
  823.  
  824.         return dialog;
  825.     }
  826.  
  827.     // **************************
  828.     // ***** Dialog Options *****
  829.     // **************************
  830.  
  831.     /**
  832.      * Returns the value of the <code>controlButtonsAreShown</code>
  833.      * property.
  834.      *
  835.      * @return   the value of the <code>controlButtonsAreShown</code>
  836.      *     property
  837.      *
  838.      * @see #setControlButtonsAreShown
  839.      * @since 1.3
  840.      */
  841.     public boolean getControlButtonsAreShown() {
  842.         return controlsShown;
  843.     }
  844.  
  845.  
  846.     /**
  847.      * Sets the property
  848.      * that indicates whether the <i>approve</i> and <i>cancel</i>
  849.      * buttons are shown in the file chooser.  This property
  850.      * is <code>true</code> by default.  Look and feels
  851.      * that always show these buttons will ignore the value
  852.      * of this property.
  853.      * This method fires a property-changed event,
  854.      * using the string value of
  855.      * <code>CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY</code>
  856.      * as the name of the property.
  857.      *
  858.      * @param b <code>false</code> if control buttons should not be
  859.      *    shown; otherwise, <code>true</code>
  860.      *
  861.      * @beaninfo
  862.      *   preferred: true
  863.      *       bound: true
  864.      * description: Sets whether the approve &amp; cancel buttons are shown.
  865.      *
  866.      * @see #getControlButtonsAreShown
  867.      * @see #CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY
  868.      * @since 1.3
  869.      */
  870.     public void setControlButtonsAreShown(boolean b) {
  871.         if(controlsShown == b) {
  872.             return;
  873.         }
  874.         boolean oldValue = controlsShown;
  875.         controlsShown = b;
  876.         firePropertyChange(CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY, oldValue, controlsShown);
  877.     }
  878.  
  879.     /**
  880.      * Returns the type of this dialog.  The default is
  881.      * <code>JFileChooser.OPEN_DIALOG</code>.
  882.      *
  883.      * @return   the type of dialog to be displayed:
  884.      * <ul>
  885.      * <li>JFileChooser.OPEN_DIALOG
  886.      * <li>JFileChooser.SAVE_DIALOG
  887.      * <li>JFileChooser.CUSTOM_DIALOG
  888.      * </ul>
  889.      *
  890.      * @see #setDialogType
  891.      */
  892.     public int getDialogType() {
  893.         return dialogType;
  894.     }
  895.  
  896.     /**
  897.      * Sets the type of this dialog. Use <code>OPEN_DIALOG</code> when you
  898.      * want to bring up a file chooser that the user can use to open a file.
  899.      * Likewise, use <code>SAVE_DIALOG</code> for letting the user choose
  900.      * a file for saving.
  901.      * Use <code>CUSTOM_DIALOG</code> when you want to use the file
  902.      * chooser in a context other than "Open" or "Save".
  903.      * For instance, you might want to bring up a file chooser that allows
  904.      * the user to choose a file to execute. Note that you normally would not
  905.      * need to set the <code>JFileChooser</code> to use
  906.      * <code>CUSTOM_DIALOG</code>
  907.      * since a call to <code>setApproveButtonText</code> does this for you.
  908.      * The default dialog type is <code>JFileChooser.OPEN_DIALOG</code>.
  909.      *
  910.      * @param dialogType the type of dialog to be displayed:
  911.      * <ul>
  912.      * <li>JFileChooser.OPEN_DIALOG
  913.      * <li>JFileChooser.SAVE_DIALOG
  914.      * <li>JFileChooser.CUSTOM_DIALOG
  915.      * </ul>
  916.      *
  917.      * @exception IllegalArgumentException if <code>dialogType</code> is
  918.      *                          not legal
  919.      * @beaninfo
  920.      *   preferred: true
  921.      *       bound: true
  922.      * description: The type (open, save, custom) of the JFileChooser.
  923.      *        enum:
  924.      *              OPEN_DIALOG JFileChooser.OPEN_DIALOG
  925.      *              SAVE_DIALOG JFileChooser.SAVE_DIALOG
  926.      *              CUSTOM_DIALOG JFileChooser.CUSTOM_DIALOG
  927.      *
  928.      * @see #getDialogType
  929.      * @see #setApproveButtonText
  930.      */
  931.     // PENDING(jeff) - fire button text change property
  932.     public void setDialogType(int dialogType) {
  933.         if(this.dialogType == dialogType) {
  934.             return;
  935.         }
  936.         if(!(dialogType == OPEN_DIALOG || dialogType == SAVE_DIALOG || dialogType == CUSTOM_DIALOG)) {
  937.             throw new IllegalArgumentException("Incorrect Dialog Type: " + dialogType);
  938.         }
  939.         int oldValue = this.dialogType;
  940.         this.dialogType = dialogType;
  941.         if(dialogType == OPEN_DIALOG || dialogType == SAVE_DIALOG) {
  942.             setApproveButtonText(null);
  943.         }
  944.         firePropertyChange(DIALOG_TYPE_CHANGED_PROPERTY, oldValue, dialogType);
  945.     }
  946.  
  947.     /**
  948.      * Sets the string that goes in the <code>JFileChooser</code> window's
  949.      * title bar.
  950.      *
  951.      * @param dialogTitle the new <code>String</code> for the title bar
  952.      *
  953.      * @beaninfo
  954.      *   preferred: true
  955.      *       bound: true
  956.      * description: The title of the JFileChooser dialog window.
  957.      *
  958.      * @see #getDialogTitle
  959.      *
  960.      */
  961.     public void setDialogTitle(String dialogTitle) {
  962.         String oldValue = this.dialogTitle;
  963.         this.dialogTitle = dialogTitle;
  964.         if(dialog != null) {
  965.             dialog.setTitle(dialogTitle);
  966.         }
  967.         firePropertyChange(DIALOG_TITLE_CHANGED_PROPERTY, oldValue, dialogTitle);
  968.     }
  969.  
  970.     /**
  971.      * Gets the string that goes in the <code>JFileChooser</code>'s titlebar.
  972.      *
  973.      * @see #setDialogTitle
  974.      */
  975.     public String getDialogTitle() {
  976.         return dialogTitle;
  977.     }
  978.  
  979.     // ************************************
  980.     // ***** JFileChooser View Options *****
  981.     // ************************************
  982.  
  983.  
  984.  
  985.     /**
  986.      * Sets the tooltip text used in the <code>ApproveButton</code>.
  987.      * If <code>null</code>, the UI object will determine the button's text.
  988.      *
  989.      * @beaninfo
  990.      *   preferred: true
  991.      *       bound: true
  992.      * description: The tooltip text for the ApproveButton.
  993.      *
  994.      * @param toolTipText the tooltip text for the approve button
  995.      * @see #setApproveButtonText
  996.      * @see #setDialogType
  997.      * @see #showDialog
  998.      */
  999.     public void setApproveButtonToolTipText(String toolTipText) {
  1000.         if(approveButtonToolTipText == toolTipText) {
  1001.             return;
  1002.         }
  1003.         String oldValue = approveButtonToolTipText;
  1004.         approveButtonToolTipText = toolTipText;
  1005.         firePropertyChange(APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY, oldValue, approveButtonToolTipText);
  1006.     }
  1007.  
  1008.  
  1009.     /**
  1010.      * Returns the tooltip text used in the <code>ApproveButton</code>.
  1011.      * If <code>null</code>, the UI object will determine the button's text.
  1012.      *
  1013.      * @return the tooltip text used for the approve button
  1014.      *
  1015.      * @see #setApproveButtonText
  1016.      * @see #setDialogType
  1017.      * @see #showDialog
  1018.      */
  1019.     public String getApproveButtonToolTipText() {
  1020.         return approveButtonToolTipText;
  1021.     }
  1022.  
  1023.     /**
  1024.      * Returns the approve button's mnemonic.
  1025.      * @return an integer value for the mnemonic key
  1026.      *
  1027.      * @see #setApproveButtonMnemonic
  1028.      */
  1029.     public int getApproveButtonMnemonic() {
  1030.         return approveButtonMnemonic;
  1031.     }
  1032.  
  1033.     /**
  1034.      * Sets the approve button's mnemonic using a numeric keycode.
  1035.      *
  1036.      * @param mnemonic  an integer value for the mnemonic key
  1037.      *
  1038.      * @beaninfo
  1039.      *   preferred: true
  1040.      *       bound: true
  1041.      * description: The mnemonic key accelerator for the ApproveButton.
  1042.      *
  1043.      * @see #getApproveButtonMnemonic
  1044.      */
  1045.     public void setApproveButtonMnemonic(int mnemonic) {
  1046.         if(approveButtonMnemonic == mnemonic) {
  1047.            return;
  1048.         }
  1049.         int oldValue = approveButtonMnemonic;
  1050.         approveButtonMnemonic = mnemonic;
  1051.         firePropertyChange(APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY, oldValue, approveButtonMnemonic);
  1052.     }
  1053.  
  1054.     /**
  1055.      * Sets the approve button's mnemonic using a character.
  1056.      * @param mnemonic  a character value for the mnemonic key
  1057.      *
  1058.      * @see #getApproveButtonMnemonic
  1059.      */
  1060.     public void setApproveButtonMnemonic(char mnemonic) {
  1061.         int vk = (int) mnemonic;
  1062.         if(vk >= 'a' && vk <='z') {
  1063.             vk -= ('a' - 'A');
  1064.         }
  1065.         setApproveButtonMnemonic(vk);
  1066.     }
  1067.  
  1068.  
  1069.     /**
  1070.      * Sets the text used in the <code>ApproveButton</code> in the
  1071.      * <code>FileChooserUI</code>.
  1072.      *
  1073.      * @beaninfo
  1074.      *   preferred: true
  1075.      *       bound: true
  1076.      * description: The text that goes in the ApproveButton.
  1077.      *
  1078.      * @param approveButtonText the text used in the <code>ApproveButton</code>
  1079.      *
  1080.      * @see #getApproveButtonText
  1081.      * @see #setDialogType
  1082.      * @see #showDialog
  1083.      */
  1084.     // PENDING(jeff) - have ui set this on dialog type change
  1085.     public void setApproveButtonText(String approveButtonText) {
  1086.         if(this.approveButtonText == approveButtonText) {
  1087.             return;
  1088.         }
  1089.         String oldValue = this.approveButtonText;
  1090.         this.approveButtonText = approveButtonText;
  1091.         firePropertyChange(APPROVE_BUTTON_TEXT_CHANGED_PROPERTY, oldValue, approveButtonText);
  1092.     }
  1093.  
  1094.     /**
  1095.      * Returns the text used in the <code>ApproveButton</code> in the
  1096.      * <code>FileChooserUI</code>.
  1097.      * If <code>null</code>, the UI object will determine the button's text.
  1098.      *
  1099.      * Typically, this would be "Open" or "Save".
  1100.      *
  1101.      * @return the text used in the <code>ApproveButton</code>
  1102.      *
  1103.      * @see #setApproveButtonText
  1104.      * @see #setDialogType
  1105.      * @see #showDialog
  1106.      */
  1107.     public String getApproveButtonText() {
  1108.         return approveButtonText;
  1109.     }
  1110.  
  1111.     /**
  1112.      * Gets the list of user choosable file filters.
  1113.      *
  1114.      * @return a <code>FileFilter</code> array containing all the choosable
  1115.      *         file filters
  1116.      *
  1117.      * @see #addChoosableFileFilter
  1118.      * @see #removeChoosableFileFilter
  1119.      * @see #resetChoosableFileFilters
  1120.      */
  1121.     public FileFilter[] getChoosableFileFilters() {
  1122.         FileFilter[] filterArray = new FileFilter[filters.size()];
  1123.         filters.copyInto(filterArray);
  1124.         return filterArray;
  1125.     }
  1126.  
  1127.     /**
  1128.      * Adds a filter to the list of user choosable file filters.
  1129.      * For information on setting the file selection mode, see
  1130.      * {@link #setFileSelectionMode setFileSelectionMode}.
  1131.      *
  1132.      * @param filter the <code>FileFilter</code> to add to the choosable file
  1133.      *               filter list
  1134.      *
  1135.      * @beaninfo
  1136.      *   preferred: true
  1137.      *       bound: true
  1138.      * description: Adds a filter to the list of user choosable file filters.
  1139.      *
  1140.      * @see #getChoosableFileFilters
  1141.      * @see #removeChoosableFileFilter
  1142.      * @see #resetChoosableFileFilters
  1143.      * @see #setFileSelectionMode
  1144.      */
  1145.     public void addChoosableFileFilter(FileFilter filter) {
  1146.         if(filter != null && !filters.contains(filter)) {
  1147.             FileFilter[] oldValue = getChoosableFileFilters();
  1148.             filters.addElement(filter);
  1149.             firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, oldValue, getChoosableFileFilters());
  1150.             if (fileFilter == null && filters.size() == 1) {
  1151.                 setFileFilter(filter);
  1152.             }
  1153.         }
  1154.     }
  1155.  
  1156.     /**
  1157.      * Removes a filter from the list of user choosable file filters. Returns
  1158.      * true if the file filter was removed.
  1159.      *
  1160.      * @see #addChoosableFileFilter
  1161.      * @see #getChoosableFileFilters
  1162.      * @see #resetChoosableFileFilters
  1163.      */
  1164.     public boolean removeChoosableFileFilter(FileFilter f) {
  1165.         int index = filters.indexOf(f);
  1166.         if (index >= 0) {
  1167.             if(getFileFilter() == f) {
  1168.                 FileFilter aaff = getAcceptAllFileFilter();
  1169.                 if (isAcceptAllFileFilterUsed() && (aaff != f)) {
  1170.                     // choose default filter if it is used
  1171.                     setFileFilter(aaff);
  1172.                 }
  1173.                 else if (index > 0) {
  1174.                     // choose the first filter, because it is not removed
  1175.                     setFileFilter(filters.get(0));
  1176.                 }
  1177.                 else if (filters.size() > 1) {
  1178.                     // choose the second filter, because the first one is removed
  1179.                     setFileFilter(filters.get(1));
  1180.                 }
  1181.                 else {
  1182.                     // no more filters
  1183.                     setFileFilter(null);
  1184.                 }
  1185.             }
  1186.             FileFilter[] oldValue = getChoosableFileFilters();
  1187.             filters.removeElement(f);
  1188.             firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, oldValue, getChoosableFileFilters());
  1189.             return true;
  1190.         } else {
  1191.             return false;
  1192.         }
  1193.     }
  1194.  
  1195.     /**
  1196.      * Resets the choosable file filter list to its starting state. Normally,
  1197.      * this removes all added file filters while leaving the
  1198.      * <code>AcceptAll</code> file filter.
  1199.      *
  1200.      * @see #addChoosableFileFilter
  1201.      * @see #getChoosableFileFilters
  1202.      * @see #removeChoosableFileFilter
  1203.      */
  1204.     public void resetChoosableFileFilters() {
  1205.         FileFilter[] oldValue = getChoosableFileFilters();
  1206.         setFileFilter(null);
  1207.         filters.removeAllElements();
  1208.         if(isAcceptAllFileFilterUsed()) {
  1209.            addChoosableFileFilter(getAcceptAllFileFilter());
  1210.         }
  1211.         firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, oldValue, getChoosableFileFilters());
  1212.     }
  1213.  
  1214.     /**
  1215.      * Returns the <code>AcceptAll</code> file filter.
  1216.      * For example, on Microsoft Windows this would be All Files (*.*).
  1217.      */
  1218.     public FileFilter getAcceptAllFileFilter() {
  1219.         FileFilter filter = null;
  1220.         if(getUI() != null) {
  1221.             filter = getUI().getAcceptAllFileFilter(this);
  1222.         }
  1223.         return filter;
  1224.     }
  1225.  
  1226.    /**
  1227.     * Returns whether the <code>AcceptAll FileFilter</code> is used.
  1228.     * @return true if the <code>AcceptAll FileFilter</code> is used
  1229.     * @see #setAcceptAllFileFilterUsed
  1230.     * @since 1.3
  1231.     */
  1232.     public boolean isAcceptAllFileFilterUsed() {
  1233.         return useAcceptAllFileFilter;
  1234.     }
  1235.  
  1236.    /**
  1237.     * Determines whether the <code>AcceptAll FileFilter</code> is used
  1238.     * as an available choice in the choosable filter list.
  1239.     * If false, the <code>AcceptAll</code> file filter is removed from
  1240.     * the list of available file filters.
  1241.     * If true, the <code>AcceptAll</code> file filter will become the
  1242.     * the actively used file filter.
  1243.     *
  1244.     * @beaninfo
  1245.     *   preferred: true
  1246.     *       bound: true
  1247.     * description: Sets whether the AcceptAll FileFilter is used as an available choice in the choosable filter list.
  1248.     *
  1249.     * @see #isAcceptAllFileFilterUsed
  1250.     * @see #getAcceptAllFileFilter
  1251.     * @see #setFileFilter
  1252.     * @since 1.3
  1253.     */
  1254.     public void setAcceptAllFileFilterUsed(boolean b) {
  1255.         boolean oldValue = useAcceptAllFileFilter;
  1256.         useAcceptAllFileFilter = b;
  1257.         if(!b) {
  1258.             removeChoosableFileFilter(getAcceptAllFileFilter());
  1259.         } else {
  1260.             removeChoosableFileFilter(getAcceptAllFileFilter());
  1261.             addChoosableFileFilter(getAcceptAllFileFilter());
  1262.         }
  1263.         firePropertyChange(ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY, oldValue, useAcceptAllFileFilter);
  1264.     }
  1265.  
  1266.     /**
  1267.      * Returns the accessory component.
  1268.      *
  1269.      * @return this JFileChooser's accessory component, or null
  1270.      * @see #setAccessory
  1271.      */
  1272.     public JComponent getAccessory() {
  1273.         return accessory;
  1274.     }
  1275.  
  1276.     /**
  1277.      * Sets the accessory component. An accessory is often used to show a
  1278.      * preview image of the selected file; however, it can be used for anything
  1279.      * that the programmer wishes, such as extra custom file chooser controls.
  1280.      *
  1281.      * <p>
  1282.      * Note: if there was a previous accessory, you should unregister
  1283.      * any listeners that the accessory might have registered with the
  1284.      * file chooser.
  1285.      *
  1286.      * @beaninfo
  1287.      *   preferred: true
  1288.      *       bound: true
  1289.      * description: Sets the accessory component on the JFileChooser.
  1290.      */
  1291.     public void setAccessory(JComponent newAccessory) {
  1292.         JComponent oldValue = accessory;
  1293.         accessory = newAccessory;
  1294.         firePropertyChange(ACCESSORY_CHANGED_PROPERTY, oldValue, accessory);
  1295.     }
  1296.  
  1297.     /**
  1298.      * Sets the <code>JFileChooser</code> to allow the user to just
  1299.      * select files, just select
  1300.      * directories, or select both files and directories.  The default is
  1301.      * <code>JFilesChooser.FILES_ONLY</code>.
  1302.      *
  1303.      * @param mode the type of files to be displayed:
  1304.      * <ul>
  1305.      * <li>JFileChooser.FILES_ONLY
  1306.      * <li>JFileChooser.DIRECTORIES_ONLY
  1307.      * <li>JFileChooser.FILES_AND_DIRECTORIES
  1308.      * </ul>
  1309.      *
  1310.      * @exception IllegalArgumentException  if <code>mode</code> is an
  1311.      *                          illegal file selection mode
  1312.      * @beaninfo
  1313.      *   preferred: true
  1314.      *       bound: true
  1315.      * description: Sets the types of files that the JFileChooser can choose.
  1316.      *        enum: FILES_ONLY JFileChooser.FILES_ONLY
  1317.      *              DIRECTORIES_ONLY JFileChooser.DIRECTORIES_ONLY
  1318.      *              FILES_AND_DIRECTORIES JFileChooser.FILES_AND_DIRECTORIES
  1319.      *
  1320.      *
  1321.      * @see #getFileSelectionMode
  1322.      */
  1323.     public void setFileSelectionMode(int mode) {
  1324.         if(fileSelectionMode == mode) {
  1325.             return;
  1326.         }
  1327.  
  1328.         if ((mode == FILES_ONLY) || (mode == DIRECTORIES_ONLY) || (mode == FILES_AND_DIRECTORIES)) {
  1329.            int oldValue = fileSelectionMode;
  1330.            fileSelectionMode = mode;
  1331.            firePropertyChange(FILE_SELECTION_MODE_CHANGED_PROPERTY, oldValue, fileSelectionMode);
  1332.         } else {
  1333.            throw new IllegalArgumentException("Incorrect Mode for file selection: " + mode);
  1334.         }
  1335.     }
  1336.  
  1337.     /**
  1338.      * Returns the current file-selection mode.  The default is
  1339.      * <code>JFilesChooser.FILES_ONLY</code>.
  1340.      *
  1341.      * @return the type of files to be displayed, one of the following:
  1342.      * <ul>
  1343.      * <li>JFileChooser.FILES_ONLY
  1344.      * <li>JFileChooser.DIRECTORIES_ONLY
  1345.      * <li>JFileChooser.FILES_AND_DIRECTORIES
  1346.      * </ul>
  1347.      * @see #setFileSelectionMode
  1348.      */
  1349.     public int getFileSelectionMode() {
  1350.         return fileSelectionMode;
  1351.     }
  1352.  
  1353.     /**
  1354.      * Convenience call that determines if files are selectable based on the
  1355.      * current file selection mode.
  1356.      *
  1357.      * @see #setFileSelectionMode
  1358.      * @see #getFileSelectionMode
  1359.      */
  1360.     public boolean isFileSelectionEnabled() {
  1361.         return ((fileSelectionMode == FILES_ONLY) || (fileSelectionMode == FILES_AND_DIRECTORIES));
  1362.     }
  1363.  
  1364.     /**
  1365.      * Convenience call that determines if directories are selectable based
  1366.      * on the current file selection mode.
  1367.      *
  1368.      * @see #setFileSelectionMode
  1369.      * @see #getFileSelectionMode
  1370.      */
  1371.     public boolean isDirectorySelectionEnabled() {
  1372.         return ((fileSelectionMode == DIRECTORIES_ONLY) || (fileSelectionMode == FILES_AND_DIRECTORIES));
  1373.     }
  1374.  
  1375.     /**
  1376.      * Sets the file chooser to allow multiple file selections.
  1377.      *
  1378.      * @param b true if multiple files may be selected
  1379.      * @beaninfo
  1380.      *       bound: true
  1381.      * description: Sets multiple file selection mode.
  1382.      *
  1383.      * @see #isMultiSelectionEnabled
  1384.      */
  1385.     public void setMultiSelectionEnabled(boolean b) {
  1386.         if(multiSelectionEnabled == b) {
  1387.             return;
  1388.         }
  1389.         boolean oldValue = multiSelectionEnabled;
  1390.         multiSelectionEnabled = b;
  1391.         firePropertyChange(MULTI_SELECTION_ENABLED_CHANGED_PROPERTY, oldValue, multiSelectionEnabled);
  1392.     }
  1393.  
  1394.     /**
  1395.      * Returns true if multiple files can be selected.
  1396.      * @return true if multiple files can be selected
  1397.      * @see #setMultiSelectionEnabled
  1398.      */
  1399.     public boolean isMultiSelectionEnabled() {
  1400.         return multiSelectionEnabled;
  1401.     }
  1402.  
  1403.  
  1404.     /**
  1405.      * Returns true if hidden files are not shown in the file chooser;
  1406.      * otherwise, returns false.
  1407.      *
  1408.      * @return the status of the file hiding property
  1409.      * @see #setFileHidingEnabled
  1410.      */
  1411.     public boolean isFileHidingEnabled() {
  1412.         return useFileHiding;
  1413.     }
  1414.  
  1415.     /**
  1416.      * Sets file hiding on or off. If true, hidden files are not shown
  1417.      * in the file chooser. The job of determining which files are
  1418.      * shown is done by the <code>FileView</code>.
  1419.      *
  1420.      * @beaninfo
  1421.      *   preferred: true
  1422.      *       bound: true
  1423.      * description: Sets file hiding on or off.
  1424.      *
  1425.      * @param b the boolean value that determines whether file hiding is
  1426.      *          turned on
  1427.      * @see #isFileHidingEnabled
  1428.      */
  1429.     public void setFileHidingEnabled(boolean b) {
  1430.         // Dump showFilesListener since we'll ignore it from now on
  1431.         if (showFilesListener != null) {
  1432.             Toolkit.getDefaultToolkit().removePropertyChangeListener(SHOW_HIDDEN_PROP, showFilesListener);
  1433.             showFilesListener = null;
  1434.         }
  1435.         boolean oldValue = useFileHiding;
  1436.         useFileHiding = b;
  1437.         firePropertyChange(FILE_HIDING_CHANGED_PROPERTY, oldValue, useFileHiding);
  1438.     }
  1439.  
  1440.     /**
  1441.      * Sets the current file filter. The file filter is used by the
  1442.      * file chooser to filter out files from the user's view.
  1443.      *
  1444.      * @beaninfo
  1445.      *   preferred: true
  1446.      *       bound: true
  1447.      * description: Sets the File Filter used to filter out files of type.
  1448.      *
  1449.      * @param filter the new current file filter to use
  1450.      * @see #getFileFilter
  1451.      */
  1452.     public void setFileFilter(FileFilter filter) {
  1453.         FileFilter oldValue = fileFilter;
  1454.         fileFilter = filter;
  1455.         if (filter != null) {
  1456.             if (isMultiSelectionEnabled() && selectedFiles != null && selectedFiles.length > 0) {
  1457.                 Vector<File> fList = new Vector<File>();
  1458.                 boolean failed = false;
  1459.                 for (File file : selectedFiles) {
  1460.                     if (filter.accept(file)) {
  1461.                         fList.add(file);
  1462.                     } else {
  1463.                         failed = true;
  1464.                     }
  1465.                 }
  1466.                 if (failed) {
  1467.                     setSelectedFiles((fList.size() == 0) ? null : fList.toArray(new File[fList.size()]));
  1468.                 }
  1469.             } else if (selectedFile != null && !filter.accept(selectedFile)) {
  1470.                 setSelectedFile(null);
  1471.             }
  1472.         }
  1473.         firePropertyChange(FILE_FILTER_CHANGED_PROPERTY, oldValue, fileFilter);
  1474.     }
  1475.  
  1476.  
  1477.     /**
  1478.      * Returns the currently selected file filter.
  1479.      *
  1480.      * @return the current file filter
  1481.      * @see #setFileFilter
  1482.      * @see #addChoosableFileFilter
  1483.      */
  1484.     public FileFilter getFileFilter() {
  1485.         return fileFilter;
  1486.     }
  1487.  
  1488.     /**
  1489.      * Sets the file view to used to retrieve UI information, such as
  1490.      * the icon that represents a file or the type description of a file.
  1491.      *
  1492.      * @beaninfo
  1493.      *   preferred: true
  1494.      *       bound: true
  1495.      * description: Sets the File View used to get file type information.
  1496.      *
  1497.      * @see #getFileView
  1498.      */
  1499.     public void setFileView(FileView fileView) {
  1500.         FileView oldValue = this.fileView;
  1501.         this.fileView = fileView;
  1502.         firePropertyChange(FILE_VIEW_CHANGED_PROPERTY, oldValue, fileView);
  1503.     }
  1504.  
  1505.     /**
  1506.      * Returns the current file view.
  1507.      *
  1508.      * @see #setFileView
  1509.      */
  1510.     public FileView getFileView() {
  1511.         return fileView;
  1512.     }
  1513.  
  1514.     // ******************************
  1515.     // *****FileView delegation *****
  1516.     // ******************************
  1517.  
  1518.     // NOTE: all of the following methods attempt to delegate
  1519.     // first to the client set fileView, and if <code>null</code> is returned
  1520.     // (or there is now client defined fileView) then calls the
  1521.     // UI's default fileView.
  1522.  
  1523.     /**
  1524.      * Returns the filename.
  1525.      * @param f the <code>File</code>
  1526.      * @return the <code>String</code> containing the filename for
  1527.      *          <code>f</code>
  1528.      * @see FileView#getName
  1529.      */
  1530.     public String getName(File f) {
  1531.         String filename = null;
  1532.         if(f != null) {
  1533.             if(getFileView() != null) {
  1534.                 filename = getFileView().getName(f);
  1535.             }
  1536.  
  1537.             FileView uiFileView = getUI().getFileView(this);
  1538.  
  1539.             if(filename == null && uiFileView != null) {
  1540.                 filename = uiFileView.getName(f);
  1541.             }
  1542.         }
  1543.         return filename;
  1544.     }
  1545.  
  1546.     /**
  1547.      * Returns the file description.
  1548.      * @param f the <code>File</code>
  1549.      * @return the <code>String</code> containing the file description for
  1550.      *          <code>f</code>
  1551.      * @see FileView#getDescription
  1552.      */
  1553.     public String getDescription(File f) {
  1554.         String description = null;
  1555.         if(f != null) {
  1556.             if(getFileView() != null) {
  1557.                 description = getFileView().getDescription(f);
  1558.             }
  1559.  
  1560.             FileView uiFileView = getUI().getFileView(this);
  1561.  
  1562.             if(description == null && uiFileView != null) {
  1563.                 description = uiFileView.getDescription(f);
  1564.             }
  1565.         }
  1566.         return description;
  1567.     }
  1568.  
  1569.     /**
  1570.      * Returns the file type.
  1571.      * @param f the <code>File</code>
  1572.      * @return the <code>String</code> containing the file type description for
  1573.      *          <code>f</code>
  1574.      * @see FileView#getTypeDescription
  1575.      */
  1576.     public String getTypeDescription(File f) {
  1577.         String typeDescription = null;
  1578.         if(f != null) {
  1579.             if(getFileView() != null) {
  1580.                 typeDescription = getFileView().getTypeDescription(f);
  1581.             }
  1582.  
  1583.             FileView uiFileView = getUI().getFileView(this);
  1584.  
  1585.             if(typeDescription == null && uiFileView != null) {
  1586.                 typeDescription = uiFileView.getTypeDescription(f);
  1587.             }
  1588.         }
  1589.         return typeDescription;
  1590.     }
  1591.  
  1592.     /**
  1593.      * Returns the icon for this file or type of file, depending
  1594.      * on the system.
  1595.      * @param f the <code>File</code>
  1596.      * @return the <code>Icon</code> for this file, or type of file
  1597.      * @see FileView#getIcon
  1598.      */
  1599.     public Icon getIcon(File f) {
  1600.         Icon icon = null;
  1601.         if (f != null) {
  1602.             if(getFileView() != null) {
  1603.                 icon = getFileView().getIcon(f);
  1604.             }
  1605.  
  1606.             FileView uiFileView = getUI().getFileView(this);
  1607.  
  1608.             if(icon == null && uiFileView != null) {
  1609.                 icon = uiFileView.getIcon(f);
  1610.             }
  1611.         }
  1612.         return icon;
  1613.     }
  1614.  
  1615.     /**
  1616.      * Returns true if the file (directory) can be visited.
  1617.      * Returns false if the directory cannot be traversed.
  1618.      * @param f the <code>File</code>
  1619.      * @return true if the file/directory can be traversed, otherwise false
  1620.      * @see FileView#isTraversable
  1621.      */
  1622.     public boolean isTraversable(File f) {
  1623.         Boolean traversable = null;
  1624.         if (f != null) {
  1625.             if (getFileView() != null) {
  1626.                 traversable = getFileView().isTraversable(f);
  1627.             }
  1628.  
  1629.             FileView uiFileView = getUI().getFileView(this);
  1630.  
  1631.             if (traversable == null && uiFileView != null) {
  1632.                 traversable = uiFileView.isTraversable(f);
  1633.             }
  1634.             if (traversable == null) {
  1635.                 traversable = getFileSystemView().isTraversable(f);
  1636.             }
  1637.         }
  1638.         return (traversable != null && traversable.booleanValue());
  1639.     }
  1640.  
  1641.     /**
  1642.      * Returns true if the file should be displayed.
  1643.      * @param f the <code>File</code>
  1644.      * @return true if the file should be displayed, otherwise false
  1645.      * @see FileFilter#accept
  1646.      */
  1647.     public boolean accept(File f) {
  1648.         boolean shown = true;
  1649.         if(f != null && fileFilter != null) {
  1650.             shown = fileFilter.accept(f);
  1651.         }
  1652.         return shown;
  1653.     }
  1654.  
  1655.     /**
  1656.      * Sets the file system view that the <code>JFileChooser</code> uses for
  1657.      * accessing and creating file system resources, such as finding
  1658.      * the floppy drive and getting a list of root drives.
  1659.      * @param fsv  the new <code>FileSystemView</code>
  1660.      *
  1661.      * @beaninfo
  1662.      *      expert: true
  1663.      *       bound: true
  1664.      * description: Sets the FileSytemView used to get filesystem information.
  1665.      *
  1666.      * @see FileSystemView
  1667.      */
  1668.     public void setFileSystemView(FileSystemView fsv) {
  1669.         FileSystemView oldValue = fileSystemView;
  1670.         fileSystemView = fsv;
  1671.         firePropertyChange(FILE_SYSTEM_VIEW_CHANGED_PROPERTY, oldValue, fileSystemView);
  1672.     }
  1673.  
  1674.     /**
  1675.      * Returns the file system view.
  1676.      * @return the <code>FileSystemView</code> object
  1677.      * @see #setFileSystemView
  1678.      */
  1679.     public FileSystemView getFileSystemView() {
  1680.         return fileSystemView;
  1681.     }
  1682.  
  1683.     // **************************
  1684.     // ***** Event Handling *****
  1685.     // **************************
  1686.  
  1687.     /**
  1688.      * Called by the UI when the user hits the Approve button
  1689.      * (labeled "Open" or "Save", by default). This can also be
  1690.      * called by the programmer.
  1691.      * This method causes an action event to fire
  1692.      * with the command string equal to
  1693.      * <code>APPROVE_SELECTION</code>.
  1694.      *
  1695.      * @see #APPROVE_SELECTION
  1696.      */
  1697.     public void approveSelection() {
  1698.         returnValue = APPROVE_OPTION;
  1699.         if(dialog != null) {
  1700.             dialog.setVisible(false);
  1701.         }
  1702.         fireActionPerformed(APPROVE_SELECTION);
  1703.     }
  1704.  
  1705.     /**
  1706.      * Called by the UI when the user chooses the Cancel button.
  1707.      * This can also be called by the programmer.
  1708.      * This method causes an action event to fire
  1709.      * with the command string equal to
  1710.      * <code>CANCEL_SELECTION</code>.
  1711.      *
  1712.      * @see #CANCEL_SELECTION
  1713.      */
  1714.     public void cancelSelection() {
  1715.         returnValue = CANCEL_OPTION;
  1716.         if(dialog != null) {
  1717.             dialog.setVisible(false);
  1718.         }
  1719.         fireActionPerformed(CANCEL_SELECTION);
  1720.     }
  1721.  
  1722.     /**
  1723.      * Adds an <code>ActionListener</code> to the file chooser.
  1724.      *
  1725.      * @param l  the listener to be added
  1726.      *
  1727.      * @see #approveSelection
  1728.      * @see #cancelSelection
  1729.      */
  1730.     public void addActionListener(ActionListener l) {
  1731.         listenerList.add(ActionListener.class, l);
  1732.     }
  1733.  
  1734.     /**
  1735.      * Removes an <code>ActionListener</code> from the file chooser.
  1736.      *
  1737.      * @param l  the listener to be removed
  1738.      *
  1739.      * @see #addActionListener
  1740.      */
  1741.     public void removeActionListener(ActionListener l) {
  1742.         listenerList.remove(ActionListener.class, l);
  1743.     }
  1744.  
  1745.     /**
  1746.      * Returns an array of all the action listeners
  1747.      * registered on this file chooser.
  1748.      *
  1749.      * @return all of this file chooser's <code>ActionListener</code>s
  1750.      *         or an empty
  1751.      *         array if no action listeners are currently registered
  1752.      *
  1753.      * @see #addActionListener
  1754.      * @see #removeActionListener
  1755.      *
  1756.      * @since 1.4
  1757.      */
  1758.     public ActionListener[] getActionListeners() {
  1759.         return listenerList.getListeners(ActionListener.class);
  1760.     }
  1761.  
  1762.     /**
  1763.      * Notifies all listeners that have registered interest for
  1764.      * notification on this event type. The event instance
  1765.      * is lazily created using the <code>command</code> parameter.
  1766.      *
  1767.      * @see EventListenerList
  1768.      */
  1769.     protected void fireActionPerformed(String command) {
  1770.         // Guaranteed to return a non-null array
  1771.         Object[] listeners = listenerList.getListenerList();
  1772.         long mostRecentEventTime = EventQueue.getMostRecentEventTime();
  1773.         int modifiers = 0;
  1774.         AWTEvent currentEvent = EventQueue.getCurrentEvent();
  1775.         if (currentEvent instanceof InputEvent) {
  1776.             modifiers = ((InputEvent)currentEvent).getModifiers();
  1777.         } else if (currentEvent instanceof ActionEvent) {
  1778.             modifiers = ((ActionEvent)currentEvent).getModifiers();
  1779.         }
  1780.         ActionEvent e = null;
  1781.         // Process the listeners last to first, notifying
  1782.         // those that are interested in this event
  1783.         for (int i = listeners.length-2; i>=0; i-=2) {
  1784.             if (listeners[i]==ActionListener.class) {
  1785.                 // Lazily create the event:
  1786.                 if (e == null) {
  1787.                     e = new ActionEvent(this, ActionEvent.ACTION_PERFORMED,
  1788.                                         command, mostRecentEventTime,
  1789.                                         modifiers);
  1790.                 }
  1791.                 ((ActionListener)listeners[i+1]).actionPerformed(e);
  1792.             }
  1793.         }
  1794.     }
  1795.  
  1796.     private static class WeakPCL implements PropertyChangeListener {
  1797.         WeakReference<JFileChooser> jfcRef;
  1798.  
  1799.         public WeakPCL(JFileChooser jfc) {
  1800.             jfcRef = new WeakReference<JFileChooser>(jfc);
  1801.         }
  1802.         public void propertyChange(PropertyChangeEvent ev) {
  1803.             assert ev.getPropertyName().equals(SHOW_HIDDEN_PROP);
  1804.             JFileChooser jfc = jfcRef.get();
  1805.             if (jfc == null) {
  1806.                 // Our JFileChooser is no longer around, so we no longer need to
  1807.                 // listen for PropertyChangeEvents.
  1808.                 Toolkit.getDefaultToolkit().removePropertyChangeListener(SHOW_HIDDEN_PROP, this);
  1809.             }
  1810.             else {
  1811.                 boolean oldValue = jfc.useFileHiding;
  1812.                 jfc.useFileHiding = !((Boolean)ev.getNewValue()).booleanValue();
  1813.                 jfc.firePropertyChange(FILE_HIDING_CHANGED_PROPERTY, oldValue, jfc.useFileHiding);
  1814.             }
  1815.         }
  1816.     }
  1817.  
  1818.     // *********************************
  1819.     // ***** Pluggable L&F methods *****
  1820.     // *********************************
  1821.  
  1822.     /**
  1823.      * Resets the UI property to a value from the current look and feel.
  1824.      *
  1825.      * @see JComponent#updateUI
  1826.      */
  1827.     public void updateUI() {
  1828.         if (isAcceptAllFileFilterUsed()) {
  1829.             removeChoosableFileFilter(getAcceptAllFileFilter());
  1830.         }
  1831.         FileChooserUI ui = ((FileChooserUI)UIManager.getUI(this));
  1832.         if (fileSystemView == null) {
  1833.             // We were probably deserialized
  1834.             setFileSystemView(FileSystemView.getFileSystemView());
  1835.         }
  1836.         setUI(ui);
  1837.  
  1838.         if(isAcceptAllFileFilterUsed()) {
  1839.             addChoosableFileFilter(getAcceptAllFileFilter());
  1840.         }
  1841.     }
  1842.  
  1843.     /**
  1844.      * Returns a string that specifies the name of the L&amp;F class
  1845.      * that renders this component.
  1846.      *
  1847.      * @return the string "FileChooserUI"
  1848.      * @see JComponent#getUIClassID
  1849.      * @see UIDefaults#getUI
  1850.      * @beaninfo
  1851.      *        expert: true
  1852.      *   description: A string that specifies the name of the L&amp;F class.
  1853.      */
  1854.     public String getUIClassID() {
  1855.         return uiClassID;
  1856.     }
  1857.  
  1858.     /**
  1859.      * Gets the UI object which implements the L&amp;F for this component.
  1860.      *
  1861.      * @return the FileChooserUI object that implements the FileChooserUI L&amp;F
  1862.      */
  1863.     public FileChooserUI getUI() {
  1864.         return (FileChooserUI) ui;
  1865.     }
  1866.  
  1867.     /**
  1868.      * See <code>readObject</code> and <code>writeObject</code> in
  1869.      * <code>JComponent</code> for more
  1870.      * information about serialization in Swing.
  1871.      */
  1872.     private void readObject(java.io.ObjectInputStream in)
  1873.             throws IOException, ClassNotFoundException {
  1874.         in.defaultReadObject();
  1875.         installShowFilesListener();
  1876.     }
  1877.  
  1878.     /**
  1879.      * See <code>readObject</code> and <code>writeObject</code> in
  1880.      * <code>JComponent</code> for more
  1881.      * information about serialization in Swing.
  1882.      */
  1883.     private void writeObject(ObjectOutputStream s) throws IOException {
  1884.         FileSystemView fsv = null;
  1885.  
  1886.         if (isAcceptAllFileFilterUsed()) {
  1887.             //The AcceptAllFileFilter is UI specific, it will be reset by
  1888.             //updateUI() after deserialization
  1889.             removeChoosableFileFilter(getAcceptAllFileFilter());
  1890.         }
  1891.         if (fileSystemView.equals(FileSystemView.getFileSystemView())) {
  1892.             //The default FileSystemView is platform specific, it will be
  1893.             //reset by updateUI() after deserialization
  1894.             fsv = fileSystemView;
  1895.             fileSystemView = null;
  1896.         }
  1897.         s.defaultWriteObject();
  1898.         if (fsv != null) {
  1899.             fileSystemView = fsv;
  1900.         }
  1901.         if (isAcceptAllFileFilterUsed()) {
  1902.             addChoosableFileFilter(getAcceptAllFileFilter());
  1903.         }
  1904.         if (getUIClassID().equals(uiClassID)) {
  1905.             byte count = JComponent.getWriteObjCounter(this);
  1906.             JComponent.setWriteObjCounter(this, --count);
  1907.             if (count == 0 && ui != null) {
  1908.                 ui.installUI(this);
  1909.             }
  1910.         }
  1911.     }
  1912.  
  1913.  
  1914.     /**
  1915.      * Returns a string representation of this <code>JFileChooser</code>.
  1916.      * This method
  1917.      * is intended to be used only for debugging purposes, and the
  1918.      * content and format of the returned string may vary between
  1919.      * implementations. The returned string may be empty but may not
  1920.      * be <code>null</code>.
  1921.      *
  1922.      * @return  a string representation of this <code>JFileChooser</code>
  1923.      */
  1924.     protected String paramString() {
  1925.         String approveButtonTextString = (approveButtonText != null ?
  1926.                                           approveButtonText: "");
  1927.         String dialogTitleString = (dialogTitle != null ?
  1928.                                     dialogTitle: "");
  1929.         String dialogTypeString;
  1930.         if (dialogType == OPEN_DIALOG) {
  1931.             dialogTypeString = "OPEN_DIALOG";
  1932.         } else if (dialogType == SAVE_DIALOG) {
  1933.             dialogTypeString = "SAVE_DIALOG";
  1934.         } else if (dialogType == CUSTOM_DIALOG) {
  1935.             dialogTypeString = "CUSTOM_DIALOG";
  1936.         } else dialogTypeString = "";
  1937.         String returnValueString;
  1938.         if (returnValue == CANCEL_OPTION) {
  1939.             returnValueString = "CANCEL_OPTION";
  1940.         } else if (returnValue == APPROVE_OPTION) {
  1941.             returnValueString = "APPROVE_OPTION";
  1942.         } else if (returnValue == ERROR_OPTION) {
  1943.             returnValueString = "ERROR_OPTION";
  1944.         } else returnValueString = "";
  1945.         String useFileHidingString = (useFileHiding ?
  1946.                                     "true" : "false");
  1947.         String fileSelectionModeString;
  1948.         if (fileSelectionMode == FILES_ONLY) {
  1949.             fileSelectionModeString = "FILES_ONLY";
  1950.         } else if (fileSelectionMode == DIRECTORIES_ONLY) {
  1951.             fileSelectionModeString = "DIRECTORIES_ONLY";
  1952.         } else if (fileSelectionMode == FILES_AND_DIRECTORIES) {
  1953.             fileSelectionModeString = "FILES_AND_DIRECTORIES";
  1954.         } else fileSelectionModeString = "";
  1955.         String currentDirectoryString = (currentDirectory != null ?
  1956.                                          currentDirectory.toString() : "");
  1957.         String selectedFileString = (selectedFile != null ?
  1958.                                      selectedFile.toString() : "");
  1959.  
  1960.         return super.paramString() +
  1961.         ",approveButtonText=" + approveButtonTextString +
  1962.         ",currentDirectory=" + currentDirectoryString +
  1963.         ",dialogTitle=" + dialogTitleString +
  1964.         ",dialogType=" + dialogTypeString +
  1965.         ",fileSelectionMode=" + fileSelectionModeString +
  1966.         ",returnValue=" + returnValueString +
  1967.         ",selectedFile=" + selectedFileString +
  1968.         ",useFileHiding=" + useFileHidingString;
  1969.     }
  1970.  
  1971. /////////////////
  1972. // Accessibility support
  1973. ////////////////
  1974.  
  1975.     protected AccessibleContext accessibleContext = null;
  1976.  
  1977.     /**
  1978.      * Gets the AccessibleContext associated with this JFileChooser.
  1979.      * For file choosers, the AccessibleContext takes the form of an
  1980.      * AccessibleJFileChooser.
  1981.      * A new AccessibleJFileChooser instance is created if necessary.
  1982.      *
  1983.      * @return an AccessibleJFileChooser that serves as the
  1984.      *         AccessibleContext of this JFileChooser
  1985.      */
  1986.     public AccessibleContext getAccessibleContext() {
  1987.         if (accessibleContext == null) {
  1988.             accessibleContext = new AccessibleJFileChooser();
  1989.         }
  1990.         return accessibleContext;
  1991.     }
  1992.  
  1993.     /**
  1994.      * This class implements accessibility support for the
  1995.      * <code>JFileChooser</code> class.  It provides an implementation of the
  1996.      * Java Accessibility API appropriate to file chooser user-interface
  1997.      * elements.
  1998.      */
  1999.     protected class AccessibleJFileChooser extends AccessibleJComponent {
  2000.  
  2001.         /**
  2002.          * Gets the role of this object.
  2003.          *
  2004.          * @return an instance of AccessibleRole describing the role of the
  2005.          * object
  2006.          * @see AccessibleRole
  2007.          */
  2008.         public AccessibleRole getAccessibleRole() {
  2009.             return AccessibleRole.FILE_CHOOSER;
  2010.         }
  2011.  
  2012.     } // inner class AccessibleJFileChooser
  2013.  
  2014. }
  2015.  
  2016.  

diccionarioGenerador.java

Código: Java
  1. /*
  2.  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
  3.  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  4.  *
  5.  *
  6.  *
  7.  *
  8.  *
  9.  *
  10.  *
  11.  *
  12.  *
  13.  *
  14.  *
  15.  *
  16.  *
  17.  *
  18.  *
  19.  *
  20.  *
  21.  *
  22.  *
  23.  *
  24.  */
  25.  
  26. package javax.swing;
  27.  
  28. import javax.swing.event.*;
  29. import javax.swing.filechooser.*;
  30. import javax.swing.plaf.FileChooserUI;
  31.  
  32. import javax.accessibility.*;
  33.  
  34. import java.io.File;
  35. import java.io.ObjectOutputStream;
  36. import java.io.IOException;
  37.  
  38. import java.util.Vector;
  39. import java.awt.AWTEvent;
  40. import java.awt.Component;
  41. import java.awt.Container;
  42. import java.awt.BorderLayout;
  43. import java.awt.Window;
  44. import java.awt.Dialog;
  45. import java.awt.Frame;
  46. import java.awt.GraphicsEnvironment;
  47. import java.awt.HeadlessException;
  48. import java.awt.EventQueue;
  49. import java.awt.Toolkit;
  50. import java.awt.event.*;
  51. import java.beans.PropertyChangeListener;
  52. import java.beans.PropertyChangeEvent;
  53. import java.lang.ref.WeakReference;
  54.  
  55. /**
  56.  * <code>JFileChooser</code> provides a simple mechanism for the user to
  57.  * choose a file.
  58.  * For information about using <code>JFileChooser</code>, see
  59.  * <a
  60.  href="https://docs.oracle.com/javase/tutorial/uiswing/components/filechooser.html">How to Use File Choosers</a>,
  61.  * a section in <em>The Java Tutorial</em>.
  62.  *
  63.  * <p>
  64.  *
  65.  * The following code pops up a file chooser for the user's home directory that
  66.  * sees only .jpg and .gif images:
  67.  * <pre>
  68.  *    JFileChooser chooser = new JFileChooser();
  69.  *    FileNameExtensionFilter filter = new FileNameExtensionFilter(
  70.  *        "JPG &amp; GIF Images", "jpg", "gif");
  71.  *    chooser.setFileFilter(filter);
  72.  *    int returnVal = chooser.showOpenDialog(parent);
  73.  *    if(returnVal == JFileChooser.APPROVE_OPTION) {
  74.  *       System.out.println("You chose to open this file: " +
  75.  *            chooser.getSelectedFile().getName());
  76.  *    }
  77.  * </pre>
  78.  * <p>
  79.  * <strong>Warning:</strong> Swing is not thread safe. For more
  80.  * information see <a
  81.  * href="package-summary.html#threading">Swing's Threading
  82.  * Policy</a>.
  83.  *
  84.  * @beaninfo
  85.  *   attribute: isContainer false
  86.  * description: A component which allows for the interactive selection of a file.
  87.  *
  88.  * @author Jeff Dinkins
  89.  *
  90.  */
  91. public class JFileChooser extends JComponent implements Accessible {
  92.  
  93.     /**
  94.      * @see #getUIClassID
  95.      * @see #readObject
  96.      */
  97.     private static final String uiClassID = "FileChooserUI";
  98.  
  99.     // ************************
  100.     // ***** Dialog Types *****
  101.     // ************************
  102.  
  103.     /**
  104.      * Type value indicating that the <code>JFileChooser</code> supports an
  105.      * "Open" file operation.
  106.      */
  107.     public static final int OPEN_DIALOG = 0;
  108.  
  109.     /**
  110.      * Type value indicating that the <code>JFileChooser</code> supports a
  111.      * "Save" file operation.
  112.      */
  113.     public static final int SAVE_DIALOG = 1;
  114.  
  115.     /**
  116.      * Type value indicating that the <code>JFileChooser</code> supports a
  117.      * developer-specified file operation.
  118.      */
  119.     public static final int CUSTOM_DIALOG = 2;
  120.  
  121.  
  122.     // ********************************
  123.     // ***** Dialog Return Values *****
  124.     // ********************************
  125.  
  126.     /**
  127.      * Return value if cancel is chosen.
  128.      */
  129.     public static final int CANCEL_OPTION = 1;
  130.  
  131.     /**
  132.      * Return value if approve (yes, ok) is chosen.
  133.      */
  134.     public static final int APPROVE_OPTION = 0;
  135.  
  136.     /**
  137.      * Return value if an error occurred.
  138.      */
  139.     public static final int ERROR_OPTION = -1;
  140.  
  141.  
  142.     // **********************************
  143.     // ***** JFileChooser properties *****
  144.     // **********************************
  145.  
  146.  
  147.     /** Instruction to display only files. */
  148.     public static final int FILES_ONLY = 0;
  149.  
  150.     /** Instruction to display only directories. */
  151.     public static final int DIRECTORIES_ONLY = 1;
  152.  
  153.     /** Instruction to display both files and directories. */
  154.     public static final int FILES_AND_DIRECTORIES = 2;
  155.  
  156.     /** Instruction to cancel the current selection. */
  157.     public static final String CANCEL_SELECTION = "CancelSelection";
  158.  
  159.     /**
  160.      * Instruction to approve the current selection
  161.      * (same as pressing yes or ok).
  162.      */
  163.     public static final String APPROVE_SELECTION = "ApproveSelection";
  164.  
  165.     /** Identifies change in the text on the approve (yes, ok) button. */
  166.     public static final String APPROVE_BUTTON_TEXT_CHANGED_PROPERTY = "ApproveButtonTextChangedProperty";
  167.  
  168.     /**
  169.      * Identifies change in the tooltip text for the approve (yes, ok)
  170.      * button.
  171.      */
  172.     public static final String APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY = "ApproveButtonToolTipTextChangedProperty";
  173.  
  174.     /** Identifies change in the mnemonic for the approve (yes, ok) button. */
  175.     public static final String APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY = "ApproveButtonMnemonicChangedProperty";
  176.  
  177.     /** Instruction to display the control buttons. */
  178.     public static final String CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY = "ControlButtonsAreShownChangedProperty";
  179.  
  180.     /** Identifies user's directory change. */
  181.     public static final String DIRECTORY_CHANGED_PROPERTY = "directoryChanged";
  182.  
  183.     /** Identifies change in user's single-file selection. */
  184.     public static final String SELECTED_FILE_CHANGED_PROPERTY = "SelectedFileChangedProperty";
  185.  
  186.     /** Identifies change in user's multiple-file selection. */
  187.     public static final String SELECTED_FILES_CHANGED_PROPERTY = "SelectedFilesChangedProperty";
  188.  
  189.     /** Enables multiple-file selections. */
  190.     public static final String MULTI_SELECTION_ENABLED_CHANGED_PROPERTY = "MultiSelectionEnabledChangedProperty";
  191.  
  192.     /**
  193.      * Says that a different object is being used to find available drives
  194.      * on the system.
  195.      */
  196.     public static final String FILE_SYSTEM_VIEW_CHANGED_PROPERTY = "FileSystemViewChanged";
  197.  
  198.     /**
  199.      * Says that a different object is being used to retrieve file
  200.      * information.
  201.      */
  202.     public static final String FILE_VIEW_CHANGED_PROPERTY = "fileViewChanged";
  203.  
  204.     /** Identifies a change in the display-hidden-files property. */
  205.     public static final String FILE_HIDING_CHANGED_PROPERTY = "FileHidingChanged";
  206.  
  207.     /** User changed the kind of files to display. */
  208.     public static final String FILE_FILTER_CHANGED_PROPERTY = "fileFilterChanged";
  209.  
  210.     /**
  211.      * Identifies a change in the kind of selection (single,
  212.      * multiple, etc.).
  213.      */
  214.     public static final String FILE_SELECTION_MODE_CHANGED_PROPERTY = "fileSelectionChanged";
  215.  
  216.     /**
  217.      * Says that a different accessory component is in use
  218.      * (for example, to preview files).
  219.      */
  220.     public static final String ACCESSORY_CHANGED_PROPERTY = "AccessoryChangedProperty";
  221.  
  222.     /**
  223.      * Identifies whether a the AcceptAllFileFilter is used or not.
  224.      */
  225.     public static final String ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY = "acceptAllFileFilterUsedChanged";
  226.  
  227.     /** Identifies a change in the dialog title. */
  228.     public static final String DIALOG_TITLE_CHANGED_PROPERTY = "DialogTitleChangedProperty";
  229.  
  230.     /**
  231.      * Identifies a change in the type of files displayed (files only,
  232.      * directories only, or both files and directories).
  233.      */
  234.     public static final String DIALOG_TYPE_CHANGED_PROPERTY = "DialogTypeChangedProperty";
  235.  
  236.     /**
  237.      * Identifies a change in the list of predefined file filters
  238.      * the user can choose from.
  239.      */
  240.     public static final String CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY = "ChoosableFileFilterChangedProperty";
  241.  
  242.     // ******************************
  243.     // ***** instance variables *****
  244.     // ******************************
  245.  
  246.     private String dialogTitle = null;
  247.     private String approveButtonText = null;
  248.     private String approveButtonToolTipText = null;
  249.     private int approveButtonMnemonic = 0;
  250.  
  251.     private Vector<FileFilter> filters = new Vector<FileFilter>(5);
  252.     private JDialog dialog = null;
  253.     private int dialogType = OPEN_DIALOG;
  254.     private int returnValue = ERROR_OPTION;
  255.     private JComponent accessory = null;
  256.  
  257.     private FileView fileView = null;
  258.  
  259.     private boolean controlsShown = true;
  260.  
  261.     private boolean useFileHiding = true;
  262.     private static final String SHOW_HIDDEN_PROP = "awt.file.showHiddenFiles";
  263.  
  264.     // Listens to changes in the native setting for showing hidden files.
  265.     // The Listener is removed and the native setting is ignored if
  266.     // setFileHidingEnabled() is ever called.
  267.     private transient PropertyChangeListener showFilesListener = null;
  268.  
  269.     private int fileSelectionMode = FILES_ONLY;
  270.  
  271.     private boolean multiSelectionEnabled = false;
  272.  
  273.     private boolean useAcceptAllFileFilter = true;
  274.  
  275.     private boolean dragEnabled = false;
  276.  
  277.     private FileFilter fileFilter = null;
  278.  
  279.     private FileSystemView fileSystemView = null;
  280.  
  281.     private File currentDirectory = null;
  282.     private File selectedFile = null;
  283.     private File[] selectedFiles;
  284.  
  285.     // *************************************
  286.     // ***** JFileChooser Constructors *****
  287.     // *************************************
  288.  
  289.     /**
  290.      * Constructs a <code>JFileChooser</code> pointing to the user's
  291.      * default directory. This default depends on the operating system.
  292.      * It is typically the "My Documents" folder on Windows, and the
  293.      * user's home directory on Unix.
  294.      */
  295.     public JFileChooser() {
  296.         this((File) null, (FileSystemView) null);
  297.     }
  298.  
  299.     /**
  300.      * Constructs a <code>JFileChooser</code> using the given path.
  301.      * Passing in a <code>null</code>
  302.      * string causes the file chooser to point to the user's default directory.
  303.      * This default depends on the operating system. It is
  304.      * typically the "My Documents" folder on Windows, and the user's
  305.      * home directory on Unix.
  306.      *
  307.      * @param currentDirectoryPath  a <code>String</code> giving the path
  308.      *                          to a file or directory
  309.      */
  310.     public JFileChooser(String currentDirectoryPath) {
  311.         this(currentDirectoryPath, (FileSystemView) null);
  312.     }
  313.  
  314.     /**
  315.      * Constructs a <code>JFileChooser</code> using the given <code>File</code>
  316.      * as the path. Passing in a <code>null</code> file
  317.      * causes the file chooser to point to the user's default directory.
  318.      * This default depends on the operating system. It is
  319.      * typically the "My Documents" folder on Windows, and the user's
  320.      * home directory on Unix.
  321.      *
  322.      * @param currentDirectory  a <code>File</code> object specifying
  323.      *                          the path to a file or directory
  324.      */
  325.     public JFileChooser(File currentDirectory) {
  326.         this(currentDirectory, (FileSystemView) null);
  327.     }
  328.  
  329.     /**
  330.      * Constructs a <code>JFileChooser</code> using the given
  331.      * <code>FileSystemView</code>.
  332.      */
  333.     public JFileChooser(FileSystemView fsv) {
  334.         this((File) null, fsv);
  335.     }
  336.  
  337.  
  338.     /**
  339.      * Constructs a <code>JFileChooser</code> using the given current directory
  340.      * and <code>FileSystemView</code>.
  341.      */
  342.     public JFileChooser(File currentDirectory, FileSystemView fsv) {
  343.         setup(fsv);
  344.         setCurrentDirectory(currentDirectory);
  345.     }
  346.  
  347.     /**
  348.      * Constructs a <code>JFileChooser</code> using the given current directory
  349.      * path and <code>FileSystemView</code>.
  350.      */
  351.     public JFileChooser(String currentDirectoryPath, FileSystemView fsv) {
  352.         setup(fsv);
  353.         if(currentDirectoryPath == null) {
  354.             setCurrentDirectory(null);
  355.         } else {
  356.             setCurrentDirectory(fileSystemView.createFileObject(currentDirectoryPath));
  357.         }
  358.     }
  359.  
  360.     /**
  361.      * Performs common constructor initialization and setup.
  362.      */