Attachment #145530 for bug #242099

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 242099
Collapse All | Expand All

Lines 49-54 Link Here

(-)a/dlight.remote/src/org/netbeans/modules/remote/api/ui/FileChooserBuilder.java (+42 lines)
49	import java.beans.PropertyChangeEvent;	49	import java.beans.PropertyChangeEvent;
50	import java.beans.PropertyChangeListener;	50	import java.beans.PropertyChangeListener;
51	import java.io.File;	51	import java.io.File;
		52	import java.io.IOException;
52	import java.util.ArrayList;	53	import java.util.ArrayList;
53	import java.util.List;	54	import java.util.List;
54	import java.util.concurrent.Callable;	55	import java.util.concurrent.Callable;
Lines 64-73 Link Here
64	import javax.swing.plaf.FileChooserUI;	65	import javax.swing.plaf.FileChooserUI;
65	import org.netbeans.modules.nativeexecution.api.ExecutionEnvironment;	66	import org.netbeans.modules.nativeexecution.api.ExecutionEnvironment;
66	import org.netbeans.modules.nativeexecution.api.ExecutionEnvironmentFactory;	67	import org.netbeans.modules.nativeexecution.api.ExecutionEnvironmentFactory;
		68	import org.netbeans.modules.nativeexecution.api.util.ConnectionManager;
		69	import org.netbeans.modules.nativeexecution.api.util.HostInfoUtils;
67	import org.netbeans.modules.remote.spi.FileSystemProvider;	70	import org.netbeans.modules.remote.spi.FileSystemProvider;
68	import org.netbeans.modules.remote.support.RemoteLogger;	71	import org.netbeans.modules.remote.support.RemoteLogger;
69	import org.openide.filesystems.FileObject;	72	import org.openide.filesystems.FileObject;
		73	import org.openide.filesystems.FileSystem;
70	import org.openide.filesystems.FileUtil;	74	import org.openide.filesystems.FileUtil;
		75	import org.openide.util.Exceptions;
71	import org.openide.util.NbBundle;	76	import org.openide.util.NbBundle;
72	import org.openide.util.Utilities;	77	import org.openide.util.Utilities;
73		78
Lines 96-101 Link Here
96	public abstract void setCurrentDirectory(FileObject dir);	101	public abstract void setCurrentDirectory(FileObject dir);
97	public abstract FileObject getSelectedFileObject();	102	public abstract FileObject getSelectedFileObject();
98	public abstract FileObject[] getSelectedFileObjects();	103	public abstract FileObject[] getSelectedFileObjects();
		104
		105	/**
		106	* Very close to getHomeDirectory, but isn't quite the same:
		107	* does not create file object, does not fire event
		108	* @return user home
		109	*/
		110	/package/ abstract String getHomePath();
		111
		112	/package/ public abstract boolean isUnix();
99		113
100	@Override	114	@Override
101	public final File getCurrentDirectory() {	115	public final File getCurrentDirectory() {
Lines 228-233 Link Here
228	}	242	}
229		243
230	@Override	244	@Override
		245	public String getHomePath() {
		246	return System.getProperty("user.home");
		247	}
		248
		249	@Override
		250	public boolean isUnix() {
		251	return Utilities.isUnix();
		252	}
		253
		254	@Override
231	public void setCurrentDirectory(FileObject dir) {	255	public void setCurrentDirectory(FileObject dir) {
232	if (dir != null && dir.isFolder()) {	256	if (dir != null && dir.isFolder()) {
233	File file = FileUtil.toFile(dir);	257	File file = FileUtil.toFile(dir);
Lines 349-354 Link Here
349	return result.toArray(new FileObject[result.size()]);	373	return result.toArray(new FileObject[result.size()]);
350	}	374	}
351	}	375	}
		376
		377	@Override
		378	public String getHomePath() {
		379	if (HostInfoUtils.isHostInfoAvailable(env)) {
		380	try {
		381	return HostInfoUtils.getHostInfo(env).getUserDir();
		382	} catch (IOException ex) {
		383	RemoteLogger.finest(ex);
		384	} catch (ConnectionManager.CancellationException ex) {
		385	}
		386	}
		387	return "/"; //NOI18N
		388	}
		389
		390	@Override
		391	public boolean isUnix() {
		392	return Utilities.isUnix();
		393	}
