Back to index...

	/*
	* Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package com.sun.java.swing.plaf.gtk;

	import java.awt.*;
	import java.awt.event.*;
	import java.beans.*;
	import java.io.File;
	import java.io.IOException;
	import java.text.MessageFormat;
	import java.util.*;

	import javax.swing.*;
	import javax.swing.border.*;
	import javax.swing.filechooser.*;
	import javax.swing.event.*;
	import javax.swing.plaf.*;
	import javax.swing.plaf.basic.BasicDirectoryModel;
	import javax.swing.table.*;
	import javax.accessibility.*;

	import sun.swing.SwingUtilities2;

	import sun.swing.plaf.synth.*;
	import sun.swing.FilePane;
	import sun.awt.shell.ShellFolder;

	/**
	* GTK FileChooserUI.
	*
	* @author Leif Samuelsson
	* @author Jeff Dinkins
	*/
	class GTKFileChooserUI extends SynthFileChooserUI {

	// The accessoryPanel is a container to place the JFileChooser accessory component
	private JPanel accessoryPanel = null;

	private String newFolderButtonText = null;
	private String newFolderErrorSeparator = null;
	private String newFolderErrorText = null;
	private String newFolderDialogText = null;
	private String newFolderNoDirectoryErrorTitleText = null;
	private String newFolderNoDirectoryErrorText = null;

	private String deleteFileButtonText = null;
	private String renameFileButtonText = null;

	private String newFolderButtonToolTipText = null;
	private String deleteFileButtonToolTipText = null;
	private String renameFileButtonToolTipText = null;

	private int newFolderButtonMnemonic = 0;
	private int deleteFileButtonMnemonic = 0;
	private int renameFileButtonMnemonic = 0;
	private int foldersLabelMnemonic = 0;
	private int filesLabelMnemonic = 0;

	private String renameFileDialogText = null;
	private String renameFileErrorTitle = null;
	private String renameFileErrorText = null;

	private JComboBox filterComboBox;
	private FilterComboBoxModel filterComboBoxModel;

	// From Motif

	private JPanel rightPanel;
	private JList directoryList;
	private JList fileList;

	private JLabel pathField;
	private JTextField fileNameTextField;

	private static final Dimension hstrut3 = new Dimension(3, 1);
	private static final Dimension vstrut10 = new Dimension(1, 10);

	private static Dimension prefListSize = new Dimension(75, 150);

	private static Dimension PREF_SIZE = new Dimension(435, 360);
	private static final int MIN_WIDTH = 200;
	private static final int MIN_HEIGHT = 300;

	private static Dimension ZERO_ACC_SIZE = new Dimension(1, 1);

	private static Dimension MAX_SIZE = new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);

	private static final Insets buttonMargin = new Insets(3, 3, 3, 3);

	private String filesLabelText = null;
	private String foldersLabelText = null;
	private String pathLabelText = null;
	private String filterLabelText = null;

	private int pathLabelMnemonic = 0;
	private int filterLabelMnemonic = 0;

	private JComboBox directoryComboBox;
	private DirectoryComboBoxModel directoryComboBoxModel;
	private Action directoryComboBoxAction = new DirectoryComboBoxAction();
	private JPanel bottomButtonPanel;
	private GTKDirectoryModel model = null;
	private Action newFolderAction;
	private boolean readOnly;
	private boolean showDirectoryIcons;
	private boolean showFileIcons;
	private GTKFileView fileView = new GTKFileView();
	private PropertyChangeListener gtkFCPropertyChangeListener;
	private Action approveSelectionAction = new GTKApproveSelectionAction();
	private GTKDirectoryListModel directoryListModel;

	public GTKFileChooserUI(JFileChooser filechooser) {
	super(filechooser);
	}

	protected ActionMap createActionMap() {
	ActionMap map = new ActionMapUIResource();
	map.put("approveSelection", getApproveSelectionAction());
	map.put("cancelSelection", getCancelSelectionAction());
	map.put("Go Up", getChangeToParentDirectoryAction());
	map.put("fileNameCompletion", getFileNameCompletionAction());
	return map;
	}

	public String getFileName() {
	JFileChooser fc = getFileChooser();
	String typedInName = fileNameTextField != null ?
	fileNameTextField.getText() : null;

	if (!fc.isMultiSelectionEnabled()) {
	return typedInName;
	}

	int mode = fc.getFileSelectionMode();
	JList list = mode == JFileChooser.DIRECTORIES_ONLY ?
	directoryList : fileList;
	Object[] files = list.getSelectedValues();
	int len = files.length;
	Vector<String> result = new Vector<String>(len + 1);

	// we return all selected file names
	for (int i = 0; i < len; i++) {
	File file = (File)files[i];
	result.add(file.getName());
	}
	// plus the file name typed into the text field, if not already there
	if (typedInName != null && !result.contains(typedInName)) {
	result.add(typedInName);
	}

	StringBuffer buf = new StringBuffer();
	len = result.size();

	// construct the resulting string
	for (int i=0; i<len; i++) {
	if (i > 0) {
	buf.append(" ");
	}
	if (len > 1) {
	buf.append("\"");
	}
	buf.append(result.get(i));
	if (len > 1) {
	buf.append("\"");
	}
	}
	return buf.toString();
	}

	public void setFileName(String fileName) {
	if (fileNameTextField != null) {
	fileNameTextField.setText(fileName);
	}
	}

	// public String getDirectoryName() {
	// return pathField.getText();
	// }

	public void setDirectoryName(String dirname) {
	pathField.setText(dirname);
	}

	public void ensureFileIsVisible(JFileChooser fc, File f) {
	// PENDING
	}

	public void rescanCurrentDirectory(JFileChooser fc) {
	getModel().validateFileCache();
	}

	public JPanel getAccessoryPanel() {
	return accessoryPanel;
	}

	// ***********************
	// * FileView operations *
	// ***********************

	public FileView getFileView(JFileChooser fc) {
	return fileView;
	}

	private class GTKFileView extends BasicFileView {
	public GTKFileView() {
	iconCache = null;
	}

	public void clearIconCache() {
	}

	public Icon getCachedIcon(File f) {
	return null;
	}

	public void cacheIcon(File f, Icon i) {
	}

	public Icon getIcon(File f) {
	return (f != null && f.isDirectory()) ? directoryIcon : fileIcon;
	}
	}


	private void updateDefaultButton() {
	JFileChooser filechooser = getFileChooser();
	JRootPane root = SwingUtilities.getRootPane(filechooser);
	if (root == null) {
	return;
	}

	if (filechooser.getControlButtonsAreShown()) {
	if (root.getDefaultButton() == null) {
	root.setDefaultButton(getApproveButton(filechooser));
	getCancelButton(filechooser).setDefaultCapable(false);
	}
	} else {
	if (root.getDefaultButton() == getApproveButton(filechooser)) {
	root.setDefaultButton(null);
	}
	}
	}

	protected void doSelectedFileChanged(PropertyChangeEvent e) {
	super.doSelectedFileChanged(e);
	File f = (File) e.getNewValue();
	if (f != null) {
	setFileName(getFileChooser().getName(f));
	}
	}

	protected void doDirectoryChanged(PropertyChangeEvent e) {
	directoryList.clearSelection();
	ListSelectionModel sm = directoryList.getSelectionModel();
	if (sm instanceof DefaultListSelectionModel) {
	((DefaultListSelectionModel)sm).moveLeadSelectionIndex(0);
	sm.setAnchorSelectionIndex(0);
	}
	fileList.clearSelection();
	sm = fileList.getSelectionModel();
	if (sm instanceof DefaultListSelectionModel) {
	((DefaultListSelectionModel)sm).moveLeadSelectionIndex(0);
	sm.setAnchorSelectionIndex(0);
	}

	File currentDirectory = getFileChooser().getCurrentDirectory();
	if (currentDirectory != null) {
	try {
	setDirectoryName(ShellFolder.getNormalizedFile((File)e.getNewValue()).getPath());
	} catch (IOException ioe) {
	setDirectoryName(((File)e.getNewValue()).getAbsolutePath());
	}
	if ((getFileChooser().getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY) && !getFileChooser().isMultiSelectionEnabled()) {
	setFileName(pathField.getText());
	}
	directoryComboBoxModel.addItem(currentDirectory);
	directoryListModel.directoryChanged();
	}
	super.doDirectoryChanged(e);
	}

	protected void doAccessoryChanged(PropertyChangeEvent e) {
	if (getAccessoryPanel() != null) {
	if (e.getOldValue() != null) {
	getAccessoryPanel().remove((JComponent)e.getOldValue());
	}
	JComponent accessory = (JComponent)e.getNewValue();
	if (accessory != null) {
	getAccessoryPanel().add(accessory, BorderLayout.CENTER);
	getAccessoryPanel().setPreferredSize(accessory.getPreferredSize());
	getAccessoryPanel().setMaximumSize(MAX_SIZE);
	} else {
	getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);
	getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);
	}
	}
	}

	protected void doFileSelectionModeChanged(PropertyChangeEvent e) {
	directoryList.clearSelection();
	rightPanel.setVisible(((Integer)e.getNewValue()).intValue() != JFileChooser.DIRECTORIES_ONLY);

	super.doFileSelectionModeChanged(e);
	}

	protected void doMultiSelectionChanged(PropertyChangeEvent e) {
	if (getFileChooser().isMultiSelectionEnabled()) {
	fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
	} else {
	fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
	fileList.clearSelection();
	}

	super.doMultiSelectionChanged(e);
	}

	protected void doControlButtonsChanged(PropertyChangeEvent e) {
	super.doControlButtonsChanged(e);

	JFileChooser filechooser = getFileChooser();
	if (filechooser.getControlButtonsAreShown()) {
	filechooser.add(bottomButtonPanel, BorderLayout.SOUTH);
	} else {
	filechooser.remove(bottomButtonPanel);
	}
	updateDefaultButton();
	}

	protected void doAncestorChanged(PropertyChangeEvent e) {
	if (e.getOldValue() == null && e.getNewValue() != null) {
	// Ancestor was added, set initial focus
	fileNameTextField.selectAll();
	fileNameTextField.requestFocus();
	updateDefaultButton();
	}

	super.doAncestorChanged(e);
	}



	// ********************************************
	// ********** Create Listeners ************
	// ********************************************

	public ListSelectionListener createListSelectionListener(JFileChooser fc) {
	return new SelectionListener();
	}

	class DoubleClickListener extends MouseAdapter {
	JList list;
	public DoubleClickListener(JList list) {
	this.list = list;
	}

	public void mouseClicked(MouseEvent e) {
	if (SwingUtilities.isLeftMouseButton(e) && e.getClickCount() == 2) {
	int index = list.locationToIndex(e.getPoint());
	if (index >= 0) {
	File f = (File) list.getModel().getElementAt(index);
	try {
	// Strip trailing ".."
	f = ShellFolder.getNormalizedFile(f);
	} catch (IOException ex) {
	// That's ok, we'll use f as is
	}
	if (getFileChooser().isTraversable(f)) {
	list.clearSelection();
	if (getFileChooser().getCurrentDirectory().equals(f)){
	rescanCurrentDirectory(getFileChooser());
	} else {
	getFileChooser().setCurrentDirectory(f);
	}
	} else {
	getFileChooser().approveSelection();
	}
	}
	}
	}

	public void mouseEntered(MouseEvent evt) {
	if (list != null) {
	TransferHandler th1 = getFileChooser().getTransferHandler();
	TransferHandler th2 = list.getTransferHandler();
	if (th1 != th2) {
	list.setTransferHandler(th1);
	}
	if (getFileChooser().getDragEnabled() != list.getDragEnabled()) {
	list.setDragEnabled(getFileChooser().getDragEnabled());
	}
	}
	}
	}

	protected MouseListener createDoubleClickListener(JFileChooser fc, JList list) {
	return new DoubleClickListener(list);
	}



	protected class SelectionListener implements ListSelectionListener {
	public void valueChanged(ListSelectionEvent e) {
	if (!e.getValueIsAdjusting()) {
	JFileChooser chooser = getFileChooser();
	JList list = (JList) e.getSource();

	if (chooser.isMultiSelectionEnabled()) {
	File[] files = null;
	Object[] objects = list.getSelectedValues();
	if (objects != null) {
	if (objects.length == 1
	&& ((File)objects[0]).isDirectory()
	&& chooser.isTraversable(((File)objects[0]))
	&& (chooser.getFileSelectionMode() != chooser.DIRECTORIES_ONLY
	\|\| !chooser.getFileSystemView().isFileSystem(((File)objects[0])))) {
	setDirectorySelected(true);
	setDirectory(((File)objects[0]));
	} else {
	ArrayList<File> fList = new ArrayList<File>(objects.length);
	for (Object object : objects) {
	File f = (File) object;
	if ((chooser.isFileSelectionEnabled() && f.isFile())
	\|\| (chooser.isDirectorySelectionEnabled() && f.isDirectory())) {
	fList.add(f);
	}
	}
	if (fList.size() > 0) {
	files = fList.toArray(new File[fList.size()]);
	}
	setDirectorySelected(false);
	}
	}
	chooser.setSelectedFiles(files);
	} else {
	File file = (File)list.getSelectedValue();
	if (file != null
	&& file.isDirectory()
	&& chooser.isTraversable(file)
	&& (chooser.getFileSelectionMode() == chooser.FILES_ONLY
	\|\| !chooser.getFileSystemView().isFileSystem(file))) {

	setDirectorySelected(true);
	setDirectory(file);
	} else {
	setDirectorySelected(false);
	if (file != null) {
	chooser.setSelectedFile(file);
	}
	}
	}
	}
	}
	}


	//
	// ComponentUI Interface Implementation methods
	//
	public static ComponentUI createUI(JComponent c) {
	return new GTKFileChooserUI((JFileChooser)c);
	}

	public void installUI(JComponent c) {
	accessoryPanel = new JPanel(new BorderLayout(10, 10));
	accessoryPanel.setName("GTKFileChooser.accessoryPanel");

	super.installUI(c);
	}

	public void uninstallUI(JComponent c) {
	c.removePropertyChangeListener(filterComboBoxModel);
	super.uninstallUI(c);

	if (accessoryPanel != null) {
	accessoryPanel.removeAll();
	}
	accessoryPanel = null;
	getFileChooser().removeAll();
	}

	public void installComponents(JFileChooser fc) {
	super.installComponents(fc);

	boolean leftToRight = fc.getComponentOrientation().isLeftToRight();

	fc.setLayout(new BorderLayout());
	fc.setAlignmentX(JComponent.CENTER_ALIGNMENT);

	// Top row of buttons
	JPanel topButtonPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 0, 0));
	topButtonPanel.setBorder(new EmptyBorder(10, 10, 0, 10));
	topButtonPanel.setName("GTKFileChooser.topButtonPanel");

	if (!UIManager.getBoolean("FileChooser.readOnly")) {
	JButton newFolderButton = new JButton(getNewFolderAction());
	newFolderButton.setName("GTKFileChooser.newFolderButton");
	newFolderButton.setMnemonic(newFolderButtonMnemonic);
	newFolderButton.setToolTipText(newFolderButtonToolTipText);
	newFolderButton.setText(newFolderButtonText);
	topButtonPanel.add(newFolderButton);
	}
	JButton deleteFileButton = new JButton(deleteFileButtonText);
	deleteFileButton.setName("GTKFileChooser.deleteFileButton");
	deleteFileButton.setMnemonic(deleteFileButtonMnemonic);
	deleteFileButton.setToolTipText(deleteFileButtonToolTipText);
	deleteFileButton.setEnabled(false);
	topButtonPanel.add(deleteFileButton);

	RenameFileAction rfa = new RenameFileAction();
	JButton renameFileButton = new JButton(rfa);
	if (readOnly) {
	rfa.setEnabled(false);
	}
	renameFileButton.setText(renameFileButtonText);
	renameFileButton.setName("GTKFileChooser.renameFileButton");
	renameFileButton.setMnemonic(renameFileButtonMnemonic);
	renameFileButton.setToolTipText(renameFileButtonToolTipText);
	topButtonPanel.add(renameFileButton);

	fc.add(topButtonPanel, BorderLayout.NORTH);


	JPanel interior = new JPanel();
	interior.setBorder(new EmptyBorder(0, 10, 10, 10));
	interior.setName("GTKFileChooser.interiorPanel");
	align(interior);
	interior.setLayout(new BoxLayout(interior, BoxLayout.PAGE_AXIS));

	fc.add(interior, BorderLayout.CENTER);

	JPanel comboBoxPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,
	0, 0) {
	public void layoutContainer(Container target) {
	super.layoutContainer(target);
	JComboBox comboBox = directoryComboBox;
	if (comboBox.getWidth() > target.getWidth()) {
	comboBox.setBounds(0, comboBox.getY(), target.getWidth(),
	comboBox.getHeight());
	}
	}
	});
	comboBoxPanel.setBorder(new EmptyBorder(0, 0, 4, 0));
	comboBoxPanel.setName("GTKFileChooser.directoryComboBoxPanel");
	// CurrentDir ComboBox
	directoryComboBoxModel = createDirectoryComboBoxModel(fc);
	directoryComboBox = new JComboBox(directoryComboBoxModel);
	directoryComboBox.setName("GTKFileChooser.directoryComboBox");
	directoryComboBox.putClientProperty( "JComboBox.lightweightKeyboardNavigation", "Lightweight" );
	directoryComboBox.addActionListener(directoryComboBoxAction);
	directoryComboBox.setMaximumRowCount(8);
	comboBoxPanel.add(directoryComboBox);
	interior.add(comboBoxPanel);


	// CENTER: left, right, accessory
	JPanel centerPanel = new JPanel(new BorderLayout());
	centerPanel.setName("GTKFileChooser.centerPanel");

	// SPLIT PANEL: left, right
	JSplitPane splitPanel = new JSplitPane();
	splitPanel.setName("GTKFileChooser.splitPanel");
	splitPanel.setDividerLocation((PREF_SIZE.width-8)/2);

	// left panel - Filter & directoryList
	JPanel leftPanel = new JPanel(new GridBagLayout());
	leftPanel.setName("GTKFileChooser.directoryListPanel");

	// Add the Directory List
	// Create a label that looks like button (should be a table header)
	TableCellRenderer headerRenderer = new JTableHeader().getDefaultRenderer();
	JLabel directoryListLabel =
	(JLabel)headerRenderer.getTableCellRendererComponent(null, foldersLabelText,
	false, false, 0, 0);
	directoryListLabel.setName("GTKFileChooser.directoryListLabel");
	leftPanel.add(directoryListLabel, new GridBagConstraints(
	0, 0, 1, 1, 1, 0, GridBagConstraints.WEST,
	GridBagConstraints.HORIZONTAL,
	new Insets(0, 0, 0, 0), 0, 0));
	leftPanel.add(createDirectoryList(), new GridBagConstraints(
	0, 1, 1, 1, 1, 1, GridBagConstraints.EAST,
	GridBagConstraints.BOTH,
	new Insets(0, 0, 0, 0), 0, 0));
	directoryListLabel.setDisplayedMnemonic(foldersLabelMnemonic);
	directoryListLabel.setLabelFor(directoryList);

	// create files list
	rightPanel = new JPanel(new GridBagLayout());
	rightPanel.setName("GTKFileChooser.fileListPanel");

	headerRenderer = new JTableHeader().getDefaultRenderer();
	JLabel fileListLabel =
	(JLabel)headerRenderer.getTableCellRendererComponent(null, filesLabelText,
	false, false, 0, 0);
	fileListLabel.setName("GTKFileChooser.fileListLabel");
	rightPanel.add(fileListLabel, new GridBagConstraints(
	0, 0, 1, 1, 1, 0, GridBagConstraints.WEST,
	GridBagConstraints.HORIZONTAL,
	new Insets(0, 0, 0, 0), 0, 0));
	rightPanel.add(createFilesList(), new GridBagConstraints(
	0, 1, 1, 1, 1, 1, GridBagConstraints.EAST,
	GridBagConstraints.BOTH,
	new Insets(0, 0, 0, 0), 0, 0));
	fileListLabel.setDisplayedMnemonic(filesLabelMnemonic);
	fileListLabel.setLabelFor(fileList);

	splitPanel.add(leftPanel, leftToRight ? JSplitPane.LEFT : JSplitPane.RIGHT);
	splitPanel.add(rightPanel, leftToRight ? JSplitPane.RIGHT : JSplitPane.LEFT);
	centerPanel.add(splitPanel, BorderLayout.CENTER);

	JComponent accessoryPanel = getAccessoryPanel();
	JComponent accessory = fc.getAccessory();
	if (accessoryPanel != null) {
	if (accessory == null) {
	accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);
	accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);
	} else {
	getAccessoryPanel().add(accessory, BorderLayout.CENTER);
	accessoryPanel.setPreferredSize(accessory.getPreferredSize());
	accessoryPanel.setMaximumSize(MAX_SIZE);
	}
	align(accessoryPanel);
	centerPanel.add(accessoryPanel, BorderLayout.AFTER_LINE_ENDS);
	}
	interior.add(centerPanel);
	interior.add(Box.createRigidArea(vstrut10));

	JPanel pathFieldPanel = new JPanel(new FlowLayout(FlowLayout.LEADING,
	0, 0));
	pathFieldPanel.setBorder(new EmptyBorder(0, 0, 4, 0));
	JLabel pathFieldLabel = new JLabel(pathLabelText);
	pathFieldLabel.setName("GTKFileChooser.pathFieldLabel");
	pathFieldLabel.setDisplayedMnemonic(pathLabelMnemonic);
	align(pathFieldLabel);
	pathFieldPanel.add(pathFieldLabel);
	pathFieldPanel.add(Box.createRigidArea(hstrut3));

	File currentDirectory = fc.getCurrentDirectory();
	String curDirName = null;
	if (currentDirectory != null) {
	curDirName = currentDirectory.getPath();
	}
	pathField = new JLabel(curDirName) {
	public Dimension getMaximumSize() {
	Dimension d = super.getMaximumSize();
	d.height = getPreferredSize().height;
	return d;
	}
	};
	pathField.setName("GTKFileChooser.pathField");
	align(pathField);
	pathFieldPanel.add(pathField);
	interior.add(pathFieldPanel);

	// add the fileName field
	fileNameTextField = new JTextField() {
	public Dimension getMaximumSize() {
	Dimension d = super.getMaximumSize();
	d.height = getPreferredSize().height;
	return d;
	}
	};

	pathFieldLabel.setLabelFor(fileNameTextField);

	Set<AWTKeyStroke> forwardTraversalKeys = fileNameTextField.getFocusTraversalKeys(
	KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
	forwardTraversalKeys = new HashSet<AWTKeyStroke>(forwardTraversalKeys);
	forwardTraversalKeys.remove(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
	fileNameTextField.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, forwardTraversalKeys);

	fileNameTextField.setName("GTKFileChooser.fileNameTextField");
	fileNameTextField.getActionMap().put("fileNameCompletionAction", getFileNameCompletionAction());
	fileNameTextField.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0), "fileNameCompletionAction");
	interior.add(fileNameTextField);

	// Add the filter combo box
	JPanel panel = new JPanel();
	panel.setLayout(new FlowLayout(FlowLayout.LEADING, 0, 0));
	panel.setBorder(new EmptyBorder(0, 0, 4, 0));
	JLabel filterLabel = new JLabel(filterLabelText);
	filterLabel.setName("GTKFileChooser.filterLabel");
	filterLabel.setDisplayedMnemonic(filterLabelMnemonic);
	panel.add(filterLabel);

	filterComboBoxModel = createFilterComboBoxModel();
	fc.addPropertyChangeListener(filterComboBoxModel);
	filterComboBox = new JComboBox(filterComboBoxModel);
	filterComboBox.setRenderer(createFilterComboBoxRenderer());
	filterLabel.setLabelFor(filterComboBox);

	interior.add(Box.createRigidArea(vstrut10));
	interior.add(panel);
	interior.add(filterComboBox);

	// Add buttons
	bottomButtonPanel = new JPanel(new FlowLayout(FlowLayout.TRAILING));
	bottomButtonPanel.setName("GTKFileChooser.bottomButtonPanel");
	align(bottomButtonPanel);

	JPanel pnButtons = new JPanel(new GridLayout(1, 2, 5, 0));

	JButton cancelButton = getCancelButton(fc);
	align(cancelButton);
	cancelButton.setMargin(buttonMargin);
	pnButtons.add(cancelButton);

	JButton approveButton = getApproveButton(fc);
	align(approveButton);
	approveButton.setMargin(buttonMargin);
	pnButtons.add(approveButton);

	bottomButtonPanel.add(pnButtons);

	if (fc.getControlButtonsAreShown()) {
	fc.add(bottomButtonPanel, BorderLayout.SOUTH);
	}
	}

	protected void installListeners(JFileChooser fc) {
	super.installListeners(fc);

	gtkFCPropertyChangeListener = new GTKFCPropertyChangeListener();
	fc.addPropertyChangeListener(gtkFCPropertyChangeListener);
	}

	private int getMnemonic(String key, Locale l) {
	return SwingUtilities2.getUIDefaultsInt(key, l);
	}

	protected void uninstallListeners(JFileChooser fc) {
	super.uninstallListeners(fc);

	if (gtkFCPropertyChangeListener != null) {
	fc.removePropertyChangeListener(gtkFCPropertyChangeListener);
	}
	}

	private class GTKFCPropertyChangeListener implements PropertyChangeListener {
	public void propertyChange(PropertyChangeEvent e) {
	String prop = e.getPropertyName();
	if (prop.equals("GTKFileChooser.showDirectoryIcons")) {
	showDirectoryIcons = Boolean.TRUE.equals(e.getNewValue());
	} else if (prop.equals("GTKFileChooser.showFileIcons")) {
	showFileIcons = Boolean.TRUE.equals(e.getNewValue());
	}
	}
	}

	protected void installDefaults(JFileChooser fc) {
	super.installDefaults(fc);
	readOnly = UIManager.getBoolean("FileChooser.readOnly");
	showDirectoryIcons =
	Boolean.TRUE.equals(fc.getClientProperty("GTKFileChooser.showDirectoryIcons"));
	showFileIcons =
	Boolean.TRUE.equals(fc.getClientProperty("GTKFileChooser.showFileIcons"));
	}

	protected void installIcons(JFileChooser fc) {
	directoryIcon = UIManager.getIcon("FileView.directoryIcon");
	fileIcon = UIManager.getIcon("FileView.fileIcon");
	}

	protected void installStrings(JFileChooser fc) {
	super.installStrings(fc);

	Locale l = fc.getLocale();

	newFolderDialogText = UIManager.getString("FileChooser.newFolderDialogText", l);
	newFolderErrorText = UIManager.getString("FileChooser.newFolderErrorText",l);
	newFolderErrorSeparator = UIManager.getString("FileChooser.newFolderErrorSeparator",l);
	newFolderButtonText = UIManager.getString("FileChooser.newFolderButtonText", l);
	newFolderNoDirectoryErrorTitleText = UIManager.getString("FileChooser.newFolderNoDirectoryErrorTitleText", l);
	newFolderNoDirectoryErrorText = UIManager.getString("FileChooser.newFolderNoDirectoryErrorText", l);
	deleteFileButtonText = UIManager.getString("FileChooser.deleteFileButtonText", l);
	renameFileButtonText = UIManager.getString("FileChooser.renameFileButtonText", l);

	newFolderButtonMnemonic = getMnemonic("FileChooser.newFolderButtonMnemonic", l);
	deleteFileButtonMnemonic = getMnemonic("FileChooser.deleteFileButtonMnemonic", l);
	renameFileButtonMnemonic = getMnemonic("FileChooser.renameFileButtonMnemonic", l);

	newFolderButtonToolTipText = UIManager.getString("FileChooser.newFolderButtonToolTipText", l);
	deleteFileButtonToolTipText = UIManager.getString("FileChooser.deleteFileButtonToolTipText", l);
	renameFileButtonToolTipText = UIManager.getString("FileChooser.renameFileButtonToolTipText", l);

	renameFileDialogText = UIManager.getString("FileChooser.renameFileDialogText", l);
	renameFileErrorTitle = UIManager.getString("FileChooser.renameFileErrorTitle", l);
	renameFileErrorText = UIManager.getString("FileChooser.renameFileErrorText", l);

	foldersLabelText = UIManager.getString("FileChooser.foldersLabelText",l);
	foldersLabelMnemonic = getMnemonic("FileChooser.foldersLabelMnemonic", l);

	filesLabelText = UIManager.getString("FileChooser.filesLabelText",l);
	filesLabelMnemonic = getMnemonic("FileChooser.filesLabelMnemonic", l);

	pathLabelText = UIManager.getString("FileChooser.pathLabelText",l);
	pathLabelMnemonic = getMnemonic("FileChooser.pathLabelMnemonic", l);

	filterLabelText = UIManager.getString("FileChooser.filterLabelText", l);
	filterLabelMnemonic = UIManager.getInt("FileChooser.filterLabelMnemonic");
	}

	protected void uninstallStrings(JFileChooser fc) {
	super.uninstallStrings(fc);

	newFolderButtonText = null;
	deleteFileButtonText = null;
	renameFileButtonText = null;

	newFolderButtonToolTipText = null;
	deleteFileButtonToolTipText = null;
	renameFileButtonToolTipText = null;

	renameFileDialogText = null;
	renameFileErrorTitle = null;
	renameFileErrorText = null;

	foldersLabelText = null;
	filesLabelText = null;

	pathLabelText = null;

	newFolderDialogText = null;
	newFolderErrorText = null;
	newFolderErrorSeparator = null;
	}

	protected JScrollPane createFilesList() {
	fileList = new JList();
	fileList.setName("GTKFileChooser.fileList");
	fileList.putClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY, filesLabelText);

	if (getFileChooser().isMultiSelectionEnabled()) {
	fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
	} else {
	fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
	}

	fileList.setModel(new GTKFileListModel());
	fileList.getSelectionModel().removeSelectionInterval(0, 0);
	fileList.setCellRenderer(new FileCellRenderer());
	fileList.addListSelectionListener(createListSelectionListener(getFileChooser()));
	fileList.addMouseListener(createDoubleClickListener(getFileChooser(), fileList));
	align(fileList);
	JScrollPane scrollpane = new JScrollPane(fileList);
	scrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
	scrollpane.setName("GTKFileChooser.fileListScrollPane");
	scrollpane.setPreferredSize(prefListSize);
	scrollpane.setMaximumSize(MAX_SIZE);
	align(scrollpane);
	return scrollpane;
	}

	protected JScrollPane createDirectoryList() {
	directoryList = new JList();
	directoryList.setName("GTKFileChooser.directoryList");
	directoryList.putClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY, foldersLabelText);
	align(directoryList);

	directoryList.setCellRenderer(new DirectoryCellRenderer());
	directoryListModel = new GTKDirectoryListModel();
	directoryList.getSelectionModel().removeSelectionInterval(0, 0);
	directoryList.setModel(directoryListModel);
	directoryList.addMouseListener(createDoubleClickListener(getFileChooser(), directoryList));
	directoryList.addListSelectionListener(createListSelectionListener(getFileChooser()));

	JScrollPane scrollpane = new JScrollPane(directoryList);
	scrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
	scrollpane.setName("GTKFileChooser.directoryListScrollPane");
	scrollpane.setMaximumSize(MAX_SIZE);
	scrollpane.setPreferredSize(prefListSize);
	align(scrollpane);
	return scrollpane;
	}

	protected void createModel() {
	model = new GTKDirectoryModel();
	}

	public BasicDirectoryModel getModel() {
	return model;
	}

	public Action getApproveSelectionAction() {
	return approveSelectionAction;
	}

	private class GTKDirectoryModel extends BasicDirectoryModel {
	FileSystemView fsv;
	private Comparator<File> fileComparator = new Comparator<File>() {
	public int compare(File o, File o1) {
	return fsv.getSystemDisplayName(o).compareTo(fsv.getSystemDisplayName(o1));
	}
	};

	public GTKDirectoryModel() {
	super(getFileChooser());
	}

	protected void sort(Vector<? extends File> v) {
	fsv = getFileChooser().getFileSystemView();
	Collections.sort(v, fileComparator);
	}
	}

	protected class GTKDirectoryListModel extends AbstractListModel implements ListDataListener {
	File curDir;
	public GTKDirectoryListModel() {
	getModel().addListDataListener(this);
	directoryChanged();
	}

	public int getSize() {
	return getModel().getDirectories().size() + 1;
	}

	public Object getElementAt(int index) {
	return index > 0 ? getModel().getDirectories().elementAt(index - 1):
	curDir;
	}

	public void intervalAdded(ListDataEvent e) {
	fireIntervalAdded(this, e.getIndex0(), e.getIndex1());
	}

	public void intervalRemoved(ListDataEvent e) {
	fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());
	}

	// PENDING - this is inefficient - should sent out
	// incremental adjustment values instead of saying that the
	// whole list has changed.
	public void fireContentsChanged() {
	fireContentsChanged(this, 0, getModel().getDirectories().size()-1);
	}

	// PENDING - fire the correct interval changed - currently sending
	// out that everything has changed
	public void contentsChanged(ListDataEvent e) {
	fireContentsChanged();
	}

	private void directoryChanged() {
	curDir = getFileChooser().getFileSystemView().createFileObject(
	getFileChooser().getCurrentDirectory(), ".");
	}
	}

	protected class GTKFileListModel extends AbstractListModel implements ListDataListener {
	public GTKFileListModel() {
	getModel().addListDataListener(this);
	}

	public int getSize() {
	return getModel().getFiles().size();
	}

	public boolean contains(Object o) {
	return getModel().getFiles().contains(o);
	}

	public int indexOf(Object o) {
	return getModel().getFiles().indexOf(o);
	}

	public Object getElementAt(int index) {
	return getModel().getFiles().elementAt(index);
	}

	public void intervalAdded(ListDataEvent e) {
	fireIntervalAdded(this, e.getIndex0(), e.getIndex1());
	}

	public void intervalRemoved(ListDataEvent e) {
	fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());
	}

	// PENDING - this is inefficient - should sent out
	// incremental adjustment values instead of saying that the
	// whole list has changed.
	public void fireContentsChanged() {
	fireContentsChanged(this, 0, getModel().getFiles().size()-1);
	}

	// PENDING - fire the interval changed
	public void contentsChanged(ListDataEvent e) {
	fireContentsChanged();
	}
	}


	protected class FileCellRenderer extends DefaultListCellRenderer {
	public Component getListCellRendererComponent(JList list, Object value, int index,
	boolean isSelected, boolean cellHasFocus) {

	super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
	setText(getFileChooser().getName((File) value));
	if (showFileIcons) {
	setIcon(getFileChooser().getIcon((File)value));
	}
	return this;
	}
	}

	protected class DirectoryCellRenderer extends DefaultListCellRenderer {
	public Component getListCellRendererComponent(JList list, Object value, int index,
	boolean isSelected, boolean cellHasFocus) {

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

	if (showDirectoryIcons) {
	setIcon(getFileChooser().getIcon((File)value));
	setText(getFileChooser().getName((File)value));
	} else {
	setText(getFileChooser().getName((File)value) + "/");
	}
	return this;
	}
	}

	@Override
	public Dimension getPreferredSize(JComponent c) {
	Dimension prefSize = new Dimension(PREF_SIZE);
	JComponent accessory = getFileChooser().getAccessory();
	if (accessory != null) {
	prefSize.width += accessory.getPreferredSize().width + 20;
	}
	Dimension d = c.getLayout().preferredLayoutSize(c);
	if (d != null) {
	return new Dimension(d.width < prefSize.width ? prefSize.width : d.width,
	d.height < prefSize.height ? prefSize.height : d.height);
	} else {
	return prefSize;
	}
	}

	@Override
	public Dimension getMinimumSize(JComponent x) {
	return new Dimension(MIN_WIDTH, MIN_HEIGHT);
	}

	@Override
	public Dimension getMaximumSize(JComponent x) {
	return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
	}

	protected void align(JComponent c) {
	c.setAlignmentX(JComponent.LEFT_ALIGNMENT);
	c.setAlignmentY(JComponent.TOP_ALIGNMENT);
	}

	public Action getNewFolderAction() {
	if (newFolderAction == null) {
	newFolderAction = new NewFolderAction();
	newFolderAction.setEnabled(!readOnly);
	}
	return newFolderAction;
	}

	//
	// DataModel for DirectoryComboxbox
	//
	protected DirectoryComboBoxModel createDirectoryComboBoxModel(JFileChooser fc) {
	return new DirectoryComboBoxModel();
	}

	/**
	* Data model for a type-face selection combo-box.
	*/
	protected class DirectoryComboBoxModel extends AbstractListModel implements ComboBoxModel {
	Vector<File> directories = new Vector<File>();
	File selectedDirectory = null;
	JFileChooser chooser = getFileChooser();
	FileSystemView fsv = chooser.getFileSystemView();

	public DirectoryComboBoxModel() {
	// Add the current directory to the model, and make it the
	// selectedDirectory
	File dir = getFileChooser().getCurrentDirectory();
	if (dir != null) {
	addItem(dir);
	}
	}

	/**
	* Adds the directory to the model and sets it to be selected,
	* additionally clears out the previous selected directory and
	* the paths leading up to it, if any.
	*/
	private void addItem(File directory) {

	if (directory == null) {
	return;
	}

	int oldSize = directories.size();
	directories.clear();
	if (oldSize > 0) {
	fireIntervalRemoved(this, 0, oldSize);
	}

	// Get the canonical (full) path. This has the side
	// benefit of removing extraneous chars from the path,
	// for example /foo/bar/ becomes /foo/bar
	File canonical;
	try {
	canonical = fsv.createFileObject(ShellFolder.getNormalizedFile(directory).getPath());
	} catch (IOException e) {
	// Maybe drive is not ready. Can't abort here.
	canonical = directory;
	}

	// create File instances of each directory leading up to the top
	File f = canonical;
	do {
	directories.add(f);
	} while ((f = f.getParentFile()) != null);
	int newSize = directories.size();
	if (newSize > 0) {
	fireIntervalAdded(this, 0, newSize);
	}
	setSelectedItem(canonical);
	}

	public void setSelectedItem(Object selectedDirectory) {
	this.selectedDirectory = (File)selectedDirectory;
	fireContentsChanged(this, -1, -1);
	}

	public Object getSelectedItem() {
	return selectedDirectory;
	}

	public int getSize() {
	return directories.size();
	}

	public Object getElementAt(int index) {
	return directories.elementAt(index);
	}
	}

	/**
	* Acts when DirectoryComboBox has changed the selected item.
	*/
	protected class DirectoryComboBoxAction extends AbstractAction {
	protected DirectoryComboBoxAction() {
	super("DirectoryComboBoxAction");
	}

	public void actionPerformed(ActionEvent e) {
	File f = (File)directoryComboBox.getSelectedItem();
	getFileChooser().setCurrentDirectory(f);
	}
	}

	/**
	* Creates a new folder.
	*/
	private class NewFolderAction extends AbstractAction {
	protected NewFolderAction() {
	super(FilePane.ACTION_NEW_FOLDER);
	}
	public void actionPerformed(ActionEvent e) {
	if (readOnly) {
	return;
	}
	JFileChooser fc = getFileChooser();
	File currentDirectory = fc.getCurrentDirectory();
	String dirName = JOptionPane.showInputDialog(fc,
	newFolderDialogText, newFolderButtonText,
	JOptionPane.PLAIN_MESSAGE);

	if (dirName != null) {
	if (!currentDirectory.exists()) {
	JOptionPane.showMessageDialog(fc,
	MessageFormat.format(newFolderNoDirectoryErrorText, dirName),
	newFolderNoDirectoryErrorTitleText, JOptionPane.ERROR_MESSAGE);
	return;
	}

	File newDir = fc.getFileSystemView().createFileObject
	(currentDirectory, dirName);
	if (newDir == null \|\| !newDir.mkdir()) {
	JOptionPane.showMessageDialog(fc,
	newFolderErrorText + newFolderErrorSeparator + " \"" +
	dirName + "\"",
	newFolderErrorText, JOptionPane.ERROR_MESSAGE);
	}
	fc.rescanCurrentDirectory();
	}
	}
	}

	private class GTKApproveSelectionAction extends ApproveSelectionAction {
	public void actionPerformed(ActionEvent e) {
	if (isDirectorySelected()) {
	File dir = getDirectory();
	try {
	// Strip trailing ".."
	if (dir != null) {
	dir = ShellFolder.getNormalizedFile(dir);
	}
	} catch (IOException ex) {
	// Ok, use f as is
	}
	if (getFileChooser().getCurrentDirectory().equals(dir)) {
	directoryList.clearSelection();
	fileList.clearSelection();
	ListSelectionModel sm = fileList.getSelectionModel();
	if (sm instanceof DefaultListSelectionModel) {
	((DefaultListSelectionModel)sm).moveLeadSelectionIndex(0);
	sm.setAnchorSelectionIndex(0);
	}
	rescanCurrentDirectory(getFileChooser());
	return;
	}
	}
	super.actionPerformed(e);
	}
	}

	/**
	* Renames file
	*/
	private class RenameFileAction extends AbstractAction {
	protected RenameFileAction() {
	super(FilePane.ACTION_EDIT_FILE_NAME);
	}
	public void actionPerformed(ActionEvent e) {
	if (getFileName().equals("")) {
	return;
	}
	JFileChooser fc = getFileChooser();
	File currentDirectory = fc.getCurrentDirectory();
	String newFileName = (String) JOptionPane.showInputDialog
	(fc, new MessageFormat(renameFileDialogText).format
	(new Object[] { getFileName() }),
	renameFileButtonText, JOptionPane.PLAIN_MESSAGE, null, null,
	getFileName());

	if (newFileName != null) {
	File oldFile = fc.getFileSystemView().createFileObject
	(currentDirectory, getFileName());
	File newFile = fc.getFileSystemView().createFileObject
	(currentDirectory, newFileName);
	if (oldFile == null \|\| newFile == null \|\|
	!getModel().renameFile(oldFile, newFile)) {
	JOptionPane.showMessageDialog(fc,
	new MessageFormat(renameFileErrorText).
	format(new Object[] { getFileName(), newFileName}),
	renameFileErrorTitle, JOptionPane.ERROR_MESSAGE);
	} else {
	setFileName(getFileChooser().getName(newFile));
	fc.rescanCurrentDirectory();
	}
	}
	}
	}

	//
	// Renderer for Filter ComboBox
	//
	protected FilterComboBoxRenderer createFilterComboBoxRenderer() {
	return new FilterComboBoxRenderer();
	}

	/**
	* Render different filters
	*/
	public class FilterComboBoxRenderer extends DefaultListCellRenderer {
	public String getName() {
	// As SynthComboBoxRenderer's are asked for a size BEFORE they
	// are parented getName is overriden to force the name to be
	// ComboBox.renderer if it isn't set. If we didn't do this the
	// wrong style could be used for size calculations.
	String name = super.getName();
	if (name == null) {
	return "ComboBox.renderer";
	}
	return name;
	}

	public Component getListCellRendererComponent(JList list, Object value,
	int index, boolean isSelected,
	boolean cellHasFocus) {

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

	setName("ComboBox.listRenderer");

	if (value != null) {
	if (value instanceof FileFilter) {
	setText(((FileFilter) value).getDescription());
	}
	} else {
	setText("");
	}

	return this;
	}
	}

	//
	// DataModel for Filter Combobox
	//
	protected FilterComboBoxModel createFilterComboBoxModel() {
	return new FilterComboBoxModel();
	}

	/**
	* Data model for filter combo-box.
	*/
	protected class FilterComboBoxModel extends AbstractListModel
	implements ComboBoxModel, PropertyChangeListener {
	protected FileFilter[] filters;

	protected FilterComboBoxModel() {
	super();
	filters = getFileChooser().getChoosableFileFilters();
	}

	public void propertyChange(PropertyChangeEvent e) {
	String prop = e.getPropertyName();
	if (prop == JFileChooser.CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY) {
	filters = (FileFilter[]) e.getNewValue();
	fireContentsChanged(this, -1, -1);
	} else if (prop == JFileChooser.FILE_FILTER_CHANGED_PROPERTY) {
	fireContentsChanged(this, -1, -1);
	}
	}

	public void setSelectedItem(Object filter) {
	if (filter != null) {
	getFileChooser().setFileFilter((FileFilter) filter);
	fireContentsChanged(this, -1, -1);
	}
	}

	public Object getSelectedItem() {
	// Ensure that the current filter is in the list.
	// NOTE: we shouldnt' have to do this, since JFileChooser adds
	// the filter to the choosable filters list when the filter
	// is set. Lets be paranoid just in case someone overrides
	// setFileFilter in JFileChooser.
	FileFilter currentFilter = getFileChooser().getFileFilter();
	boolean found = false;
	if (currentFilter != null) {
	for (FileFilter filter : filters) {
	if (filter == currentFilter) {
	found = true;
	}
	}
	if (found == false) {
	getFileChooser().addChoosableFileFilter(currentFilter);
	}
	}
	return getFileChooser().getFileFilter();
	}

	public int getSize() {
	if (filters != null) {
	return filters.length;
	} else {
	return 0;
	}
	}

	public Object getElementAt(int index) {
	if (index > getSize() - 1) {
	// This shouldn't happen. Try to recover gracefully.
	return getFileChooser().getFileFilter();
	}
	if (filters != null) {
	return filters[index];
	} else {
	return null;
	}
	}
	}
	}

Back to index...