gtkfilechooserui.java

来自「JAVA 所有包」· Java 代码 · 共 1,363 行 · 第 1/4 页

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

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

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

        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);
	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 fileComparator = new Comparator() {
            public int compare(Object o, Object o1) {
                return fsv.getSystemDisplayName((File) o).compareTo
                      (fsv.getSystemDisplayName((File) 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;
	}
    }

    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;