1. /*

  2.  * @(#)WindowsFileChooserUI.java	1.80 04/01/13

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package com.sun.java.swing.plaf.windows;

  9. 

  10. import javax.swing.*;

  11. import javax.swing.border.*;

  12. import javax.swing.filechooser.*;

  13. import javax.swing.event.*;

  14. import javax.swing.plaf.*;

  15. import javax.swing.plaf.basic.*;

  16. import javax.swing.table.*;

  17. import javax.swing.text.Position;

  18. import java.awt.*;

  19. import java.awt.event.*;

  20. import java.beans.*;

  21. import java.io.File;

  22. import java.io.FileNotFoundException;

  23. import java.io.IOException;

  24. import java.text.DateFormat;

  25. import java.util.*;

  26. 

  27. import sun.awt.shell.ShellFolder;

  28. 

  29. /**

  30.  * Windows L&F implementation of a FileChooser.

  31.  *

  32.  * @version 1.80 01/13/04

  33.  * @author Jeff Dinkins

  34.  */

  35. public class WindowsFileChooserUI extends BasicFileChooserUI {

  36. 

  37.     // The following are private because the implementation of the

  38.     // Windows FileChooser L&F is not complete yet.

  39. 

  40.     private static final String[] OS_NAMES =

  41. 		new String[] { "Windows 3.1", "Windows 95", "Windows NT",

  42. 			       "Windows 98", "Windows 2000", "Windows Me", "Windows XP" };

  43.     private static int WIN_31 = 0;

  44.     private static int WIN_95 = 1;

  45.     private static int WIN_NT = 2;

  46.     private static int WIN_98 = 3;

  47.     private static int WIN_2k = 4;

  48.     private static int WIN_Me = 5;

  49.     private static int WIN_XP = 6;

  50.     private static String osName = System.getProperty("os.name");

  51.     private static String osVersion = System.getProperty("os.version");

  52.     private static final String OS_NAME = ((osName.equals(OS_NAMES[WIN_98]) && osVersion.startsWith("4.9"))

  53. 					   ? "Windows Me" : osName);

  54.     private static final int OS_LEVEL = Arrays.asList(OS_NAMES).indexOf(OS_NAME);

  55. 

  56.     private JPanel centerPanel;

  57. 

  58.     private JLabel lookInLabel;

  59.     private JComboBox directoryComboBox;

  60.     private DirectoryComboBoxModel directoryComboBoxModel;

  61.     private ActionListener directoryComboBoxAction = new DirectoryComboBoxAction();

  62. 

  63.     private FilterComboBoxModel filterComboBoxModel;

  64. 

  65.     private JTextField filenameTextField;

  66.     private ShortCutPanel shortCutPanel;

  67.     private JToggleButton listViewButton;

  68.     private JToggleButton detailsViewButton;

  69.     private JPanel listViewPanel;

  70.     private JPanel detailsViewPanel;

  71.     private JPanel currentViewPanel;

  72.     private FocusListener editorFocusListener = new FocusAdapter() {

  73. 	public void focusLost(FocusEvent e) {

  74. 	    if (! e.isTemporary()) {

  75. 		applyEdit();

  76. 	    }

  77. 	}

  78.     };

  79.     private boolean smallIconsView = false;

  80.     private Border listViewBorder;

  81.     private boolean useShellFolder;

  82. 

  83.     private ListSelectionModel listSelectionModel;

  84.     private JList list;

  85.     private JTable detailsTable;

  86. 

  87.     private JButton approveButton;

  88.     private JButton cancelButton;

  89. 

  90.     private JPanel buttonPanel;

  91.     private JPanel bottomPanel;

  92. 

  93.     private JComboBox filterComboBox;

  94. 

  95.     private static final Dimension hstrut10 = new Dimension(10, 1);

  96.     private static final Dimension hstrut25 = new Dimension(25, 1);

  97. 

  98.     private static final Dimension vstrut1  = new Dimension(1, 1);

  99.     private static final Dimension vstrut4  = new Dimension(1, 4);

  100.     private static final Dimension vstrut5  = new Dimension(1, 5);

  101.     private static final Dimension vstrut6  = new Dimension(1, 6);

  102.     private static final Dimension vstrut8  = new Dimension(1, 8);

  103. 

  104.     private static final Insets shrinkwrap = new Insets(0,0,0,0);

  105. 

  106.     // Preferred and Minimum sizes for the dialog box

  107.     private static int PREF_WIDTH = 425;

  108.     private static int PREF_HEIGHT = 245;

  109.     private static Dimension PREF_SIZE = new Dimension(PREF_WIDTH, PREF_HEIGHT);

  110. 

  111.     private static int MIN_WIDTH = 425;

  112.     private static int MIN_HEIGHT = 245;

  113.     private static Dimension MIN_SIZE = new Dimension(MIN_WIDTH, MIN_HEIGHT);

  114. 

  115.     private static int LIST_PREF_WIDTH = 444;

  116.     private static int LIST_PREF_HEIGHT = 138;

  117.     private static Dimension LIST_PREF_SIZE = new Dimension(LIST_PREF_WIDTH, LIST_PREF_HEIGHT);

  118. 

  119.     private static final int COLUMN_FILENAME = 0;

  120.     private static final int COLUMN_FILESIZE = 1;

  121.     private static final int COLUMN_FILETYPE = 2;

  122.     private static final int COLUMN_FILEDATE = 3;

  123.     private static final int COLUMN_FILEATTR = 4;

  124.     private static final int COLUMN_COLCOUNT = 5;

  125. 

  126.     private int[] COLUMN_WIDTHS = { 150,  75,  130,  130,  40 };

  127. 

  128.     // Labels, mnemonics, and tooltips (oh my!)

  129.     private int    lookInLabelMnemonic = 0;

  130.     private String lookInLabelText = null;

  131.     private String saveInLabelText = null;

  132. 

  133.     private int    fileNameLabelMnemonic = 0;

  134.     private String fileNameLabelText = null;

  135. 

  136.     private int    filesOfTypeLabelMnemonic = 0;

  137.     private String filesOfTypeLabelText = null;

  138. 

  139.     private String upFolderToolTipText = null;

  140.     private String upFolderAccessibleName = null;

  141. 

  142.     private String homeFolderToolTipText = null;

  143.     private String homeFolderAccessibleName = null;

  144. 

  145.     private String newFolderToolTipText = null;

  146.     private String newFolderAccessibleName = null;

  147. 

  148.     private String listViewButtonToolTipText = null;

  149.     private String listViewButtonAccessibleName = null;

  150. 

  151.     private String detailsViewButtonToolTipText = null;

  152.     private String detailsViewButtonAccessibleName = null;

  153. 

  154.     private String fileNameHeaderText = null;

  155.     private String fileSizeHeaderText = null;

  156.     private String fileTypeHeaderText = null;

  157.     private String fileDateHeaderText = null;

  158.     private String fileAttrHeaderText = null;

  159. 

  160.     private Action newFolderAction = new WindowsNewFolderAction();

  161.     private File newFolderFile;

  162.     private BasicFileView fileView = new WindowsFileView();

  163. 

  164.     //

  165.     // ComponentUI Interface Implementation methods

  166.     //

  167.     public static ComponentUI createUI(JComponent c) {

  168.         return new WindowsFileChooserUI((JFileChooser) c);

  169.     }

  170. 

  171.     public WindowsFileChooserUI(JFileChooser filechooser) {

  172. 	super(filechooser);

  173.     }

  174. 

  175.     public void installUI(JComponent c) {

  176. 	super.installUI(c);

  177.     }

  178. 

  179.     public void uninstallComponents(JFileChooser fc) {

  180. 	fc.removeAll();

  181.     }

  182. 

  183.     public void installComponents(JFileChooser fc) {

  184. 	FileSystemView fsv = fc.getFileSystemView();

  185. 	XPStyle xp = XPStyle.getXP();

  186. 	if (xp != null) {

  187. 	    listViewBorder = xp.getBorder("listview");

  188. 	} else {

  189. 	    listViewBorder = new BevelBorder(BevelBorder.LOWERED,

  190. 					     UIManager.getColor("ToolBar.highlight"),

  191. 					     UIManager.getColor("ToolBar.background"),

  192. 					     UIManager.getColor("ToolBar.darkShadow"),

  193. 					     UIManager.getColor("ToolBar.shadow"));

  194. 	}

  195. 

  196. 	fc.setBorder(new EmptyBorder(4, 10, 10, 10));

  197. 	fc.setLayout(new BorderLayout(8, 8));

  198. 

  199. 	// ********************************* //

  200. 	// **** Construct the top panel **** //

  201. 	// ********************************* //

  202. 

  203. 	// Directory manipulation buttons

  204. 	JToolBar topPanel = new JToolBar();

  205. 	topPanel.setFloatable(false);

  206. 	if (OS_LEVEL >= WIN_2k) {

  207. 	    topPanel.putClientProperty("JToolBar.isRollover", Boolean.TRUE);

  208. 	}

  209. 

  210. 	// Add the top panel to the fileChooser

  211. 	fc.add(topPanel, BorderLayout.NORTH);

  212. 

  213. 	// ComboBox Label

  214.      	lookInLabel = new JLabel(lookInLabelText);

  215.      	lookInLabel.setDisplayedMnemonic(lookInLabelMnemonic);

  216. 	lookInLabel.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  217. 	lookInLabel.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  218. 	topPanel.add(Box.createRigidArea(new Dimension(14,0)));

  219. 	topPanel.add(lookInLabel);

  220. 	topPanel.add(Box.createRigidArea(new Dimension(29,0)));

  221. 

  222. 	// CurrentDir ComboBox

  223. 	directoryComboBox = new JComboBox();

  224. 	directoryComboBox.putClientProperty( "JComboBox.lightweightKeyboardNavigation", "Lightweight" );

  225. 	lookInLabel.setLabelFor(directoryComboBox);

  226. 	directoryComboBoxModel = createDirectoryComboBoxModel(fc);

  227. 	directoryComboBox.setModel(directoryComboBoxModel);

  228. 	directoryComboBox.addActionListener(directoryComboBoxAction);

  229. 	directoryComboBox.setRenderer(createDirectoryComboBoxRenderer(fc));

  230. 	directoryComboBox.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  231. 	directoryComboBox.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  232. 	directoryComboBox.setMaximumRowCount(8);

  233. 

  234. 	topPanel.add(directoryComboBox);

  235. 	topPanel.add(Box.createRigidArea(hstrut10));

  236. 

  237. 	// Up Button

  238. 	JButton upFolderButton = new JButton(getChangeToParentDirectoryAction());

  239. 	upFolderButton.setText(null);

  240. 	upFolderButton.setIcon(upFolderIcon);

  241.      	upFolderButton.setToolTipText(upFolderToolTipText);

  242.      	upFolderButton.getAccessibleContext().setAccessibleName(upFolderAccessibleName);

  243. 	upFolderButton.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  244. 	upFolderButton.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  245. 	upFolderButton.setMargin(shrinkwrap);

  246. 	upFolderButton.setFocusPainted(false);

  247. 	topPanel.add(upFolderButton);

  248. 	if (OS_LEVEL < WIN_2k) {

  249. 	    topPanel.add(Box.createRigidArea(hstrut10));

  250. 	}

  251. 

  252. 	JButton b;

  253. 

  254. 	if (OS_LEVEL == WIN_98) {

  255. 	    // Desktop Button

  256. 	    File homeDir = fsv.getHomeDirectory();

  257. 	    String toolTipText = homeFolderToolTipText;

  258. 	    if (fsv.isRoot(homeDir)) {

  259. 		toolTipText = getFileView(fc).getName(homeDir); // Probably "Desktop".

  260. 	    }

  261. 	    b = new JButton(getFileView(fc).getIcon(homeDir));

  262. 	    b.setToolTipText(toolTipText);

  263. 	    b.getAccessibleContext().setAccessibleName(toolTipText);

  264. 	    b.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  265. 	    b.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  266. 	    b.setMargin(shrinkwrap);

  267. 	    b.setFocusPainted(false);

  268. 	    b.addActionListener(getGoHomeAction());

  269. 	    topPanel.add(b);

  270. 	    topPanel.add(Box.createRigidArea(hstrut10));

  271. 	}

  272. 

  273. 	// New Directory Button

  274. 	b = new JButton(getNewFolderAction());

  275. 	b.setText(null);

  276. 	b.setIcon(newFolderIcon);

  277.      	b.setToolTipText(newFolderToolTipText);

  278.      	b.getAccessibleContext().setAccessibleName(newFolderAccessibleName);

  279. 	b.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  280. 	b.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  281. 	b.setMargin(shrinkwrap);

  282. 	b.setFocusPainted(false);

  283. 	topPanel.add(b);

  284. 	if (OS_LEVEL < WIN_2k) {

  285. 	    topPanel.add(Box.createRigidArea(hstrut10));

  286. 	}

  287. 

  288. 	// View button group

  289. 	ButtonGroup viewButtonGroup = new ButtonGroup();

  290. 

  291. 	class ViewButtonListener implements ActionListener {

  292. 	    JFileChooser fc;

  293. 

  294. 	    ViewButtonListener(JFileChooser fc) {

  295. 		this.fc = fc;

  296. 	    }

  297. 

  298. 	    public void actionPerformed(ActionEvent e) {

  299. 		JToggleButton b = (JToggleButton)e.getSource();

  300. 		JPanel oldViewPanel = currentViewPanel;

  301. 

  302. 		if (b == detailsViewButton) {

  303. 		    if (detailsViewPanel == null) {

  304. 			detailsViewPanel = createDetailsView(fc);

  305. 			detailsViewPanel.setPreferredSize(LIST_PREF_SIZE);

  306. 		    }

  307. 		    currentViewPanel = detailsViewPanel;

  308. 		} else {

  309. 		    currentViewPanel = listViewPanel;

  310. 		}

  311. 		if (currentViewPanel != oldViewPanel) {

  312. 		    centerPanel.remove(oldViewPanel);

  313. 		    centerPanel.add(currentViewPanel, BorderLayout.CENTER);

  314. 		    centerPanel.revalidate();

  315. 		    centerPanel.repaint();

  316. 		}

  317. 	    }

  318. 	}

  319. 

  320. 	ViewButtonListener viewButtonListener = new ViewButtonListener(fc);

  321. 

  322. 	// List Button

  323. 	listViewButton = new JToggleButton(listViewIcon);

  324.      	listViewButton.setToolTipText(listViewButtonToolTipText);

  325.      	listViewButton.getAccessibleContext().setAccessibleName(listViewButtonAccessibleName);

  326. 	listViewButton.setFocusPainted(false);

  327. 	listViewButton.setSelected(true);

  328. 	listViewButton.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  329. 	listViewButton.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  330. 	listViewButton.setMargin(shrinkwrap);

  331. 	listViewButton.addActionListener(viewButtonListener);

  332. 	topPanel.add(listViewButton);

  333. 	viewButtonGroup.add(listViewButton);

  334. 

  335. 	// Details Button

  336. 	detailsViewButton = new JToggleButton(detailsViewIcon);

  337.      	detailsViewButton.setToolTipText(detailsViewButtonToolTipText);

  338.      	detailsViewButton.getAccessibleContext().setAccessibleName(detailsViewButtonAccessibleName);

  339. 	detailsViewButton.setFocusPainted(false);

  340. 	detailsViewButton.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  341. 	detailsViewButton.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  342. 	detailsViewButton.setMargin(shrinkwrap);

  343. 	detailsViewButton.addActionListener(viewButtonListener);

  344. 	topPanel.add(detailsViewButton);

  345. 	viewButtonGroup.add(detailsViewButton);

  346. 

  347. 	updateUseShellFolder();

  348. 

  349. 	// ************************************** //

  350. 	// ******* Add the directory pane ******* //

  351. 	// ************************************** //

  352. 	centerPanel = new JPanel(new BorderLayout());

  353. 	listViewPanel = createList(fc);

  354. 	listSelectionModel = list.getSelectionModel();

  355. 	listViewPanel.setPreferredSize(LIST_PREF_SIZE);

  356. 	centerPanel.add(listViewPanel, BorderLayout.CENTER);

  357. 	currentViewPanel = listViewPanel;

  358. 	centerPanel.add(getAccessoryPanel(), BorderLayout.AFTER_LINE_ENDS);

  359. 	JComponent accessory = fc.getAccessory();

  360. 	if(accessory != null) {

  361. 	    getAccessoryPanel().add(accessory);

  362. 	}

  363. 	fc.add(centerPanel, BorderLayout.CENTER);

  364. 

  365. 	// ********************************** //

  366. 	// **** Construct the bottom panel ** //

  367. 	// ********************************** //

  368. 	getBottomPanel().setLayout(new BoxLayout(getBottomPanel(), BoxLayout.LINE_AXIS));

  369. 

  370. 	// Add the bottom panel to file chooser

  371. 	centerPanel.add(getBottomPanel(), BorderLayout.SOUTH);

  372. 

  373. 	// labels

  374. 	JPanel labelPanel = new JPanel();

  375. 	labelPanel.setLayout(new BoxLayout(labelPanel, BoxLayout.PAGE_AXIS));

  376.         labelPanel.add(Box.createRigidArea(vstrut4));

  377. 

  378.      	JLabel fnl = new JLabel(fileNameLabelText);

  379.      	fnl.setDisplayedMnemonic(fileNameLabelMnemonic);

  380. 	fnl.setAlignmentY(0);

  381. 	labelPanel.add(fnl);

  382. 

  383. 	labelPanel.add(Box.createRigidArea(new Dimension(1,12)));

  384. 

  385.      	JLabel ftl = new JLabel(filesOfTypeLabelText);

  386.      	ftl.setDisplayedMnemonic(filesOfTypeLabelMnemonic);

  387. 	labelPanel.add(ftl);

  388. 

  389. 	getBottomPanel().add(labelPanel);

  390. 	getBottomPanel().add(Box.createRigidArea(new Dimension(15, 0)));

  391. 

  392. 	// file entry and filters

  393. 	JPanel fileAndFilterPanel = new JPanel();

  394.         fileAndFilterPanel.add(Box.createRigidArea(vstrut8));

  395. 	fileAndFilterPanel.setLayout(new BoxLayout(fileAndFilterPanel, BoxLayout.Y_AXIS));

  396. 

  397. 

  398. 	filenameTextField = new JTextField(35) {

  399. 	    public Dimension getMaximumSize() {

  400. 		return new Dimension(Short.MAX_VALUE, super.getPreferredSize().height);

  401. 	    }

  402. 	};

  403. 

  404. 	fnl.setLabelFor(filenameTextField);

  405.         filenameTextField.addFocusListener(

  406. 	    new FocusAdapter() {

  407. 		public void focusGained(FocusEvent e) {

  408. 		    if (!getFileChooser().isMultiSelectionEnabled()) {

  409. 			listSelectionModel.clearSelection();

  410. 		    }

  411. 		}

  412. 	    }

  413.         );

  414. 

  415. 	if (fc.isMultiSelectionEnabled()) {

  416. 	    setFileName(fileNameString(fc.getSelectedFiles()));

  417. 	} else {

  418. 	    setFileName(fileNameString(fc.getSelectedFile()));

  419. 	}

  420. 

  421. 	fileAndFilterPanel.add(filenameTextField);

  422. 	fileAndFilterPanel.add(Box.createRigidArea(vstrut8));

  423. 

  424. 	filterComboBoxModel = createFilterComboBoxModel();

  425. 	fc.addPropertyChangeListener(filterComboBoxModel);

  426. 	filterComboBox = new JComboBox(filterComboBoxModel);

  427. 	ftl.setLabelFor(filterComboBox);

  428. 	filterComboBox.setRenderer(createFilterComboBoxRenderer());

  429. 	fileAndFilterPanel.add(filterComboBox);

  430. 

  431. 	getBottomPanel().add(fileAndFilterPanel);

  432. 	getBottomPanel().add(Box.createRigidArea(hstrut10));

  433. 

  434. 	// buttons

  435. 	getButtonPanel().setLayout(new BoxLayout(getButtonPanel(), BoxLayout.Y_AXIS));

  436. 

  437. 	approveButton = new JButton(getApproveButtonText(fc)) {

  438. 	    public Dimension getMaximumSize() {

  439. 		return approveButton.getPreferredSize().width > cancelButton.getPreferredSize().width ?

  440. 		       approveButton.getPreferredSize() : cancelButton.getPreferredSize();

  441. 	    }

  442. 	}; 

  443. 	approveButton.setMnemonic(getApproveButtonMnemonic(fc));

  444. 	approveButton.addActionListener(getApproveSelectionAction());

  445. 	approveButton.setToolTipText(getApproveButtonToolTipText(fc));

  446. 	getButtonPanel().add(Box.createRigidArea(vstrut4));

  447. 	getButtonPanel().add(approveButton);

  448. 	getButtonPanel().add(Box.createRigidArea(vstrut6));

  449. 

  450. 	cancelButton = new JButton(cancelButtonText) {

  451. 	    public Dimension getMaximumSize() {

  452. 		return approveButton.getPreferredSize().width > cancelButton.getPreferredSize().width ?

  453. 		       approveButton.getPreferredSize() : cancelButton.getPreferredSize();

  454. 	    }

  455. 	}; 

  456. 	cancelButton.setMnemonic(cancelButtonMnemonic);

  457. 	cancelButton.setToolTipText(cancelButtonToolTipText);

  458. 	cancelButton.addActionListener(getCancelSelectionAction());

  459. 	getButtonPanel().add(cancelButton);

  460. 

  461. 	if(fc.getControlButtonsAreShown()) {

  462. 	    addControlButtons();

  463. 	}

  464.     }

  465. 

  466.     private void updateUseShellFolder() {

  467. 	// Decide whether to use the ShellFolder class to populate shortcut

  468. 	// panel and combobox.

  469. 	JFileChooser fc = getFileChooser();

  470. 	Boolean prop =

  471. 	    (Boolean)fc.getClientProperty("FileChooser.useShellFolder");

  472. 	if (prop != null) {

  473. 	    useShellFolder = prop.booleanValue();

  474. 	} else {

  475. 	    // See if FileSystemView.getRoots() returns the desktop folder,

  476. 	    // i.e. the normal Windows hierarchy.

  477. 	    useShellFolder = false;

  478. 	    File[] roots = fc.getFileSystemView().getRoots();

  479. 	    if (roots != null && roots.length == 1) {

  480. 		File[] cbFolders = (File[])ShellFolder.get("fileChooserComboBoxFolders");

  481. 		if (cbFolders != null && cbFolders.length > 0 && roots[0] == cbFolders[0]) {

  482. 		    useShellFolder = true;

  483. 		}

  484. 	    }

  485. 	}

  486. 	if (OS_LEVEL >= WIN_2k) {

  487. 	    if (useShellFolder) {

  488. 		if (shortCutPanel == null) {

  489. 		    shortCutPanel = new ShortCutPanel();

  490. 		    fc.add(shortCutPanel, BorderLayout.BEFORE_LINE_BEGINS);

  491. 		}

  492. 	    } else {

  493. 		if (shortCutPanel != null) {

  494. 		    fc.remove(shortCutPanel);

  495. 		    shortCutPanel = null;

  496. 		}

  497. 	    }

  498. 	}

  499.     }

  500. 

  501.     protected JPanel getButtonPanel() {

  502. 	if(buttonPanel == null) {

  503. 	    buttonPanel = new JPanel();

  504. 	}

  505. 	return buttonPanel;

  506.     }

  507. 

  508.     protected JPanel getBottomPanel() {

  509. 	if(bottomPanel == null) {

  510. 	    bottomPanel = new JPanel();

  511. 	}

  512. 	return bottomPanel;

  513.     }

  514. 

  515.     protected void installStrings(JFileChooser fc) {

  516. 	super.installStrings(fc);

  517. 

  518.         Locale l = fc.getLocale();

  519. 

  520. 	lookInLabelMnemonic = UIManager.getInt("FileChooser.lookInLabelMnemonic"); 

  521. 	lookInLabelText = UIManager.getString("FileChooser.lookInLabelText",l);

  522. 	saveInLabelText = UIManager.getString("FileChooser.saveInLabelText",l);

  523. 	

  524. 	fileNameLabelMnemonic = UIManager.getInt("FileChooser.fileNameLabelMnemonic");  

  525. 	fileNameLabelText = UIManager.getString("FileChooser.fileNameLabelText",l); 

  526. 	

  527. 	filesOfTypeLabelMnemonic = UIManager.getInt("FileChooser.filesOfTypeLabelMnemonic");  

  528. 	filesOfTypeLabelText = UIManager.getString("FileChooser.filesOfTypeLabelText",l); 

  529. 	

  530. 	upFolderToolTipText =  UIManager.getString("FileChooser.upFolderToolTipText",l);

  531. 	upFolderAccessibleName = UIManager.getString("FileChooser.upFolderAccessibleName",l); 

  532. 	

  533. 	homeFolderToolTipText =  UIManager.getString("FileChooser.homeFolderToolTipText",l);

  534. 	homeFolderAccessibleName = UIManager.getString("FileChooser.homeFolderAccessibleName",l); 

  535. 	

  536. 	newFolderToolTipText = UIManager.getString("FileChooser.newFolderToolTipText",l);

  537. 	newFolderAccessibleName = UIManager.getString("FileChooser.newFolderAccessibleName",l); 

  538. 	

  539. 	listViewButtonToolTipText = UIManager.getString("FileChooser.listViewButtonToolTipText",l); 

  540. 	listViewButtonAccessibleName = UIManager.getString("FileChooser.listViewButtonAccessibleName",l); 

  541. 	

  542. 	detailsViewButtonToolTipText = UIManager.getString("FileChooser.detailsViewButtonToolTipText",l); 

  543. 	detailsViewButtonAccessibleName = UIManager.getString("FileChooser.detailsViewButtonAccessibleName",l); 

  544. 

  545. 

  546. 	fileNameHeaderText = UIManager.getString("FileChooser.fileNameHeaderText",l);

  547. 	fileSizeHeaderText = UIManager.getString("FileChooser.fileSizeHeaderText",l);

  548. 	fileTypeHeaderText = UIManager.getString("FileChooser.fileTypeHeaderText",l);

  549. 	fileDateHeaderText = UIManager.getString("FileChooser.fileDateHeaderText",l);

  550. 	fileAttrHeaderText = UIManager.getString("FileChooser.fileAttrHeaderText",l);

  551.     }

  552. 

  553.     protected void installListeners(JFileChooser fc) {

  554. 	super.installListeners(fc);

  555.         ActionMap actionMap = getActionMap();

  556.         SwingUtilities.replaceUIActionMap(fc, actionMap);

  557.     }

  558. 

  559.     protected ActionMap getActionMap() {

  560.         return createActionMap();

  561.     }

  562. 

  563.     protected ActionMap createActionMap() {

  564.         AbstractAction escAction = new AbstractAction() {

  565.             public void actionPerformed(ActionEvent e) {

  566. 		if (editFile != null) {

  567.     		   cancelEdit();

  568. 		} else {

  569.                    getFileChooser().cancelSelection();

  570. 		}

  571.             }

  572.             public boolean isEnabled(){

  573.                 return getFileChooser().isEnabled();

  574.             }

  575.         };

  576.         ActionMap map = new ActionMapUIResource();

  577.         map.put("approveSelection", getApproveSelectionAction());

  578.         map.put("cancelSelection", escAction);

  579.         map.put("Go Up", getChangeToParentDirectoryAction());

  580.         return map;

  581.     }

  582. 

  583.     class ShortCutPanel extends JToolBar implements ActionListener {

  584. 	JToggleButton[] buttons;

  585. 	File[] files;

  586. 	XPStyle xp = XPStyle.getXP();

  587. 	final Dimension buttonSize = new Dimension(83, (xp != null) ? 69 : 54);

  588. 

  589. 	ShortCutPanel() {

  590. 	    super(JToolBar.VERTICAL);

  591. 	    setFloatable(false);

  592. 	    putClientProperty("JToolBar.isRollover", Boolean.TRUE);

  593. 	    if (xp != null) {

  594. 		putClientProperty("XPStyle.subClass", "placesbar");

  595. 		setBorder(new EmptyBorder(1, 1, 1, 1));

  596. 	    } else {

  597. 		setBorder(listViewBorder);

  598. 	    }

  599. 	    Color bgColor = new Color(UIManager.getColor("ToolBar.shadow").getRGB());

  600. 	    setBackground(bgColor);

  601. 	    JFileChooser chooser = getFileChooser();

  602. 	    FileSystemView fsv = chooser.getFileSystemView();

  603. 

  604. 	    files = (File[])ShellFolder.get("fileChooserShortcutPanelFolders");

  605. 	    buttons = new JToggleButton[files.length];

  606. 	    ButtonGroup buttonGroup = new ButtonGroup();

  607. 	    for (int i = 0; i < files.length; i++) {

  608. 		if (fsv.isFileSystemRoot(files[i])) {

  609. 		    // Create special File wrapper for drive path

  610. 		    files[i] = fsv.createFileObject(files[i].getAbsolutePath());

  611. 		}

  612. 

  613. 		String folderName = fsv.getSystemDisplayName(files[i]);

  614. 		int index = folderName.lastIndexOf(File.separatorChar);

  615. 		if (index >= 0 && index < folderName.length() - 1) {

  616. 		    folderName = folderName.substring(index + 1);

  617. 		}

  618. 		Icon icon = null;

  619. 		if (files[i] instanceof ShellFolder) {

  620. 		    // We want a large icon, fsv only gives us a small.

  621. 		    ShellFolder sf = (ShellFolder)files[i];

  622. 		    icon = new ImageIcon(sf.getIcon(true), sf.getFolderType());

  623. 		} else {

  624. 		    icon = fsv.getSystemIcon(files[i]);

  625. 		}

  626. 		buttons[i] = new JToggleButton(folderName, icon);

  627. 		if (xp != null) {

  628. 		    buttons[i].setIconTextGap(2);

  629. 		    buttons[i].setMargin(new Insets(2, 2, 2, 2));

  630. 		    buttons[i].setText("<html><center>"+folderName+"</center></html>");

  631. 		} else {

  632. 		    Color fgColor = new Color(UIManager.getColor("List.selectionForeground").getRGB());

  633. 		    buttons[i].setBackground(bgColor);

  634. 		    buttons[i].setForeground(fgColor);

  635. 		}

  636. 		buttons[i].setHorizontalTextPosition(JToggleButton.CENTER);

  637. 		buttons[i].setVerticalTextPosition(JToggleButton.BOTTOM);

  638. 		buttons[i].setAlignmentX(JComponent.CENTER_ALIGNMENT);

  639. 		buttons[i].setPreferredSize(buttonSize);

  640. 		buttons[i].setMaximumSize(buttonSize);

  641. 		buttons[i].addActionListener(this);

  642. 		add(buttons[i]);

  643. 		if (i < files.length-1 && xp != null) {

  644. 		    add(Box.createRigidArea(vstrut1));

  645. 		}

  646. 		buttonGroup.add(buttons[i]);

  647. 	    }

  648. 	    doDirectoryChanged(chooser.getCurrentDirectory());

  649. 	}

  650. 

  651. 	void doDirectoryChanged(File f) {

  652. 	    for (int i=0; i<buttons.length; i++) {

  653. 		buttons[i].setSelected(files[i].equals(f));

  654. 	    }

  655. 	}

  656. 

  657. 	public void actionPerformed(ActionEvent e) {

  658. 	    JToggleButton b = (JToggleButton)e.getSource();

  659. 	    for (int i=0; i<buttons.length; i++) {

  660. 		if (b == buttons[i]) {

  661. 		    getFileChooser().setCurrentDirectory(files[i]);

  662. 		    break;

  663. 		}

  664. 	    }

  665. 	}

  666. 

  667. 	public Dimension getPreferredSize() {

  668. 	    Dimension min  = super.getMinimumSize();

  669. 	    Dimension pref = super.getPreferredSize();

  670. 	    if (min.height > pref.height) {

  671. 		pref = new Dimension(pref.width, min.height);

  672. 	    }

  673. 	    return pref;

  674. 	}

  675.     } // class ShortCutPanel

  676. 

  677. 

  678.     private void updateListRowCount() {

  679. 	if (smallIconsView) {

  680. 	    list.setVisibleRowCount(getModel().getSize() / 3);

  681. 	} else {

  682. 	    list.setVisibleRowCount(-1);

  683. 	}

  684.     }

  685. 

  686.     protected JPanel createList(JFileChooser fc) {

  687. 	JPanel p = new JPanel(new BorderLayout());

  688. 	final JFileChooser fileChooser = fc;

  689. 	list = new JList() {

  690. 	    public int getNextMatch(String prefix, int startIndex, Position.Bias bias) {

  691. 		ListModel model = getModel();

  692. 		int max = model.getSize();

  693. 		if (prefix == null || startIndex < 0 || startIndex >= max) {

  694. 		    throw new IllegalArgumentException();

  695. 		}

  696. 		// start search from the next element before/after the selected element

  697. 		boolean backwards = (bias == Position.Bias.Backward);

  698. 		for (int i = startIndex; backwards ? i >= 0 : i < max; i += (backwards ?  -1 : 1)) {

  699. 		    String filename = fileChooser.getName((File)model.getElementAt(i));

  700. 		    if (filename.regionMatches(true, 0, prefix, 0, prefix.length())) {

  701. 			return i;

  702. 		    }

  703. 		}

  704. 		return -1;

  705. 	    }

  706. 	};

  707. 	list.setCellRenderer(new FileRenderer());

  708. 	list.setLayoutOrientation(JList.VERTICAL_WRAP);

  709. 

  710. 	updateListRowCount();

  711. 

  712. 	getModel().addListDataListener(new ListDataListener() {

  713. 	    public void intervalAdded(ListDataEvent e) {

  714. 		updateListRowCount();

  715. 	    }

  716. 	    public void intervalRemoved(ListDataEvent e) {

  717. 		updateListRowCount();

  718. 	    }

  719. 	    public void contentsChanged(ListDataEvent e) {

  720. 		updateListRowCount();

  721. 	    }

  722. 	});

  723. 

  724. 	if (fc.isMultiSelectionEnabled()) {

  725. 	    list.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  726. 	} else {

  727. 	    list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  728. 	}

  729. 	list.setModel(getModel());

  730. 	list.addListSelectionListener(createListSelectionListener(fc));

  731. 	list.addMouseListener(createDoubleClickListener(fc, list));

  732. 	list.addMouseListener(createSingleClickListener(fc, list));

  733. 	getModel().addListDataListener(new ListDataListener() {

  734. 	    public void contentsChanged(ListDataEvent e) {

  735. 		// Update the selection after JList has been updated

  736. 		new DelayedSelectionUpdater();

  737. 	    }

  738. 	    public void intervalAdded(ListDataEvent e) {

  739. 		int i0 = e.getIndex0();

  740. 		int i1 = e.getIndex1();

  741. 		if (i0 == i1) {

  742. 		    File file = (File)getModel().getElementAt(i0);

  743. 		    if (file.equals(newFolderFile)) {

  744. 			new DelayedSelectionUpdater(file);

  745. 			newFolderFile = null;

  746. 		    }

  747. 		}

  748. 	    }

  749. 	    public void intervalRemoved(ListDataEvent e) {

  750. 	    }

  751. 	});

  752. 

  753. 	JScrollPane scrollpane = new JScrollPane(list);

  754. 	XPStyle xp = XPStyle.getXP();

  755. 	if (xp != null) {

  756. 	    Color bg = xp.getColor("listview.fillcolor", null);

  757. 	    if (bg != null) {

  758. 		list.setBackground(bg);

  759. 	    }

  760. 	}

  761. 	if (listViewBorder != null) {

  762. 	    scrollpane.setBorder(listViewBorder);

  763. 	}

  764. 	p.add(scrollpane, BorderLayout.CENTER);

  765. 	return p;

  766.     }

  767. 

  768.     class DetailsTableModel extends AbstractTableModel implements ListDataListener {

  769. 	String[] columnNames = {

  770. 	    fileNameHeaderText,

  771. 	    fileSizeHeaderText,

  772. 	    fileTypeHeaderText,

  773. 	    fileDateHeaderText,

  774. 	    fileAttrHeaderText

  775. 	};

  776. 	JFileChooser chooser;

  777. 	ListModel listModel;

  778. 

  779. 	DetailsTableModel(JFileChooser fc) {

  780. 	    this.chooser = fc;

  781. 	    listModel = getModel();

  782. 	    listModel.addListDataListener(this);

  783. 	}

  784. 

  785. 	public int getRowCount() {

  786. 	    return listModel.getSize();

  787. 	}

  788. 

  789. 	public int getColumnCount() {

  790. 	    return COLUMN_COLCOUNT;

  791. 	}

  792. 

  793. 	public String getColumnName(int column) {

  794. 	    return columnNames[column];

  795. 	}

  796. 

  797. 	public Class getColumnClass(int column) {

  798. 	    switch (column) {

  799. 	      case COLUMN_FILENAME:

  800. 		  return File.class;

  801. 	      case COLUMN_FILEDATE:

  802. 		  return Date.class;

  803. 	      default:

  804. 		  return super.getColumnClass(column);

  805. 	    }

  806. 	}

  807. 

  808. 	public Object getValueAt(int row, int col) {

  809. 	    // Note: It is very important to avoid getting info on drives, as

  810. 	    // this will trigger "No disk in A:" and similar dialogs.

  811. 	    //

  812. 	    // Use (f.exists() && !chooser.getFileSystemView().isFileSystemRoot(f)) to

  813. 	    // determine if it is safe to call methods directly on f.

  814. 

  815. 	    File f = (File)listModel.getElementAt(row);

  816. 	    switch (col) {

  817. 	      case COLUMN_FILENAME:

  818. 		  return f;

  819. 

  820. 	      case COLUMN_FILESIZE:

  821. 		  if (!f.exists() || f.isDirectory()) {

  822. 		      return null;

  823. 		  }

  824. 		  return (f.length() / 1024 + 1) + "KB";

  825. 

  826. 	      case COLUMN_FILETYPE:

  827. 		  if (!f.exists()) {

  828. 		      return null;

  829. 		  }

  830. 		  return chooser.getFileSystemView().getSystemTypeDescription(f);

  831. 

  832. 	      case COLUMN_FILEDATE:

  833. 		  if (!f.exists() || chooser.getFileSystemView().isFileSystemRoot(f)) {

  834. 		      return null;

  835. 		  }

  836. 		  long time = f.lastModified();

  837. 		  return (time == 0L) ? null : new Date(time);

  838. 

  839. 	      case COLUMN_FILEATTR:

  840. 		  if (!f.exists() || chooser.getFileSystemView().isFileSystemRoot(f)) {

  841. 		      return null;

  842. 		  }

  843. 		  String attributes = "";

  844. 		  if (!f.canWrite()) {

  845. 		      attributes += "R";

  846. 		  }

  847. 		  if (f.isHidden()) {

  848. 		      attributes += "H";

  849. 		  }

  850. 		  return attributes;

  851. 	    }

  852. 	    return null;

  853. 	}

  854. 

  855. 	public void setValueAt(Object value, int row, int col) {

  856. 	    if (col == COLUMN_FILENAME) {

  857. 		JFileChooser chooser = getFileChooser();

  858. 		File f = (File)getValueAt(row, col);

  859. 		String oldDisplayName = chooser.getName(f);

  860. 		String oldFileName = f.getName();

  861. 		String newDisplayName = ((String)value).trim();

  862. 		String newFileName;

  863. 

  864. 		if (!newDisplayName.equals(oldDisplayName)) {

  865. 		    newFileName = newDisplayName;

  866. 		    //Check if extension is hidden from user

  867. 		    int i1 = oldFileName.length();

  868. 		    int i2 = oldDisplayName.length();

  869. 		    if (i1 > i2 && oldFileName.charAt(i2) == '.') {

  870. 			newFileName = newDisplayName + oldFileName.substring(i2);

  871. 		    }

  872. 

  873. 		    // rename

  874. 		    FileSystemView fsv = chooser.getFileSystemView();

  875. 		    File f2 = fsv.createFileObject(f.getParentFile(), newFileName);

  876. 		    if (!f2.exists() && WindowsFileChooserUI.this.getModel().renameFile(f, f2)) {

  877. 			if (fsv.isParent(chooser.getCurrentDirectory(), f2)) {

  878. 			    if (chooser.isMultiSelectionEnabled()) {

  879. 				chooser.setSelectedFiles(new File[] { f2 });

  880. 			    } else {

  881. 				chooser.setSelectedFile(f2);

  882. 			    }

  883. 			} else {

  884. 			    //Could be because of delay in updating Desktop folder

  885. 			    //chooser.setSelectedFile(null);

  886. 			}

  887. 		    } else {

  888. 			// PENDING(jeff) - show a dialog indicating failure

  889. 		    }

  890. 		}

  891. 	    }

  892. 	}

  893. 

  894. 	public boolean isCellEditable(int row, int column) {

  895. 	    return (column == COLUMN_FILENAME);

  896. 	}

  897. 

  898. 	public void contentsChanged(ListDataEvent e) {

  899. 	    fireTableDataChanged();

  900. 	}

  901. 	public void intervalAdded(ListDataEvent e) {

  902. 	    fireTableDataChanged();

  903. 	}

  904. 	public void intervalRemoved(ListDataEvent e) {

  905. 	    fireTableDataChanged();

  906. 	}

  907.     }

  908. 

  909.     class DetailsTableCellRenderer extends DefaultTableCellRenderer {

  910. 	JFileChooser chooser;

  911. 	DateFormat df;

  912. 

  913. 	DetailsTableCellRenderer(JFileChooser chooser) {

  914. 	    this.chooser = chooser;

  915. 	    df = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT,

  916. 						chooser.getLocale());

  917. 	}

  918. 

  919. 	public void setBounds(int x, int y, int width, int height) { 

  920. 	    super.setBounds(x, y, Math.min(width, this.getPreferredSize().width+4), height); 

  921. 	}

  922. 

  923. 	public Component getTableCellRendererComponent(JTable table, Object value,

  924. 			      boolean isSelected, boolean hasFocus, int row, int column) {

  925. 

  926. 	    if (column == COLUMN_FILESIZE || column == COLUMN_FILEATTR) {

  927. 		setHorizontalAlignment(SwingConstants.TRAILING);

  928. 	    } else {

  929. 		setHorizontalAlignment(SwingConstants.LEADING);

  930. 	    }

  931. 

  932. 	    if (column == COLUMN_FILENAME && table.isRowSelected(row) && table.isFocusOwner()) {

  933. 		super.setForeground(table.getSelectionForeground());

  934. 		super.setBackground(table.getSelectionBackground());

  935. 	    } else {

  936. 		super.setForeground(table.getForeground());

  937. 		super.setBackground(table.getBackground());

  938. 	    }

  939. 	    setFont(table.getFont());

  940. 	    setValue(value); 

  941. 

  942. 	    return this;

  943. 	}

  944. 

  945. 	public void setValue(Object value) { 

  946. 	    setIcon(null);

  947. 	    if (value instanceof File) {

  948. 		File file = (File)value;

  949. 		String fileName = chooser.getName(file);

  950. 		setText(fileName);

  951. 		Icon icon = chooser.getIcon(file);

  952. 		setIcon(icon);

  953. 	    } else if (value instanceof Date) {

  954. 		setText((value == null) ? "" : df.format((Date)value));

  955. 	    } else {

  956. 		super.setValue(value);

  957. 	    }

  958. 	}

  959.     }

  960. 

  961.     protected JPanel createDetailsView(JFileChooser fc) {

  962. 	final JFileChooser chooser = fc;

  963. 	JPanel p = new JPanel(new BorderLayout());

  964. 

  965. 	DetailsTableModel detailsTableModel = new DetailsTableModel(chooser);

  966. 

  967. 	detailsTable = new JTable(detailsTableModel) {

  968. 	    // Handle Escape key events here

  969. 	    protected boolean processKeyBinding(KeyStroke ks, KeyEvent e, int condition, boolean pressed) {

  970. 		if (e.getKeyCode() == KeyEvent.VK_ESCAPE && getCellEditor() == null) {

  971. 		    // We are not editing, forward to filechooser.

  972. 		    chooser.dispatchEvent(e);

  973. 		    return true;

  974. 		}

  975. 

  976. 		return super.processKeyBinding(ks, e, condition, pressed);

  977. 	    }

  978. 	};

  979. 

  980. 	detailsTable.setComponentOrientation(chooser.getComponentOrientation());

  981. 	detailsTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

  982. 	detailsTable.setShowGrid(false);

  983. 	detailsTable.setSelectionModel(listSelectionModel); 

  984. 	detailsTable.putClientProperty("JTable.autoStartsEdit", Boolean.FALSE);

  985. 

  986. 	Font font = detailsTable.getFont();

  987. 	detailsTable.setRowHeight(Math.max(font.getSize(), 19)+3);

  988. 

  989. 	TableColumnModel columnModel = detailsTable.getColumnModel();

  990. 	TableColumn[] columns = new TableColumn[COLUMN_COLCOUNT];

  991. 

  992. 	for (int i = 0; i < COLUMN_COLCOUNT; i++) {

  993. 	    columns[i] = columnModel.getColumn(i);

  994. 	    columns[i].setPreferredWidth(COLUMN_WIDTHS[i]);

  995. 	}

  996. 

  997. 	TableCellRenderer cellRenderer = new DetailsTableCellRenderer(chooser);

  998. 	detailsTable.setDefaultRenderer(File.class, cellRenderer);

  999. 	detailsTable.setDefaultRenderer(Date.class, cellRenderer);

  1000. 	detailsTable.setDefaultRenderer(Object.class, cellRenderer);

  1001. 

  1002. 	// Install cell editor for editing file name

  1003. 	final JTextField tf = new JTextField();

  1004. 	tf.addFocusListener(editorFocusListener);

  1005. 	columns[COLUMN_FILENAME].setCellEditor(new DefaultCellEditor(tf) {

  1006. 	    public boolean isCellEditable(EventObject e) {

  1007. 		if (e instanceof MouseEvent) { 

  1008. 		    MouseEvent me = (MouseEvent)e;

  1009. 		    int index = detailsTable.rowAtPoint(me.getPoint());

  1010. 		    return (me.getClickCount() == 1 && detailsTable.isRowSelected(index));

  1011. 		}

  1012. 		return super.isCellEditable(e);

  1013. 	    }

  1014. 

  1015. 	    public Component getTableCellEditorComponent(JTable table, Object value,

  1016. 							 boolean isSelected, int row, int column) {

  1017. 		Component comp = super.getTableCellEditorComponent(table, value, isSelected, row, column);

  1018. 		if (value instanceof File) {

  1019. 		    tf.setText(chooser.getName((File)value));

  1020. 		    tf.requestFocus();

  1021. 		    tf.selectAll();

  1022. 		}		

  1023. 		return comp;

  1024. 	    }

  1025. 	});

  1026. 

  1027. 	JList fakeList = new JList(detailsTableModel.listModel) {

  1028. 	    JTable table = detailsTable;

  1029. 

  1030. 	    public int locationToIndex(Point location) {

  1031. 		return table.rowAtPoint(location);

  1032. 	    }

  1033. 

  1034. 	    public Rectangle getCellBounds(int index0, int index1) {

  1035. 		Rectangle r0 = table.getCellRect(index0, COLUMN_FILENAME, false);

  1036. 		Rectangle r1 = table.getCellRect(index1, COLUMN_FILENAME, false);

  1037. 		return r0.union(r1);

  1038. 	    }

  1039. 	    

  1040. 	    public Object getSelectedValue() {

  1041. 		return table.getValueAt(table.getSelectedRow(), COLUMN_FILENAME);

  1042. 	    }

  1043. 

  1044. 	    public Component add(Component comp) {

  1045. 		if (comp instanceof JTextField) {

  1046. 		    return table.add(comp);

  1047. 		} else {

  1048. 		    return super.add(comp);

  1049. 		}

  1050. 	    }

  1051. 

  1052. 	    public void repaint() {

  1053. 		if (table != null)

  1054. 		    table.repaint();

  1055. 	    }

  1056. 

  1057. 	    public TransferHandler getTransferHandler() {

  1058. 		if (table != null) {

  1059. 		    return table.getTransferHandler();

  1060. 		} else {

  1061. 		    return super.getTransferHandler();

  1062. 		}

  1063. 	    }

  1064. 

  1065. 	    public void setTransferHandler(TransferHandler newHandler) {

  1066. 		if (table != null) {

  1067. 		    table.setTransferHandler(newHandler);

  1068. 		} else {

  1069. 		    super.setTransferHandler(newHandler);

  1070. 		}

  1071. 	    }

  1072. 

  1073. 	    public boolean getDragEnabled() {

  1074. 		if (table != null) {

  1075. 		    return table.getDragEnabled();

  1076. 		} else {

  1077. 		    return super.getDragEnabled();

  1078. 		}

  1079. 	    }

  1080. 

  1081. 	    public void setDragEnabled(boolean b) {

  1082. 		if (table != null) {

  1083. 		    table.setDragEnabled(b);

  1084. 		} else {

  1085. 		    super.setDragEnabled(b);

  1086. 		}

  1087. 	    }

  1088. 	};

  1089. 

  1090. 	fakeList.setSelectionModel(listSelectionModel);

  1091. 	detailsTable.addMouseListener(createDoubleClickListener(chooser, fakeList));

  1092. 	//detailsTable.addMouseListener(createSingleClickListener(chooser, fakeList));

  1093. 

  1094. 	JScrollPane scrollpane = new JScrollPane(detailsTable);

  1095. 	scrollpane.setComponentOrientation(chooser.getComponentOrientation());

  1096.         LookAndFeel.installColors(scrollpane.getViewport(), "Table.background", "Table.foreground");

  1097. 

  1098. 	scrollpane.addComponentListener(new ComponentAdapter() {

  1099. 	    public void componentResized(ComponentEvent e) {

  1100. 		JScrollPane sp = (JScrollPane)e.getComponent();

  1101. 		fixNameColumnWidth(sp.getViewport().getSize().width);

  1102. 		sp.removeComponentListener(this);

  1103. 	    }

  1104. 	});

  1105. 

  1106. 	XPStyle xp = XPStyle.getXP();

  1107. 	if (xp != null) {

  1108. 	    Color bg = xp.getColor("listview.fillcolor", null);

  1109. 	    if (bg != null) {

  1110. 		list.setBackground(bg);

  1111. 	    }

  1112. 	}

  1113. 	if (listViewBorder != null) {

  1114. 	    scrollpane.setBorder(listViewBorder);

  1115. 	}

  1116. 	p.add(scrollpane, BorderLayout.CENTER);

  1117. 	return p;

  1118.     }

  1119. 

  1120.     private void fixNameColumnWidth(int viewWidth) {

  1121. 	TableColumn nameCol = detailsTable.getColumnModel().getColumn(COLUMN_FILENAME);

  1122. 	int tableWidth = detailsTable.getPreferredSize().width;

  1123. 

  1124. 	if (tableWidth < viewWidth) {

  1125. 	    nameCol.setPreferredWidth(nameCol.getPreferredWidth() + viewWidth - tableWidth);

  1126. 	}

  1127.     }

  1128. 

  1129.     private class DelayedSelectionUpdater implements Runnable {

  1130. 	File editFile;

  1131. 

  1132. 	DelayedSelectionUpdater() {

  1133. 	    this(null);

  1134. 	}

  1135. 

  1136. 	DelayedSelectionUpdater(File editFile) {

  1137. 	    this.editFile = editFile;

  1138. 	    SwingUtilities.invokeLater(this);

  1139. 	}

  1140. 

  1141. 	public void run() {

  1142. 	    setFileSelected();

  1143. 	    if (editFile != null) {

  1144. 		editFileName(getModel().indexOf(editFile));

  1145. 		editFile = null;

  1146. 	    }

  1147. 	}

  1148.     }

  1149. 

  1150. 

  1151.     /**

  1152.      * Creates a selection listener for the list of files and directories.

  1153.      *

  1154.      * @param fc a <code>JFileChooser</code>

  1155.      * @return a <code>ListSelectionListener</code>

  1156.      */

  1157.     public ListSelectionListener createListSelectionListener(JFileChooser fc) {

  1158. 	return new SelectionListener() {

  1159. 	    public void valueChanged(ListSelectionEvent e) {

  1160. 		if (!e.getValueIsAdjusting()) {

  1161. 		    JFileChooser chooser = getFileChooser();

  1162. 		    FileSystemView fsv = chooser.getFileSystemView();

  1163. 		    JList list = (JList) e.getSource();

  1164. 

  1165. 		    if (chooser.isMultiSelectionEnabled()) {

  1166. 			File[] files = null;

  1167. 			Object[] objects = list.getSelectedValues();

  1168. 			if (objects != null) {

  1169. 			    if (objects.length == 1

  1170. 				&& ((File)objects[0]).isDirectory()

  1171. 				&& chooser.isTraversable(((File)objects[0]))

  1172. 				&& (chooser.getFileSelectionMode() == chooser.FILES_ONLY

  1173. 				    || !fsv.isFileSystem(((File)objects[0])))) {

  1174. 				setDirectorySelected(true);

  1175. 				setDirectory(((File)objects[0]));

  1176. 			    } else {

  1177. 				files = new File[objects.length];

  1178. 				int j = 0;

  1179. 				for (int i = 0; i < objects.length; i++) {

  1180. 				    File f = (File)objects[i];

  1181. 				    boolean isDir = f.isDirectory();

  1182. 				    boolean isFile = ShellFolder.disableFileChooserSpeedFix() ? f.isFile() : !isDir;

  1183. 				    if ((chooser.isFileSelectionEnabled() && isFile)

  1184. 					|| (chooser.isDirectorySelectionEnabled()

  1185. 					    && fsv.isFileSystem(f)

  1186. 					    && isDir)) {

  1187. 					files[j++] = f;

  1188. 				    }

  1189. 				}

  1190. 				if (j == 0) {

  1191. 				    files = null;

  1192. 				} else if (j < objects.length) {

  1193. 				    File[] tmpFiles = new File[j];

  1194. 				    System.arraycopy(files, 0, tmpFiles, 0, j);

  1195. 				    files = tmpFiles;

  1196. 				}

  1197. 				setDirectorySelected(false);

  1198. 			    }

  1199. 			}

  1200. 			chooser.setSelectedFiles(files);

  1201. 		    } else {

  1202. 			File file = (File)list.getSelectedValue();

  1203. 			if (file != null

  1204. 			    && file.isDirectory()

  1205. 			    && chooser.isTraversable(file)

  1206. 			    && (chooser.getFileSelectionMode() == chooser.FILES_ONLY

  1207. 				|| !fsv.isFileSystem(file))) {

  1208. 

  1209. 			    setDirectorySelected(true);

  1210. 			    setDirectory(file);

  1211. 			    chooser.setSelectedFile(null);

  1212. 			} else {

  1213. 			    setDirectorySelected(false);

  1214. 

  1215. 			    if (file != null) {

  1216. 			       chooser.setSelectedFile(file);

  1217. 			    }

  1218. 			}

  1219. 		    }

  1220. 		}

  1221. 	    }

  1222. 	};

  1223.     }

  1224. 

  1225.     private MouseListener createSingleClickListener(JFileChooser fc, JList list) {

  1226. 	return new SingleClickListener(list);

  1227.     }

  1228. 

  1229.     int lastIndex = -1;

  1230.     File editFile = null;

  1231.     int editX = 20;

  1232. 

  1233.     private int getEditIndex() {

  1234. 	return lastIndex;

  1235.     }

  1236. 

  1237.     private void setEditIndex(int i) {

  1238. 	lastIndex = i;

  1239.     }

  1240. 

  1241.     private void resetEditIndex() {

  1242. 	lastIndex = -1;

  1243.     }

  1244. 

  1245.     private void cancelEdit() {

  1246. 	if (editFile != null) {

  1247. 	    editFile = null;

  1248. 	    list.remove(editCell);

  1249. 	    centerPanel.repaint();

  1250. 	} else if (detailsTable != null && detailsTable.isEditing()) {

  1251. 	    detailsTable.getCellEditor().cancelCellEditing();

  1252. 	}

  1253.     }

  1254. 

  1255.     JTextField editCell = null;

  1256. 

  1257.     private void editFileName(int index) {

  1258. 	ensureIndexIsVisible(index);

  1259. 	if (listViewPanel.isVisible()) {

  1260. 	    editFile = (File)getModel().getElementAt(index);

  1261. 	    Rectangle r = list.getCellBounds(index, index);

  1262. 	    if (editCell == null) {

  1263. 		editCell = new JTextField();

  1264. 		editCell.addActionListener(new EditActionListener());

  1265. 		editCell.addFocusListener(editorFocusListener);

  1266. 		editCell.setNextFocusableComponent(list);

  1267. 	    }

  1268. 	    list.add(editCell);

  1269. 	    editCell.setText(getFileChooser().getName(editFile));

  1270. 	    if (list.getComponentOrientation().isLeftToRight()) {

  1271. 		editCell.setBounds(editX + r.x, r.y, r.width - editX, r.height);

  1272. 	    } else {

  1273. 		editCell.setBounds(r.x, r.y, r.width - editX, r.height);

  1274. 	    }

  1275. 	    editCell.requestFocus();

  1276. 	    editCell.selectAll();

  1277. 	} else if (detailsViewPanel.isVisible()) {

  1278. 	    detailsTable.editCellAt(index, COLUMN_FILENAME);

  1279. 	}

  1280.     }

  1281. 

  1282. 

  1283.     protected class SingleClickListener extends MouseAdapter {

  1284. 	JList list;

  1285. 

  1286. 	public  SingleClickListener(JList list) {

  1287. 	    this.list = list;

  1288. 	}

  1289. 

  1290. 	public void mouseClicked(MouseEvent e) {

  1291. 	    if (SwingUtilities.isLeftMouseButton(e)) {

  1292. 		if (e.getClickCount() == 1) {

  1293. 		    JFileChooser fc = getFileChooser();

  1294. 		    int index = list.locationToIndex(e.getPoint());

  1295. 		    if ((!fc.isMultiSelectionEnabled() || fc.getSelectedFiles().length <= 1)

  1296. 			&& index >= 0 && list.isSelectedIndex(index)

  1297. 			&& getEditIndex() == index && editFile == null) {

  1298. 

  1299. 			editFileName(index);

  1300. 		    } else {

  1301. 			if (index >= 0) {

  1302. 			    setEditIndex(index);

  1303. 			} else {

  1304. 			    resetEditIndex();

  1305. 			}

  1306. 		    }

  1307. 		} else {

  1308. 		    // on double click (open or drill down one directory) be

  1309. 		    // sure to clear the edit index

  1310. 		    resetEditIndex();

  1311. 		}

  1312. 	    }	    

  1313. 	}

  1314.     }

  1315. 

  1316.     public Action getNewFolderAction() {

  1317. 	return newFolderAction;

  1318.     }

  1319. 

  1320.     /**

  1321.      * Creates a new folder.

  1322.      */

  1323.     protected class WindowsNewFolderAction extends NewFolderAction {

  1324. 	public void actionPerformed(ActionEvent e) {

  1325. 	    JFileChooser fc = getFileChooser();

  1326. 	    File oldFile = fc.getSelectedFile();

  1327. 	    super.actionPerformed(e);

  1328. 	    File newFile = fc.getSelectedFile();

  1329. 	    if (newFile != null && !newFile.equals(oldFile) && newFile.isDirectory()) {

  1330. 		newFolderFile = newFile;

  1331. 	    }

  1332. 	}

  1333.     }

  1334. 

  1335.     class EditActionListener implements ActionListener {

  1336. 	public void actionPerformed(ActionEvent e) {

  1337. 	    applyEdit();

  1338. 	} 

  1339.     }

  1340. 

  1341.     private void applyEdit() {

  1342. 	if (editFile != null && editFile.exists()) {

  1343. 	    JFileChooser chooser = getFileChooser();

  1344. 	    String oldDisplayName = chooser.getName(editFile);

  1345. 	    String oldFileName = editFile.getName();

  1346. 	    String newDisplayName = editCell.getText().trim();

  1347. 	    String newFileName;

  1348. 

  1349. 	    if (!newDisplayName.equals(oldDisplayName)) {

  1350. 		newFileName = newDisplayName;

  1351. 		//Check if extension is hidden from user

  1352. 		int i1 = oldFileName.length();

  1353. 		int i2 = oldDisplayName.length();

  1354. 		if (i1 > i2 && oldFileName.charAt(i2) == '.') {

  1355. 		    newFileName = newDisplayName + oldFileName.substring(i2);

  1356. 		}

  1357. 

  1358. 		// rename

  1359. 		FileSystemView fsv = chooser.getFileSystemView();

  1360. 		File f2 = fsv.createFileObject(editFile.getParentFile(), newFileName);

  1361. 		if (!f2.exists() && getModel().renameFile(editFile, f2)) {

  1362. 		    if (fsv.isParent(chooser.getCurrentDirectory(), f2)) {

  1363. 			if (chooser.isMultiSelectionEnabled()) {

  1364. 			    chooser.setSelectedFiles(new File[] { f2 });

  1365. 			} else {

  1366. 			    chooser.setSelectedFile(f2);

  1367. 			}

  1368. 		    } else {

  1369. 			//Could be because of delay in updating Desktop folder

  1370. 			//chooser.setSelectedFile(null);

  1371. 		    }

  1372. 		} else {

  1373. 		    // PENDING(jeff) - show a dialog indicating failure

  1374. 		}

  1375. 	    }

  1376. 	} 

  1377.         if (detailsTable != null && detailsTable.isEditing()) {

  1378.             detailsTable.getCellEditor().stopCellEditing();

  1379.         }

  1380. 	cancelEdit();

  1381.     }

  1382. 

  1383.     protected class FileRenderer extends DefaultListCellRenderer  {

  1384. 

  1385. 	public void setBounds(int x, int y, int width, int height) { 

  1386. 	    super.setBounds(x, y, Math.min(width, this.getPreferredSize().width+4), height); 

  1387. 	}

  1388. 

  1389. 	public Component getListCellRendererComponent(JList list, Object value,

  1390. 						      int index, boolean isSelected,

  1391. 						      boolean cellHasFocus) {

  1392. 

  1393. 	    super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

  1394. 	    File file = (File) value;

  1395. 	    String fileName = getFileChooser().getName(file);

  1396. 	    setText(fileName);

  1397. 

  1398. 	    Icon icon = getFileChooser().getIcon(file);

  1399. 	    setIcon(icon);

  1400. 

  1401. 	    if(isSelected) {

  1402. 		// PENDING(jeff) - grab padding (4) below from defaults table.

  1403. 		editX = icon.getIconWidth() + 4;

  1404. 	    }

  1405. 

  1406. 	    return this;

  1407. 	}

  1408.     }

  1409. 

  1410.     public void uninstallUI(JComponent c) {

  1411. 	// Remove listeners

  1412. 	c.removePropertyChangeListener(filterComboBoxModel);

  1413. 	cancelButton.removeActionListener(getCancelSelectionAction());

  1414. 	approveButton.removeActionListener(getApproveSelectionAction());

  1415. 	filenameTextField.removeActionListener(getApproveSelectionAction());

  1416. 

  1417. 	super.uninstallUI(c);

  1418.     }

  1419. 

  1420.     /**

  1421.      * Returns the preferred size of the specified

  1422.      * <code>JFileChooser</code>.

  1423.      * The preferred size is at least as large,

  1424.      * in both height and width,

  1425.      * as the preferred size recommended

  1426.      * by the file chooser's layout manager.

  1427.      *

  1428.      * @param c  a <code>JFileChooser</code>

  1429.      * @return   a <code>Dimension</code> specifying the preferred

  1430.      *           width and height of the file chooser

  1431.      */

  1432.     public Dimension getPreferredSize(JComponent c) {

  1433. 	int prefWidth = PREF_SIZE.width;

  1434. 	Dimension d = c.getLayout().preferredLayoutSize(c);

  1435. 	if (d != null) {

  1436. 	    return new Dimension(d.width < prefWidth ? prefWidth : d.width,

  1437. 				 d.height < PREF_SIZE.height ? PREF_SIZE.height : d.height);

  1438. 	} else {

  1439. 	    return new Dimension(prefWidth, PREF_SIZE.height);

  1440. 	}

  1441.     }

  1442. 

  1443.     /**

  1444.      * Returns the minimum size of the <code>JFileChooser</code>.

  1445.      *

  1446.      * @param c  a <code>JFileChooser</code>

  1447.      * @return   a <code>Dimension</code> specifying the minimum

  1448.      *           width and height of the file chooser

  1449.      */

  1450.     public Dimension getMinimumSize(JComponent c) {

  1451. 	return MIN_SIZE;

  1452.     }

  1453. 

  1454.     /**

  1455.      * Returns the maximum size of the <code>JFileChooser</code>.

  1456.      *

  1457.      * @param c  a <code>JFileChooser</code>

  1458.      * @return   a <code>Dimension</code> specifying the maximum 

  1459.      *           width and height of the file chooser

  1460.      */

  1461.     public Dimension getMaximumSize(JComponent c) {

  1462. 	return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);

  1463.     }

  1464. 

  1465.     void setFileSelected() {

  1466. 	if (getFileChooser().isMultiSelectionEnabled() && !isDirectorySelected()) {

  1467. 	    File[] files = getFileChooser().getSelectedFiles();	// Should be selected

  1468. 	    Object[] selectedObjects = list.getSelectedValues(); // Are actually selected

  1469. 

  1470. 	    if (ShellFolder.disableFileChooserSpeedFix()) {

  1471. 		// Remove files that shouldn't be selected

  1472. 		for (int j = 0; j < selectedObjects.length; j++) {

  1473. 		    boolean found = false;

  1474. 		    for (int i = 0; i < files.length; i++) {

  1475. 			if (files[i].equals(selectedObjects[j])) {

  1476. 			    found = true;

  1477. 			    break;

  1478. 			}

  1479. 		    }

  1480. 		    if (!found) {

  1481. 			int index = getModel().indexOf(selectedObjects[j]);

  1482. 			if (index >= 0) {

  1483. 			    listSelectionModel.removeSelectionInterval(index, index);

  1484. 			}

  1485. 		    }

  1486. 		}

  1487. 		// Add files that should be selected

  1488. 		for (int i = 0; i < files.length; i++) {

  1489. 		    boolean found = false;

  1490. 		    for (int j = 0; j < selectedObjects.length; j++) {

  1491. 			if (files[i].equals(selectedObjects[j])) {

  1492. 			    found = true;

  1493. 			    break;

  1494. 			}

  1495. 		    }

  1496. 		    if (!found) {

  1497. 			int index = getModel().indexOf(files[i]);

  1498. 			if (index >= 0) {

  1499. 			    listSelectionModel.addSelectionInterval(index, index);

  1500. 			}

  1501. 		    }

  1502. 		}

  1503. 	    } else {

  1504. 		listSelectionModel.setValueIsAdjusting(true);

  1505. 		try {

  1506. 		    Arrays.sort(files);

  1507. 		    Arrays.sort(selectedObjects);

  1508. 

  1509. 		    int shouldIndex = 0;

  1510. 		    int actuallyIndex = 0;

  1511. 

  1512. 		    // Remove files that shouldn't be selected and add files which should be selected

  1513. 		    // Note: Assume files are already sorted in compareTo order.

  1514. 		    while (shouldIndex < files.length &&

  1515. 			   actuallyIndex < selectedObjects.length) {

  1516. 			int comparison = files[shouldIndex].compareTo(selectedObjects[actuallyIndex]);

  1517. 			if (comparison < 0) {

  1518. 			    int index = getModel().indexOf(files[shouldIndex]);

  1519. 			    listSelectionModel.addSelectionInterval(index, index);

  1520. 			    shouldIndex++;

  1521. 			} else if (comparison > 0) {

  1522. 			    int index = getModel().indexOf(selectedObjects[actuallyIndex]);

  1523. 			    listSelectionModel.removeSelectionInterval(index, index);

  1524. 			    actuallyIndex++;

  1525. 			} else {

  1526. 			    // Do nothing

  1527. 			    shouldIndex++;

  1528. 			    actuallyIndex++;

  1529. 			}

  1530. 

  1531. 		    }

  1532. 

  1533. 		    while (shouldIndex < files.length) {

  1534. 			int index = getModel().indexOf(files[shouldIndex]);

  1535. 			listSelectionModel.addSelectionInterval(index, index);

  1536. 			shouldIndex++;

  1537. 		    }

  1538. 

  1539. 		    while (actuallyIndex < selectedObjects.length) {

  1540. 			int index = getModel().indexOf(selectedObjects[actuallyIndex]);

  1541. 			listSelectionModel.removeSelectionInterval(index, index);

  1542. 			actuallyIndex++;

  1543. 		    }

  1544. 		} finally {

  1545. 		    listSelectionModel.setValueIsAdjusting(false);

  1546. 		}

  1547. 	    }

  1548. 	} else {

  1549. 	    JFileChooser chooser = getFileChooser();

  1550. 	    File f = null;

  1551. 	    if (isDirectorySelected()) {

  1552. 		f = getDirectory();

  1553. 	    } else {

  1554. 		f = chooser.getSelectedFile();

  1555. 	    }

  1556. 	    int i;

  1557. 	    if (f != null && (i = getModel().indexOf(f)) >= 0) {

  1558. 		listSelectionModel.setSelectionInterval(i, i);

  1559. 		ensureIndexIsVisible(i);

  1560. 	    } else {

  1561. 		listSelectionModel.clearSelection();

  1562. 	    }

  1563. 	}

  1564.     }

  1565. 

  1566. 

  1567.     private String fileNameString(File file) {

  1568. 	if (file == null) {

  1569. 	    return null;

  1570. 	} else {

  1571. 	    JFileChooser fc = getFileChooser();

  1572. 	    if (fc.isDirectorySelectionEnabled() && !fc.isFileSelectionEnabled()) {

  1573. 		return file.getPath();

  1574. 	    } else {

  1575. 		return file.getName();

  1576. 	    }

  1577. 	}

  1578.     }

  1579. 

  1580.     private String fileNameString(File[] files) {

  1581. 	StringBuffer buf = new StringBuffer();

  1582. 	for (int i = 0; files != null && i < files.length; i++) {

  1583. 	    if (i > 0) {

  1584. 		buf.append(" ");

  1585. 	    }

  1586. 	    if (files.length > 1) {

  1587. 		buf.append("\"");

  1588. 	    }

  1589. 	    buf.append(fileNameString(files[i]));

  1590. 	    if (files.length > 1) {

  1591. 		buf.append("\"");

  1592. 	    }

  1593. 	}

  1594. 	return buf.toString();

  1595.     }

  1596. 

  1597.     /* The following methods are used by the PropertyChange Listener */

  1598. 

  1599.     private void doSelectedFileChanged(PropertyChangeEvent e) {

  1600. 	applyEdit();

  1601. 	File f = (File) e.getNewValue();

  1602. 	JFileChooser fc = getFileChooser();

  1603. 	if (f != null 

  1604. 	    && ((fc.isFileSelectionEnabled() && !f.isDirectory())

  1605. 		|| (f.isDirectory() && fc.isDirectorySelectionEnabled()))) {

  1606. 

  1607. 	    setFileName(fileNameString(f));

  1608. 	    setFileSelected();

  1609. 	}

  1610.     }

  1611.     

  1612.     private void doSelectedFilesChanged(PropertyChangeEvent e) {

  1613. 	applyEdit();

  1614. 	File[] files = (File[]) e.getNewValue();

  1615. 	JFileChooser fc = getFileChooser();

  1616. 	if (files != null

  1617. 	    && files.length > 0

  1618. 	    && (files.length > 1 || fc.isDirectorySelectionEnabled() || !files[0].isDirectory())) {

  1619. 	    setFileName(fileNameString(files));

  1620. 	    setFileSelected();

  1621. 	}

  1622.     }

  1623.     

  1624.     private void doDirectoryChanged(PropertyChangeEvent e) {

  1625. 	JFileChooser fc = getFileChooser();

  1626. 	FileSystemView fsv = fc.getFileSystemView();

  1627. 

  1628. 	applyEdit();

  1629. 	resetEditIndex();

  1630. 	clearIconCache();

  1631. 	listSelectionModel.clearSelection();

  1632. 	ensureIndexIsVisible(0);

  1633. 	File currentDirectory = fc.getCurrentDirectory();

  1634. 	if (shortCutPanel != null) {

  1635. 	    shortCutPanel.doDirectoryChanged(currentDirectory);

  1636. 	}

  1637. 	if(currentDirectory != null) {

  1638. 	    directoryComboBoxModel.addItem(currentDirectory);

  1639. 	    getNewFolderAction().setEnabled(currentDirectory.canWrite());

  1640. 	    getChangeToParentDirectoryAction().setEnabled(!fsv.isRoot(currentDirectory));

  1641. 

  1642. 	    if (fc.isDirectorySelectionEnabled() && !fc.isFileSelectionEnabled()) {

  1643. 		if (fsv.isFileSystem(currentDirectory)) {

  1644. 		    setFileName(currentDirectory.getPath());

  1645. 		} else {

  1646. 		    setFileName(null);

  1647. 		}

  1648. 	    }

  1649. 	}

  1650.     }

  1651. 

  1652.     private void doFilterChanged(PropertyChangeEvent e) {

  1653. 	applyEdit();

  1654. 	resetEditIndex();

  1655. 	clearIconCache();

  1656. 	listSelectionModel.clearSelection();

  1657.     }

  1658. 

  1659.     private void doFileSelectionModeChanged(PropertyChangeEvent e) {

  1660. 	applyEdit();

  1661. 	resetEditIndex();

  1662. 	clearIconCache();

  1663. 	listSelectionModel.clearSelection();

  1664. 

  1665. 	JFileChooser fc = getFileChooser();

  1666. 	File currentDirectory = fc.getCurrentDirectory();

  1667. 	if (currentDirectory != null

  1668. 	    && fc.isDirectorySelectionEnabled()

  1669. 	    && !fc.isFileSelectionEnabled()

  1670. 	    && fc.getFileSystemView().isFileSystem(currentDirectory)) {

  1671. 

  1672. 	    setFileName(currentDirectory.getPath());

  1673. 	} else {

  1674. 	    setFileName(null);

  1675. 	}

  1676.     }

  1677. 

  1678.     private void doMultiSelectionChanged(PropertyChangeEvent e) {

  1679. 	if (getFileChooser().isMultiSelectionEnabled()) {

  1680. 	    listSelectionModel.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  1681. 	} else {

  1682. 	    listSelectionModel.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  1683. 	    listSelectionModel.clearSelection();

  1684. 	    getFileChooser().setSelectedFiles(null);

  1685. 	}

  1686.     }

  1687.     

  1688.     private void doAccessoryChanged(PropertyChangeEvent e) {

  1689. 	if(getAccessoryPanel() != null) {

  1690. 	    if(e.getOldValue() != null) {

  1691. 		getAccessoryPanel().remove((JComponent) e.getOldValue());

  1692. 	    }

  1693. 	    JComponent accessory = (JComponent) e.getNewValue();

  1694. 	    if(accessory != null) {

  1695. 		getAccessoryPanel().add(accessory, BorderLayout.CENTER);

  1696. 	    }

  1697. 	}

  1698.     }

  1699. 

  1700.     private void doApproveButtonTextChanged(PropertyChangeEvent e) {

  1701. 	JFileChooser chooser = getFileChooser();

  1702. 	approveButton.setText(getApproveButtonText(chooser));

  1703. 	approveButton.setToolTipText(getApproveButtonToolTipText(chooser));

  1704. 	approveButton.setMnemonic(getApproveButtonMnemonic(chooser));

  1705.     }

  1706. 

  1707.     private void doDialogTypeChanged(PropertyChangeEvent e) {

  1708. 	JFileChooser chooser = getFileChooser();

  1709. 	approveButton.setText(getApproveButtonText(chooser));

  1710. 	approveButton.setToolTipText(getApproveButtonToolTipText(chooser));

  1711. 	approveButton.setMnemonic(getApproveButtonMnemonic(chooser));

  1712. 	if (chooser.getDialogType() == JFileChooser.SAVE_DIALOG) {

  1713. 	    lookInLabel.setText(saveInLabelText);

  1714. 	} else {

  1715. 	    lookInLabel.setText(lookInLabelText);

  1716. 	}

  1717.     }

  1718. 

  1719.     private void doApproveButtonMnemonicChanged(PropertyChangeEvent e) {

  1720. 	approveButton.setMnemonic(getApproveButtonMnemonic(getFileChooser()));

  1721.     }

  1722. 

  1723.     private void doControlButtonsChanged(PropertyChangeEvent e) {

  1724. 	if(getFileChooser().getControlButtonsAreShown()) {

  1725. 	    addControlButtons();

  1726. 	} else {

  1727. 	    removeControlButtons();

  1728. 	}

  1729.     }

  1730. 

  1731.     /*

  1732.      * Listen for filechooser property changes, such as

  1733.      * the selected file changing, or the type of the dialog changing.

  1734.      */

  1735.     public PropertyChangeListener createPropertyChangeListener(JFileChooser fc) {

  1736. 	return new PropertyChangeListener() {

  1737. 	    public void propertyChange(PropertyChangeEvent e) {

  1738. 		String s = e.getPropertyName();

  1739. 		if(s.equals(JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)) {

  1740. 		    doSelectedFileChanged(e);

  1741. 		} else if (s.equals(JFileChooser.SELECTED_FILES_CHANGED_PROPERTY)) {

  1742. 		    doSelectedFilesChanged(e);

  1743. 		} else if(s.equals(JFileChooser.DIRECTORY_CHANGED_PROPERTY)) {

  1744. 		    doDirectoryChanged(e);

  1745. 		} else if(s.equals(JFileChooser.FILE_FILTER_CHANGED_PROPERTY)) {

  1746. 		    doFilterChanged(e);

  1747. 		} else if(s.equals(JFileChooser.FILE_SELECTION_MODE_CHANGED_PROPERTY)) {

  1748. 		    doFileSelectionModeChanged(e);

  1749. 		} else if(s.equals(JFileChooser.MULTI_SELECTION_ENABLED_CHANGED_PROPERTY)) {

  1750. 		    doMultiSelectionChanged(e);

  1751. 		} else if(s.equals(JFileChooser.ACCESSORY_CHANGED_PROPERTY)) {

  1752. 		    doAccessoryChanged(e);

  1753. 		} else if (s.equals(JFileChooser.APPROVE_BUTTON_TEXT_CHANGED_PROPERTY) ||

  1754. 			   s.equals(JFileChooser.APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY)) { 

  1755. 		    doApproveButtonTextChanged(e);

  1756. 		} else if(s.equals(JFileChooser.DIALOG_TYPE_CHANGED_PROPERTY)) {

  1757. 		    doDialogTypeChanged(e);

  1758. 		} else if(s.equals(JFileChooser.APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY)) {

  1759. 		    doApproveButtonMnemonicChanged(e);

  1760. 		} else if(s.equals(JFileChooser.CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY)) {

  1761. 		    doControlButtonsChanged(e);

  1762. 		} else if (s.equals("componentOrientation")) {

  1763. 		    ComponentOrientation o = (ComponentOrientation)e.getNewValue();

  1764. 		    JFileChooser cc = (JFileChooser)e.getSource();

  1765. 		    if (o != (ComponentOrientation)e.getOldValue()) {

  1766. 			cc.applyComponentOrientation(o);

  1767. 		    }

  1768. 		    if (detailsTable != null) {

  1769. 			detailsTable.setComponentOrientation(o);

  1770. 			detailsTable.getParent().getParent().setComponentOrientation(o);

  1771. 		    }

  1772. 		} else if (s == "FileChooser.useShellFolder") {

  1773. 		    updateUseShellFolder();

  1774. 		    doDirectoryChanged(e);

  1775. 		} else if (s.equals("ancestor")) {

  1776. 		    if (e.getOldValue() == null && e.getNewValue() != null) {

  1777. 			// Ancestor was added, set initial focus

  1778. 			filenameTextField.selectAll();

  1779. 			filenameTextField.requestFocus();

  1780. 		    }

  1781. 		}

  1782. 	    }

  1783. 	};

  1784.     }

  1785. 

  1786. 

  1787.     protected void removeControlButtons() {

  1788. 	getBottomPanel().remove(getButtonPanel());

  1789.     }

  1790. 

  1791.     protected void addControlButtons() {

  1792. 	getBottomPanel().add(getButtonPanel());

  1793.     }

  1794. 

  1795.     private void ensureIndexIsVisible(int i) {

  1796. 	if (i >= 0) {

  1797. 	    list.ensureIndexIsVisible(i);

  1798. 	    if (detailsTable != null) {

  1799. 		detailsTable.scrollRectToVisible(detailsTable.getCellRect(i, COLUMN_FILENAME, true));

  1800. 	    }

  1801. 	}

  1802.     }

  1803. 

  1804.     public void ensureFileIsVisible(JFileChooser fc, File f) {

  1805. 	ensureIndexIsVisible(getModel().indexOf(f));

  1806.     }

  1807. 

  1808.     public void rescanCurrentDirectory(JFileChooser fc) {

  1809. 	getModel().validateFileCache();

  1810.     }

  1811. 

  1812.     public String getFileName() {

  1813. 	if(filenameTextField != null) {

  1814. 	    return filenameTextField.getText();

  1815. 	} else {

  1816. 	    return null;

  1817. 	}

  1818.     }

  1819. 

  1820.     public void setFileName(String filename) {

  1821. 	if(filenameTextField != null) {

  1822. 	    filenameTextField.setText(filename);

  1823. 	}

  1824.     }

  1825. 

  1826.     /**

  1827.      * Property to remember whether a directory is currently selected in the UI.

  1828.      * This is normally called by the UI on a selection event.

  1829.      *

  1830.      * @param directorySelected if a directory is currently selected.

  1831.      * @since 1.4

  1832.      */

  1833.     protected void setDirectorySelected(boolean directorySelected) {

  1834. 	super.setDirectorySelected(directorySelected);

  1835. 	JFileChooser chooser = getFileChooser();

  1836. 	if(directorySelected) {

  1837. 	    approveButton.setText(directoryOpenButtonText);

  1838. 	    approveButton.setToolTipText(directoryOpenButtonToolTipText);

  1839. 	    approveButton.setMnemonic(directoryOpenButtonMnemonic);

  1840. 	} else {

  1841. 	    approveButton.setText(getApproveButtonText(chooser));

  1842. 	    approveButton.setToolTipText(getApproveButtonToolTipText(chooser));

  1843. 	    approveButton.setMnemonic(getApproveButtonMnemonic(chooser));

  1844. 	}

  1845.     }

  1846. 

  1847.     public String getDirectoryName() {

  1848. 	// PENDING(jeff) - get the name from the directory combobox

  1849. 	return null;

  1850.     }

  1851. 

  1852.     public void setDirectoryName(String dirname) {

  1853. 	// PENDING(jeff) - set the name in the directory combobox

  1854.     }

  1855. 

  1856.     protected DirectoryComboBoxRenderer createDirectoryComboBoxRenderer(JFileChooser fc) {

  1857. 	return new DirectoryComboBoxRenderer();

  1858.     }

  1859. 

  1860.     //

  1861.     // Renderer for DirectoryComboBox

  1862.     //

  1863.     class DirectoryComboBoxRenderer extends DefaultListCellRenderer  {

  1864. 	IndentIcon ii = new IndentIcon();

  1865. 	public Component getListCellRendererComponent(JList list, Object value,

  1866. 						      int index, boolean isSelected,

  1867. 						      boolean cellHasFocus) {

  1868. 

  1869. 	    super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

  1870. 

  1871. 	    if (value == null) {

  1872. 		setText("");

  1873. 		return this;

  1874. 	    }

  1875. 	    File directory = (File)value;

  1876. 	    setText(getFileChooser().getName(directory));

  1877. 	    Icon icon = getFileChooser().getIcon(directory);

  1878. 	    ii.icon = icon;

  1879. 	    ii.depth = directoryComboBoxModel.getDepth(index);

  1880. 	    setIcon(ii);

  1881. 

  1882. 	    return this;

  1883. 	}

  1884.     }

  1885. 

  1886.     final static int space = 10;

  1887.     class IndentIcon implements Icon {

  1888. 

  1889. 	Icon icon = null;

  1890. 	int depth = 0;

  1891. 

  1892. 	public void paintIcon(Component c, Graphics g, int x, int y) {

  1893. 	    if (c.getComponentOrientation().isLeftToRight()) {

  1894. 		icon.paintIcon(c, g, x+depth*space, y);

  1895. 	    } else {

  1896. 		icon.paintIcon(c, g, x, y);

  1897. 	    }

  1898. 	}

  1899. 

  1900. 	public int getIconWidth() {

  1901. 	    return icon.getIconWidth() + depth*space;

  1902. 	}

  1903. 

  1904. 	public int getIconHeight() {

  1905. 	    return icon.getIconHeight();

  1906. 	}

  1907. 

  1908.     }

  1909. 

  1910.     //

  1911.     // DataModel for DirectoryComboxbox

  1912.     //

  1913.     protected DirectoryComboBoxModel createDirectoryComboBoxModel(JFileChooser fc) {

  1914. 	return new DirectoryComboBoxModel();

  1915.     }

  1916. 

  1917.     /**

  1918.      * Data model for a type-face selection combo-box.

  1919.      */

  1920.     protected class DirectoryComboBoxModel extends AbstractListModel implements ComboBoxModel {

  1921. 	Vector directories = new Vector();

  1922. 	int[] depths = null;

  1923. 	File selectedDirectory = null;

  1924. 	JFileChooser chooser = getFileChooser();

  1925. 	FileSystemView fsv = chooser.getFileSystemView();

  1926. 

  1927. 	public DirectoryComboBoxModel() {

  1928. 	    // Add the current directory to the model, and make it the

  1929. 	    // selectedDirectory

  1930. 	    File dir = getFileChooser().getCurrentDirectory();

  1931. 	    if(dir != null) {

  1932. 		addItem(dir);

  1933. 	    }

  1934. 	}

  1935. 

  1936. 	/**

  1937. 	 * Adds the directory to the model and sets it to be selected,

  1938. 	 * additionally clears out the previous selected directory and

  1939. 	 * the paths leading up to it, if any.

  1940. 	 */

  1941. 	private void addItem(File directory) {

  1942. 

  1943. 	    if(directory == null) {

  1944. 		return;

  1945. 	    }

  1946. 

  1947. 	    directories.clear();

  1948. 

  1949. 	    File[] baseFolders;

  1950. 	    if (useShellFolder) {

  1951. 		baseFolders = (File[])ShellFolder.get("fileChooserComboBoxFolders");

  1952. 	    } else {

  1953. 		baseFolders = fsv.getRoots();

  1954. 	    }

  1955. 	    directories.addAll(Arrays.asList(baseFolders));

  1956. 

  1957. 	    // Get the canonical (full) path. This has the side

  1958. 	    // benefit of removing extraneous chars from the path,

  1959. 	    // for example /foo/bar/ becomes /foo/bar

  1960. 	    File canonical = null;

  1961. 	    try {

  1962. 		canonical = directory.getCanonicalFile();

  1963. 	    } catch (IOException e) {

  1964. 		// Maybe drive is not ready. Can't abort here.

  1965. 		canonical = directory;

  1966. 	    }

  1967. 

  1968. 	    // create File instances of each directory leading up to the top

  1969. 	    try {

  1970. 		File sf = useShellFolder ? ShellFolder.getShellFolder(canonical)

  1971. 					 : canonical;

  1972. 		File f = sf;

  1973. 		Vector path = new Vector(10);

  1974. 		do {

  1975. 		    path.addElement(f);

  1976. 		} while ((f = f.getParentFile()) != null);

  1977. 

  1978. 		int pathCount = path.size();

  1979. 		// Insert chain at appropriate place in vector

  1980. 		for (int i = 0; i < pathCount; i++) {

  1981. 		    f = (File)path.get(i);

  1982. 		    if (directories.contains(f)) {

  1983. 			int topIndex = directories.indexOf(f);

  1984. 			for (int j = i-1; j >= 0; j--) {

  1985. 			    directories.insertElementAt(path.get(j), topIndex+i-j);

  1986. 			}

  1987. 			break;

  1988. 		    }

  1989. 		}

  1990. 		calculateDepths();

  1991. 		setSelectedItem(sf);

  1992. 	    } catch (FileNotFoundException ex) {

  1993. 		calculateDepths();

  1994. 	    }

  1995. 	}

  1996. 

  1997. 	private void calculateDepths() {

  1998. 	    depths = new int[directories.size()];

  1999. 	    for (int i = 0; i < depths.length; i++) {

  2000. 		File dir = (File)directories.get(i);

  2001. 		File parent = dir.getParentFile();

  2002. 		depths[i] = 0;

  2003. 		if (parent != null) {

  2004. 		    for (int j = i-1; j >= 0; j--) {

  2005. 			if (parent.equals((File)directories.get(j))) {

  2006. 			    depths[i] = depths[j] + 1;

  2007. 			    break;

  2008. 			}

  2009. 		    }

  2010. 		}

  2011. 	    }

  2012. 	}

  2013. 

  2014. 	public int getDepth(int i) {

  2015. 	    return (depths != null && i >= 0 && i < depths.length) ? depths[i] : 0;

  2016. 	}

  2017. 

  2018. 	public void setSelectedItem(Object selectedDirectory) {

  2019. 	    this.selectedDirectory = (File)selectedDirectory;

  2020.             fireContentsChanged(this, -1, -1);

  2021. 	}

  2022. 

  2023. 	public Object getSelectedItem() {

  2024. 	    return selectedDirectory;

  2025. 	}

  2026. 

  2027. 	public int getSize() {

  2028. 	    return directories.size();

  2029. 	}

  2030. 

  2031. 	public Object getElementAt(int index) {

  2032. 	    return directories.elementAt(index);

  2033. 	}

  2034.     }

  2035. 

  2036.     //

  2037.     // Renderer for Types ComboBox

  2038.     //

  2039.     protected FilterComboBoxRenderer createFilterComboBoxRenderer() {

  2040. 	return new FilterComboBoxRenderer();

  2041.     }

  2042. 

  2043.     /**

  2044.      * Render different type sizes and styles.

  2045.      */

  2046.     public class FilterComboBoxRenderer extends DefaultListCellRenderer {

  2047. 	public Component getListCellRendererComponent(JList list,

  2048. 	    Object value, int index, boolean isSelected,

  2049. 	    boolean cellHasFocus) {

  2050. 

  2051. 	    super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

  2052. 

  2053. 	    if (value != null && value instanceof FileFilter) {

  2054. 		setText(((FileFilter)value).getDescription());

  2055. 	    }

  2056. 

  2057. 	    return this;

  2058. 	}

  2059.     }

  2060. 

  2061.     //

  2062.     // DataModel for Types Comboxbox

  2063.     //

  2064.     protected FilterComboBoxModel createFilterComboBoxModel() {

  2065. 	return new FilterComboBoxModel();

  2066.     }

  2067. 

  2068.     /**

  2069.      * Data model for a type-face selection combo-box.

  2070.      */

  2071.     protected class FilterComboBoxModel extends AbstractListModel implements ComboBoxModel, PropertyChangeListener {

  2072. 	protected FileFilter[] filters;

  2073. 	protected FilterComboBoxModel() {

  2074. 	    super();

  2075. 	    filters = getFileChooser().getChoosableFileFilters();

  2076. 	}

  2077. 

  2078. 	public void propertyChange(PropertyChangeEvent e) {

  2079. 	    String prop = e.getPropertyName();

  2080. 	    if(prop == JFileChooser.CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY) {

  2081. 		filters = (FileFilter[]) e.getNewValue();

  2082. 		fireContentsChanged(this, -1, -1);

  2083. 	    } else if (prop == JFileChooser.FILE_FILTER_CHANGED_PROPERTY) {

  2084. 		fireContentsChanged(this, -1, -1);

  2085. 	    }

  2086. 	}

  2087. 

  2088. 	public void setSelectedItem(Object filter) {

  2089. 	    if(filter != null) {

  2090. 		getFileChooser().setFileFilter((FileFilter) filter);

  2091. 		setFileName(null);

  2092. 		fireContentsChanged(this, -1, -1);

  2093. 	    }

  2094. 	}

  2095. 

  2096. 	public Object getSelectedItem() {

  2097. 	    // Ensure that the current filter is in the list.

  2098. 	    // NOTE: we shouldnt' have to do this, since JFileChooser adds

  2099. 	    // the filter to the choosable filters list when the filter

  2100. 	    // is set. Lets be paranoid just in case someone overrides

  2101. 	    // setFileFilter in JFileChooser.

  2102. 	    FileFilter currentFilter = getFileChooser().getFileFilter();

  2103. 	    boolean found = false;

  2104. 	    if(currentFilter != null) {

  2105. 		for(int i=0; i < filters.length; i++) {

  2106. 		    if(filters[i] == currentFilter) {

  2107. 			found = true;

  2108. 		    }

  2109. 		}

  2110. 		if(found == false) {

  2111. 		    getFileChooser().addChoosableFileFilter(currentFilter);

  2112. 		}

  2113. 	    }

  2114. 	    return getFileChooser().getFileFilter();

  2115. 	}

  2116. 

  2117. 	public int getSize() {

  2118. 	    if(filters != null) {

  2119. 		return filters.length;

  2120. 	    } else {

  2121. 		return 0;

  2122. 	    }

  2123. 	}

  2124. 

  2125. 	public Object getElementAt(int index) {

  2126. 	    if(index > getSize() - 1) {

  2127. 		// This shouldn't happen. Try to recover gracefully.

  2128. 		return getFileChooser().getFileFilter();

  2129. 	    }

  2130. 	    if(filters != null) {

  2131. 		return filters[index];

  2132. 	    } else {

  2133. 		return null;

  2134. 	    }

  2135. 	}

  2136.     }

  2137. 

  2138.     public void valueChanged(ListSelectionEvent e) {

  2139. 	JFileChooser fc = getFileChooser();

  2140. 	File f = fc.getSelectedFile();

  2141. 	if (!e.getValueIsAdjusting() && f != null && !getFileChooser().isTraversable(f)) {

  2142. 	    setFileName(fileNameString(f));

  2143. 	}

  2144.     }

  2145. 

  2146.     /**

  2147.      * Acts when DirectoryComboBox has changed the selected item.

  2148.      */

  2149.     protected class DirectoryComboBoxAction implements ActionListener {

  2150. 

  2151. 

  2152. 

  2153. 

  2154. 	public void actionPerformed(ActionEvent e) {

  2155. 	    File f = (File)directoryComboBox.getSelectedItem();

  2156. 	    getFileChooser().setCurrentDirectory(f);

  2157. 	}

  2158.     }

  2159. 

  2160.     protected JButton getApproveButton(JFileChooser fc) {

  2161. 	return approveButton;

  2162.     }

  2163. 

  2164.     public FileView getFileView(JFileChooser fc) {

  2165. 	return fileView;

  2166.     }

  2167. 

  2168.     // ***********************

  2169.     // * FileView operations *

  2170.     // ***********************

  2171.     protected class WindowsFileView extends BasicFileView {

  2172. 	/* FileView type descriptions */

  2173. 

  2174. 	public Icon getIcon(File f) {

  2175. 	    Icon icon = getCachedIcon(f);

  2176. 	    if (icon != null) {

  2177. 		return icon;

  2178. 	    }

  2179. 	    if (f != null) {

  2180. 		icon = getFileChooser().getFileSystemView().getSystemIcon(f);

  2181. 	    }

  2182. 	    if (icon == null) {

  2183. 		icon = super.getIcon(f);

  2184. 	    }

  2185. 	    cacheIcon(f, icon);

  2186. 	    return icon;

  2187. 	}

  2188.     }

  2189. }

  2190.