Attachment #145946 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 (+47 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-69 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;
Lines 96-101 Link Here
96	public abstract void setCurrentDirectory(FileObject dir);	99	public abstract void setCurrentDirectory(FileObject dir);
97	public abstract FileObject getSelectedFileObject();	100	public abstract FileObject getSelectedFileObject();
98	public abstract FileObject[] getSelectedFileObjects();	101	public abstract FileObject[] getSelectedFileObjects();
		102
		103	/**
		104	* Very close to getHomeDirectory, but isn't quite the same:
		105	* getHomePath()
		106	* - does not create file object,
		107	* - does not fire event,
		108	* - is fast (in the case remote host info isn't avaliable, just returns "/")
		109	* @return user home
		110	*/
		111	/package/ abstract String getHomePath();
		112
		113	/**
		114	* Used to determine whether "~" should be expanded to home directory
		115	* @return
		116	*/
		117	/package/ public abstract boolean isUnix();
99		118
100	@Override	119	@Override
101	public final File getCurrentDirectory() {	120	public final File getCurrentDirectory() {
Lines 228-233 Link Here
228	}	247	}
229		248
230	@Override	249	@Override
		250	public String getHomePath() {
		251	return System.getProperty("user.home");
		252	}
		253
		254	@Override
		255	public boolean isUnix() {
		256	return Utilities.isUnix();
		257	}
		258
		259	@Override
231	public void setCurrentDirectory(FileObject dir) {	260	public void setCurrentDirectory(FileObject dir) {
232	if (dir != null && dir.isFolder()) {	261	if (dir != null && dir.isFolder()) {
233	File file = FileUtil.toFile(dir);	262	File file = FileUtil.toFile(dir);
Lines 349-354 Link Here
349	return result.toArray(new FileObject[result.size()]);	378	return result.toArray(new FileObject[result.size()]);
350	}	379	}
351	}	380	}
		381
		382	@Override
		383	public String getHomePath() {
		384	if (HostInfoUtils.isHostInfoAvailable(env)) {
		385	try {
		386	return HostInfoUtils.getHostInfo(env).getUserDir();
		387	} catch (IOException ex) {
		388	RemoteLogger.finest(ex);
		389	} catch (ConnectionManager.CancellationException ex) {
		390	}
		391	}
		392	return "/"; //NOI18N
		393	}
		394
		395	@Override
		396	public boolean isUnix() {
		397	return Utilities.isUnix();
		398	}
352		399
353	@Override	400	@Override
354	protected void setup(FileSystemView view) {	401	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 RequestProcessor COMMON_RP = new RequestProcessor("Cnd File Chooser Common Worker", 16); // NOI18N
    private static final RequestProcessor UPDATE_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 = UPDATE_RP.create(listFilesWorker);
    private volatile File curDir;

    private final Action approveSelectionAction;
    private final Action cancelSelectionAction;
    private final AtomicBoolean cancelled = new AtomicBoolean(false);    

    private FileFilter actualFileFilter = null;
    private GlobFilter globFilter = null;

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

    @Override
    public void installUI(JComponent c) {
        super.installUI(c);
        fileChooser = (JFileChooserEx) c;
    }   
    
    @Override

        AbstractAction escAction = new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                getCancelSelectionAction().actionPerformed(e);
            }
            @Override
            public boolean isEnabled(){

            // #105801: completionPopup might not be ready when updateCompletions not called (empty text field)
            if (completionPopup != null && !completionPopup.isVisible()) {
                if (keyCode == KeyEvent.VK_ENTER) {
                    getApproveSelectionAction().actionPerformed(new ActionEvent(evt.getSource(), evt.getID(), "")); //NOI18N
                    evt.consume();
                }               
                        fileChooser.approveSelection();
                        if (file.getParentFile() == null) {
                            // this will hopefully prevent popup to take inappropriate action
                            evt.consume();
                        }
                    }
                }
                
                if ((keyCode == KeyEvent.VK_TAB || keyCode == KeyEvent.VK_DOWN) ||
                    (keyCode == KeyEvent.VK_RIGHT && 
                    (filenameTextField.getCaretPosition() >= (filenameTextField.getDocument().getLength() - 1)))) {

        }

    } // end of UpdateWorker

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

    @Override
    public Action getCancelSelectionAction() {
        return cancelSelectionAction;
    }

    private class CancelSelectionAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
            cancelled.set(true);
            getFileChooser().cancelSelection();
        }
    }

    private 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 (fileChooser.isUnix()) {
                if (filename.startsWith("~/")) {
                    filename = fileChooser.getHomePath() + filename.substring(1);
                } else if (filename.equals("~")) {
                    filename = fileChooser.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, cancelled);
            ApproveSelectionThreadWorker worker = new ApproveSelectionThreadWorker(
                    e, filename, fileChooser.isMultiSelectionEnabled(), 
                    fileChooser.getCurrentDirectory(), fileChooser.getFileSystemView(), 
                    selectedFiles, finisher);
            APPROVE_RP.post(worker);
        }

        private void cancel() {
            cancelled.set(true);
        }
    }
    
    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() {
            try {
                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);
                }
            } finally {
                SwingUtilities.invokeLater(finisher);
            }
        }        
    }
    
    private class ApproveSelectionFinisher implements Runnable {

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

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

            enableAllButCancel(true);
            
            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();
            }
        }        
    }
    
    private void enableAllButCancel(boolean enable) {
        FileChooserUIImpl.this.newFolderButton.setEnabled(enable);
        FileChooserUIImpl.this.approveButton.setEnabled(enable);        
//        FileChooserUIImpl.this.topCombo.setEnabled(enable);
//        FileChooserUIImpl.this.filenameTextField.setEditable(enable);
//        FileChooserUIImpl.this.filenameTextField.setEnabled(enable);
//        FileChooserUIImpl.this.filterTypeComboBox.setEnabled(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;
        }
    }
    
}




import org.netbeans.modules.nativeexecution.api.util.ConnectionManager.CancellationException;
import java.util.logging.Level;
import javax.swing.Icon;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.filechooser.FileSystemView;
import org.netbeans.modules.dlight.libs.common.PathUtilities;
import org.netbeans.modules.nativeexecution.api.ExecutionEnvironment;
import org.netbeans.modules.nativeexecution.api.HostInfo;
import org.netbeans.modules.nativeexecution.api.util.ConnectionManager;

import org.netbeans.modules.remote.support.RemoteLogger;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.util.Exceptions;

/**
 *


    @Override
    public File createFileObject(String path) {
        if (RemoteLogger.getInstance().isLoggable(Level.FINEST)) {
            if (SwingUtilities.isEventDispatchThread()) {
                RemoteLogger.finest(new IllegalStateException("RFSV: creating file in EDT " + path)); //NOI18N
            } else {
                RemoteLogger.getInstance().log(Level.FINEST, "RFSV: creating file for {0}", path);
            }
        }
        RemoteLogger.getInstance().log(Level.FINEST, "RFSV: creating file for {0}", path);
        if (!path.isEmpty() && path.charAt(0) != '/') {
            return factory.create(env, path);

            HostInfo hostInfo = HostInfoUtils.getHostInfo(env);
            return factory.create(env, fs.findResource(hostInfo.getUserDir()));
        } catch (IOException ex) {
            RemoteLogger.finest(ex);
        } catch (CancellationException ex) {
            // never report cancellation exception
        } finally {
            changeSupport.firePropertyChange(LOADING_STATUS, "${HOME}", null); // NOI18N
        }

Return to bug 242099