352		394
353	@Override	395	@Override
354	protected void setup(FileSystemView view) {	396	protected void setup(FileSystemView view) {




import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;

import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import javax.swing.AbstractAction;
import javax.swing.AbstractListModel;
import javax.swing.Action;

import javax.swing.filechooser.FileSystemView;
import javax.swing.filechooser.FileView;
import javax.swing.plaf.ActionMapUIResource;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.UIResource;
import javax.swing.plaf.basic.BasicFileChooserUI;
import javax.swing.tree.DefaultMutableTreeNode;

import org.openide.util.NbPreferences;
import org.openide.util.RequestProcessor;
import org.openide.util.Utilities;
import sun.awt.shell.ShellFolder;
import sun.swing.FilePane;

/**
 * An implementation of a customized filechooser.
 *
 * @author Soot Phengsy, inspired by Jeff Dinkins' Swing version
 */
final class FileChooserUIImpl extends BasicFileChooserUI{
    
    static final String USE_SHELL_FOLDER = "FileChooser.useShellFolder";//NOI18N
    static final String NB_USE_SHELL_FOLDER = "nb.FileChooser.useShellFolder";//NOI18N

    private static final Logger LOG = Logger.getLogger(FileChooserUIImpl.class.getName());

    private static final RequestProcessor RP = new RequestProcessor("Cnd File Chooser Update Worker"); // NOI18N
    private static final RequestProcessor APPROVE_RP = new RequestProcessor("Cnd File Chooser Update Worker"); // NOI18N

    private static final String TIMEOUT_KEY="nb.fileChooser.timeout"; // NOI18N


    private final RequestProcessor.Task listFilesTask = RP.create(listFilesWorker);
    private volatile File curDir;

    private final Action approveSelectionAction;
    private FileFilter actualFileFilter = null;
    private GlobFilter globFilter = null;

    public FileChooserUIImpl(FileChooserBuilder.JFileChooserEx filechooser) {
        super(filechooser);
        approveSelectionAction = new ApproveSelectionAction();
    }

    @Override
    public JFileChooserEx getFileChooser() {
        return fileChooser;
    }

    @Override
    public void installUI(JComponent c) {
        super.installUI(c);

        }

    } // end of UpdateWorker

    @Override
    public Action getApproveSelectionAction() {
        return approveSelectionAction;
    }

    protected class ApproveSelectionAction extends AbstractAction {

        protected ApproveSelectionAction() {
            super(FilePane.ACTION_APPROVE_SELECTION);
        }

        @Override
        public void actionPerformed(final ActionEvent e) {
            if (isDirectorySelected()) {
                File dir = getDirectory();
                if (dir != null) {
                    try {
                        // Strip trailing ".."
                        dir = ShellFolder.getNormalizedFile(dir);
                    } catch (IOException ex) {
                        // Ok, use f as is
                    }
                    changeDirectory(dir);
                    return;
                }
            }

            String filename = getFileName();

            if (filename != null) {
                // VK: why isn't it just trim() ? - do we really need leading spaces??
                // Remove whitespaces from end of filename
                int i = filename.length() - 1;
                while (i >=0 && filename.charAt(i) <= ' ') {
                    i--;
                }
                filename = filename.substring(0, i + 1);
            }

            if (filename == null || filename.length() == 0) {
                // no file selected, multiple selection off, therefore cancel the approve action
                resetGlobFilter();
                return;
            }

            // Unix: Resolve '~' to user's home directory
            if (getFileChooser().isUnix()) {
                if (filename.startsWith("~/")) {
                    filename = getFileChooser().getHomePath() + filename.substring(1);
                } else if (filename.equals("~")) {
                    filename = getFileChooser().getHomePath();
                }
            }

            // in the case of single selectiom, use selectedFiles.get(0)
            final List<File> selectedFiles = new ArrayList<>();

            enableAllButCancel(false);
            ApproveSelectionFinisher finisher = new ApproveSelectionFinisher(e, filename, selectedFiles);
            JFileChooserEx chooser = getFileChooser();
            ApproveSelectionThreadWorker worker = new ApproveSelectionThreadWorker(
                    e, filename, chooser.isMultiSelectionEnabled(), 
                    chooser.getCurrentDirectory(), chooser.getFileSystemView(), 
                    selectedFiles, finisher);
            APPROVE_RP.post(worker);
        }
    }
    
    private static class ApproveSelectionThreadWorker implements Runnable {

        private final ActionEvent e;
        private final String filename;
        private final boolean multySelection;
        private final File currentDir;        
        private final FileSystemView fs;
        private final List<File> selectedFiles;
        private final ApproveSelectionFinisher finisher;

        public ApproveSelectionThreadWorker(ActionEvent e, String filename, boolean multySelection, File currentDir, FileSystemView fs, List<File> selectedFiles, ApproveSelectionFinisher finisher) {
            this.e = e;
            this.filename = filename;
            this.multySelection = multySelection;
            this.currentDir = currentDir;
            this.fs = fs;
            this.selectedFiles = selectedFiles;
            this.finisher = finisher;
        }

        @Override
        public void run() {

            if (multySelection && filename.length() > 1 &&
                    filename.charAt(0) == '"' && filename.charAt(filename.length() - 1) == '"') {

                // VK: double space between \" breaks this?! 
                String[] files = filename.substring(1, filename.length() - 1).split("\" \"");
                // Optimize searching files by names in "children" array
                Arrays.sort(files);

                File[] children = null;
                int childIndex = 0;

                for (String str : files) {
                    File file = fs.createFileObject(str);
                    if (!file.isAbsolute()) {
                        if (children == null) {
                            children = fs.getFiles(currentDir, false);
                            Arrays.sort(children);
                        }
                        for (int k = 0; k < children.length; k++) {
                            int l = (childIndex + k) % children.length;
                            if (children[l].getName().equals(str)) {
                                file = children[l];
                                childIndex = l + 1;
                                break;
                            }
                        }
                    }
                    selectedFiles.add(file);
                }
            } else {
                File selectedFile = fs.createFileObject(filename);
                if (!selectedFile.isAbsolute()) {
                    selectedFile = fs.getChild(currentDir, filename);
                }
                selectedFiles.add(selectedFile);
            }
        }        
    }
    
    private class ApproveSelectionFinisher implements Runnable {

        private final String filename;
        private final List<File> selectedFiles;
        private final ActionEvent e;

        public ApproveSelectionFinisher(ActionEvent e, String filename, List<File> selectedFiles) {
            this.e = e;
            this.selectedFiles = selectedFiles;
            this.filename = filename;
        }
        
        @Override
        public void run() {

            JFileChooser chooser = getFileChooser();
            resetGlobFilter();
            
            if (selectedFiles.size() == 1) {

                File selectedFile = selectedFiles.get(0);

                // check for wildcard pattern
                FileFilter currentFilter = chooser.getFileFilter();
                if (!selectedFile.exists() && isGlobPattern(filename)) {
                    changeDirectory(selectedFile.getParentFile());
                    if (globFilter == null) {
                        globFilter = new GlobFilter();
                    }
                    try {
                        globFilter.setPattern(selectedFile.getName());
                        if (!(currentFilter instanceof GlobFilter)) {
                            actualFileFilter = currentFilter;
                        }
                        chooser.setFileFilter(null);
                        chooser.setFileFilter(globFilter);
                        return;
                    } catch (PatternSyntaxException pse) {
                        // Not a valid glob pattern. Abandon filter.
                    }
                }
                
                // Check for directory change action
                boolean isDir = (selectedFile != null && selectedFile.isDirectory());
                boolean isTrav = (selectedFile != null && chooser.isTraversable(selectedFile));
                boolean isDirSelEnabled = chooser.isDirectorySelectionEnabled();
                boolean isFileSelEnabled = chooser.isFileSelectionEnabled();
                boolean isCtrl = (e != null && (e.getModifiers() & 
                        Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()) != 0);

                if (isDir && isTrav && (isCtrl || !isDirSelEnabled)) {
                    changeDirectory(selectedFile);
                    return;
                } else if ((isDir || !isFileSelEnabled)
                        && (!isDir || !isDirSelEnabled)
                        && (!isDirSelEnabled || selectedFile.exists())) {
                    selectedFiles.clear();
                }
            }
                
            
            if (!selectedFiles.isEmpty()) {
                if (chooser.isMultiSelectionEnabled()) {
                    final File[] selectedFilesArray = selectedFiles.toArray(new File[selectedFiles.size()]);
                    chooser.setSelectedFiles(selectedFilesArray);
                    // Do it again. This is a fix for bug 4949273 to force the
                    // selected value in case the ListSelectionModel clears it
                    // for non-existing file names.
                    chooser.setSelectedFiles(selectedFilesArray);
                } else {
                    chooser.setSelectedFile(selectedFiles.get(0));
                }
                chooser.approveSelection();
            } else {
                if (chooser.isMultiSelectionEnabled()) {
                    chooser.setSelectedFiles(null);
                } else {
                    chooser.setSelectedFile(null);
                }
                chooser.cancelSelection();
            }
            enableAllButCancel(true);            
        }        
    }
    
    private void enableAllButCancel(boolean enable) {
        FileChooserUIImpl.this.approveButton.setEnabled(enable);
        FileChooserUIImpl.this.topCombo.setEnabled(enable);
        FileChooserUIImpl.this.filenameTextField.setEditable(enable);
        FileChooserUIImpl.this.tree.setEnabled(enable);
    }

    private void changeDirectory(File dir) {
        JFileChooser fc = getFileChooser();
        // Traverse shortcuts on Windows
        if (dir != null && FilePane.usesShellFolder(fc)) {
            try {
                ShellFolder shellFolder = ShellFolder.getShellFolder(dir);

                if (shellFolder.isLink()) {
                    File linkedTo = shellFolder.getLinkLocation();

                    // If linkedTo is null we try to use dir
                    if (linkedTo != null) {
                        if (fc.isTraversable(linkedTo)) {
                            dir = linkedTo;
                        } else {
                            return;
                        }
                    } else {
                        dir = shellFolder;
                    }
                }
            } catch (FileNotFoundException ex) {
                return;
            }
        }
        fc.setCurrentDirectory(dir);
        if (fc.getFileSelectionMode() == JFileChooser.FILES_AND_DIRECTORIES &&
            fc.getFileSystemView().isFileSystem(dir)) {

            setFileName(dir.getAbsolutePath());
        }
    }

    private void resetGlobFilter() {
        if (actualFileFilter != null) {
            JFileChooser chooser = getFileChooser();
            FileFilter currentFilter = chooser.getFileFilter();
            if (currentFilter != null && currentFilter.equals(globFilter)) {
                chooser.setFileFilter(actualFileFilter);
                chooser.removeChoosableFileFilter(globFilter);
            }
            actualFileFilter = null;
        }
    }    
    
    private static boolean isGlobPattern(String filename) {
        return ((File.separatorChar == '\\' && (filename.indexOf('*') >= 0
                                                  || filename.indexOf('?') >= 0))
                || (File.separatorChar == '/' && (filename.indexOf('*') >= 0
                                                  || filename.indexOf('?') >= 0
                                                  || filename.indexOf('[') >= 0)));
    }


    /* A file filter which accepts file patterns containing
     * the special wildcards *? on Windows and *?[] on Unix.
     */
    class GlobFilter extends FileFilter {
        Pattern pattern;
        String globPattern;

        public void setPattern(String globPattern) {
            char[] gPat = globPattern.toCharArray();
            char[] rPat = new char[gPat.length * 2];
            boolean isWin32 = (File.separatorChar == '\\');
            boolean inBrackets = false;
            int j = 0;

            this.globPattern = globPattern;

            if (isWin32) {
                // On windows, a pattern ending with *.* is equal to ending with *
                int len = gPat.length;
                if (globPattern.endsWith("*.*")) {
                    len -= 2;
                }
                for (int i = 0; i < len; i++) {
                    switch(gPat[i]) {
                      case '*':
                        rPat[j++] = '.';
                        rPat[j++] = '*';
                        break;

                      case '?':
                        rPat[j++] = '.';
                        break;

                      case '\\':
                        rPat[j++] = '\\';
                        rPat[j++] = '\\';
                        break;

                      default:
                        if ("+()^$.{}[]".indexOf(gPat[i]) >= 0) {
                            rPat[j++] = '\\';
                        }
                        rPat[j++] = gPat[i];
                        break;
                    }
                }
            } else {
                for (int i = 0; i < gPat.length; i++) {
                    switch(gPat[i]) {
                      case '*':
                        if (!inBrackets) {
                            rPat[j++] = '.';
                        }
                        rPat[j++] = '*';
                        break;

                      case '?':
                        rPat[j++] = inBrackets ? '?' : '.';
                        break;

                      case '[':
                        inBrackets = true;
                        rPat[j++] = gPat[i];

                        if (i < gPat.length - 1) {
                            switch (gPat[i+1]) {
                              case '!':
                              case '^':
                                rPat[j++] = '^';
                                i++;
                                break;

                              case ']':
                                rPat[j++] = gPat[++i];
                                break;
                            }
                        }
                        break;

                      case ']':
                        rPat[j++] = gPat[i];
                        inBrackets = false;
                        break;

                      case '\\':
                        if (i == 0 && gPat.length > 1 && gPat[1] == '~') {
                            rPat[j++] = gPat[++i];
                        } else {
                            rPat[j++] = '\\';
                            if (i < gPat.length - 1 && "*?[]".indexOf(gPat[i+1]) >= 0) {
                                rPat[j++] = gPat[++i];
                            } else {
                                rPat[j++] = '\\';
                            }
                        }
                        break;

                      default:
                        //if ("+()|^$.{}<>".indexOf(gPat[i]) >= 0) {
                        if (!Character.isLetterOrDigit(gPat[i])) {
                            rPat[j++] = '\\';
                        }
                        rPat[j++] = gPat[i];
                        break;
                    }
                }
            }
            this.pattern = Pattern.compile(new String(rPat, 0, j), Pattern.CASE_INSENSITIVE);
        }

        @Override
        public boolean accept(File f) {
            if (f == null) {
                return false;
            }
            if (f.isDirectory()) {
                return true;
            }
            return pattern.matcher(f.getName()).matches();
        }

        @Override
        public String getDescription() {
            return globPattern;
        }
    }
    
}

Lines 51-56 Link Here

(-)a/dlight.remote/src/org/netbeans/modules/remote/api/ui/RemoteFileSystemView.java (-2 / +6 lines)
51	import org.netbeans.modules.nativeexecution.api.util.ConnectionManager.CancellationException;	51	import org.netbeans.modules.nativeexecution.api.util.ConnectionManager.CancellationException;
52	import java.util.logging.Level;	52	import java.util.logging.Level;
53	import javax.swing.Icon;	53	import javax.swing.Icon;
		54	import javax.swing.SwingUtilities;
54	import javax.swing.UIManager;	55	import javax.swing.UIManager;
55	import javax.swing.filechooser.FileSystemView;	56	import javax.swing.filechooser.FileSystemView;
56	import org.netbeans.modules.dlight.libs.common.PathUtilities;	57	import org.netbeans.modules.dlight.libs.common.PathUtilities;
Lines 95-100 Link Here
95		96
96	@Override	97	@Override
97	public File createFileObject(String path) {	98	public File createFileObject(String path) {
		99	if (SwingUtilities.isEventDispatchThread()) {
		100	RemoteLogger.finest(new IllegalStateException("RFSV: creating file in EDT")); //NOI18N
		101	}
98	RemoteLogger.getInstance().log(Level.FINEST, "RFSV: creating file for {0}", path);	102	RemoteLogger.getInstance().log(Level.FINEST, "RFSV: creating file for {0}", path);
99	if (!path.isEmpty() && path.charAt(0) != '/') {	103	if (!path.isEmpty() && path.charAt(0) != '/') {
100	return factory.create(env, path);	104	return factory.create(env, path);
Lines 152-160 Link Here
152	HostInfo hostInfo = HostInfoUtils.getHostInfo(env);	156	HostInfo hostInfo = HostInfoUtils.getHostInfo(env);
153	return factory.create(env, fs.findResource(hostInfo.getUserDir()));	157	return factory.create(env, fs.findResource(hostInfo.getUserDir()));
154	} catch (IOException ex) {	158	} catch (IOException ex) {
155	Exceptions.printStackTrace(ex);	159	RemoteLogger.finest(ex);
156	} catch (CancellationException ex) {	160	} catch (CancellationException ex) {
157	Exceptions.printStackTrace(ex);	161	// never report cancellation exception
158	} finally {	162	} finally {
159	changeSupport.firePropertyChange(LOADING_STATUS, "${HOME}", null); // NOI18N	163	changeSupport.firePropertyChange(LOADING_STATUS, "${HOME}", null); // NOI18N
160	}	164	}

Return to bug 242099