Example usage for org.apache.commons.vfs2 FileObject getFileSystem

Introduction

In this page you can find the example usage for org.apache.commons.vfs2 FileObject getFileSystem.

Prototype

FileSystem getFileSystem();

Source Link

Document

Returns the file system that contains this file.

Usage

From source file:org.pentaho.big.data.kettle.plugins.formats.impl.avro.BaseAvroStepDialog.java

protected void browseForFileInputPath() {
    try {//  w  w  w.jav  a  2 s . co m
        String path = transMeta.environmentSubstitute(wPath.getText());
        VfsFileChooserDialog fileChooserDialog;
        String fileName;
        if (Utils.isEmpty(path)) {
            fileChooserDialog = getVfsFileChooserDialog(null, null);
            fileName = selectedVFSScheme.getScheme() + "://";
        } else {
            FileObject initialFile = getInitialFile(wPath.getText());
            FileObject rootFile = initialFile.getFileSystem().getRoot();
            fileChooserDialog = getVfsFileChooserDialog(rootFile, initialFile);
            fileName = null;
        }

        FileObject selectedFile = fileChooserDialog.open(shell, null, selectedVFSScheme.getScheme(), true,
                fileName, FILES_FILTERS, fileFilterNames, true,
                VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, true, true);
        if (selectedFile != null) {
            String filePath = selectedFile.getURL().toString();
            if (!DEFAULT_LOCAL_PATH.equals(filePath)) {
                wPath.setText(filePath);
                updateLocation();
            }
        }
    } catch (KettleFileException ex) {
        log.logError(getBaseMsg("AvroInputDialog.FileBrowser.KettleFileException"));
    } catch (FileSystemException ex) {
        log.logError(getBaseMsg("AvroInputDialog.FileBrowser.FileSystemException"));
    }
}

---

From source file:org.pentaho.big.data.kettle.plugins.formats.impl.avro.input.AvroInputDialog.java

private void browseForFileInputPathForSchema() {
    try {//from   w w w . ja  v a 2  s .  c o m
        String path = transMeta.environmentSubstitute(wSchemaPath.getText());
        VfsFileChooserDialog fileChooserDialog;
        String fileName;
        if (Utils.isEmpty(path)) {
            fileChooserDialog = getVfsFileChooserDialog(null, null);
            fileName = selectedSchemaVFSScheme.getScheme() + "://";
        } else {
            FileObject initialFile = getInitialFile(wSchemaPath.getText());
            FileObject rootFile = initialFile.getFileSystem().getRoot();
            fileChooserDialog = getVfsFileChooserDialog(rootFile, initialFile);
            fileName = null;
        }

        FileObject selectedFile = fileChooserDialog.open(shell, null, selectedSchemaVFSScheme.getScheme(), true,
                fileName, FILES_FILTERS, fileFilterNames, true,
                VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, true, true);
        if (selectedFile != null) {
            wSchemaPath.setText(selectedFile.getURL().toString());
            updateSchemaLocation();
        }
    } catch (KettleFileException ex) {
        log.logError(getBaseMsg("AvroInputDialog.SchemaFileBrowser.KettleFileException"));
    } catch (FileSystemException ex) {
        log.logError(getBaseMsg("AvroInputDialog.SchemaFileBrowser.FileSystemException"));
    }
}

---

From source file:org.pentaho.big.data.kettle.plugins.formats.impl.avro.output.AvroOutputDialog.java

private void browseForFileInputPathForSchema() {
    try {/*from w w w  .j  a  v a2s. co  m*/
        String path = transMeta.environmentSubstitute(wSchemaPath.getText());
        VfsFileChooserDialog fileChooserDialog;
        String fileName;
        if (Utils.isEmpty(path)) {
            fileChooserDialog = getVfsFileChooserDialog(null, null);
            fileName = SCHEMA_SCHEME_DEFAULT + "://";
        } else {
            FileObject initialFile = getInitialFile(wSchemaPath.getText());
            FileObject rootFile = initialFile.getFileSystem().getRoot();
            fileChooserDialog = getVfsFileChooserDialog(rootFile, initialFile);
            fileName = null;
        }

        FileObject selectedFile = fileChooserDialog.open(shell, null, getSchemeFromPath(path), true, fileName,
                FILES_FILTERS, fileFilterNames, true, VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY,
                true, true);
        if (selectedFile != null) {
            wSchemaPath.setText(selectedFile.getURL().toString());
        }
    } catch (KettleFileException ex) {
        log.logError(getBaseMsg("AvroInputDialog.SchemaFileBrowser.KettleFileException"));
    } catch (FileSystemException ex) {
        log.logError(getBaseMsg("AvroInputDialog.SchemaFileBrowser.FileSystemException"));
    }
}

---

From source file:org.pentaho.big.data.kettle.plugins.formats.impl.orc.BaseOrcStepDialog.java

protected void browseForFileInputPath() {
    try {/*from  w  w w .j av  a2  s .  c  o m*/
        String path = transMeta.environmentSubstitute(wPath.getText());
        VfsFileChooserDialog fileChooserDialog;
        String fileName;
        if (Utils.isEmpty(path)) {
            fileChooserDialog = getVfsFileChooserDialog(null, null);
            fileName = selectedVFSScheme.getScheme() + "://";
        } else {
            FileObject initialFile = getInitialFile(wPath.getText());
            FileObject rootFile = initialFile.getFileSystem().getRoot();
            fileChooserDialog = getVfsFileChooserDialog(rootFile, initialFile);
            fileName = null;
        }

        FileObject selectedFile = fileChooserDialog.open(shell, null, selectedVFSScheme.getScheme(), true,
                fileName, FILES_FILTERS, fileFilterNames, true,
                VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, true, true);
        if (selectedFile != null) {
            String filePath = selectedFile.getURL().toString();
            if (!DEFAULT_LOCAL_PATH.equals(filePath)) {
                wPath.setText(filePath);
                updateLocation();
            }
        }
    } catch (KettleFileException ex) {
        log.logError(getBaseMsg("OrcDialog.FileBrowser.KettleFileException"));
    } catch (FileSystemException ex) {
        log.logError(getBaseMsg("OrcDialog.FileBrowser.FileSystemException"));
    }
}

---

From source file:org.pentaho.big.data.kettle.plugins.formats.impl.parquet.BaseParquetStepDialog.java

protected void browseForFileInputPath() {
    try {//w  ww  . j  av  a2s .com
        String path = transMeta.environmentSubstitute(wPath.getText());
        VfsFileChooserDialog fileChooserDialog;
        String fileName;
        if (Utils.isEmpty(path)) {
            fileChooserDialog = getVfsFileChooserDialog(null, null);
            fileName = selectedVFSScheme.getScheme() + "://";
        } else {
            FileObject initialFile = getInitialFile(wPath.getText());
            FileObject rootFile = initialFile.getFileSystem().getRoot();
            fileChooserDialog = getVfsFileChooserDialog(rootFile, initialFile);
            fileName = null;
        }

        FileObject selectedFile = fileChooserDialog.open(shell, null, selectedVFSScheme.getScheme(), true,
                fileName, FILES_FILTERS, fileFilterNames, true,
                VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, true, true);
        if (selectedFile != null) {
            String filePath = selectedFile.getName().getFriendlyURI();
            if (!DEFAULT_LOCAL_PATH.equals(filePath)) {
                wPath.setText(filePath);
                updateLocation();
            }
        }
    } catch (KettleFileException ex) {
        log.logError(getBaseMsg("ParquetDialog.FileBrowser.KettleFileException"));
    } catch (FileSystemException ex) {
        log.logError(getBaseMsg("ParquetDialog.FileBrowser.FileSystemException"));
    }
}

---

From source file:org.pentaho.big.data.kettle.plugins.hdfs.job.JobEntryHadoopCopyFilesDialog.java

private FileObject setSelectedFile(String path, String clusterName) {

    FileObject selectedFile = null;

    try {/* www .java2s  .  c o m*/
        // Get current file
        FileObject rootFile = null;
        FileObject initialFile = null;
        FileObject defaultInitialFile = null;

        if (!clusterName.equals(LOCAL_ENVIRONMENT) && !clusterName.equals(S3_ENVIRONMENT)) {
            NamedCluster namedCluster = namedClusterService.getNamedClusterByName(clusterName, getMetaStore());
            if (Utils.isEmpty(path)) {
                path = "/";
            }
            if (namedCluster == null) {
                return null;
            }
            path = namedCluster.processURLsubstitution(path, getMetaStore(), jobMeta);
        }

        boolean resolvedInitialFile = false;

        if (path != null) {

            String fileName = jobMeta.environmentSubstitute(path);

            if (fileName != null && !fileName.equals("")) {
                try {
                    initialFile = KettleVFS.getFileObject(fileName);
                    resolvedInitialFile = true;
                } catch (Exception e) {
                    showMessageAndLog(BaseMessages.getString(PKG, "JobHadoopCopyFiles.Connection.Error.title"),
                            BaseMessages.getString(PKG, "JobHadoopCopyFiles.Connection.error"), e.getMessage());
                    return null;
                }
                File startFile = new File(System.getProperty("user.home"));
                defaultInitialFile = KettleVFS.getFileObject(startFile.getAbsolutePath());
                rootFile = initialFile.getFileSystem().getRoot();
            } else {
                defaultInitialFile = KettleVFS.getFileObject(Spoon.getInstance().getLastFileOpened());
            }
        }

        if (rootFile == null) {
            if (defaultInitialFile == null) {
                return null;
            }
            rootFile = defaultInitialFile.getFileSystem().getRoot();
            initialFile = defaultInitialFile;
        }
        VfsFileChooserDialog fileChooserDialog = Spoon.getInstance().getVfsFileChooserDialog(rootFile,
                initialFile);
        fileChooserDialog.defaultInitialFile = defaultInitialFile;

        NamedClusterWidgetImpl namedClusterWidget = null;

        if (clusterName.equals(LOCAL_ENVIRONMENT)) {
            selectedFile = fileChooserDialog.open(shell, new String[] { "file" }, "file", true, path,
                    new String[] { "*.*" }, FILETYPES, false,
                    VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, false);
        } else if (clusterName.equals(S3_ENVIRONMENT)) {
            selectedFile = fileChooserDialog.open(shell, new String[] { Schemes.S3_SCHEME }, Schemes.S3_SCHEME,
                    true, path, new String[] { "*.*" }, FILETYPES, false,
                    VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, true);
        } else {
            NamedCluster namedCluster = namedClusterService.getNamedClusterByName(clusterName, getMetaStore());
            if (namedCluster != null) {
                if (namedCluster.isMapr()) {
                    selectedFile = fileChooserDialog.open(shell, new String[] { Schemes.MAPRFS_SCHEME },
                            Schemes.MAPRFS_SCHEME, false, path, new String[] { "*.*" }, FILETYPES, true,
                            VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, false);
                } else {
                    List<CustomVfsUiPanel> customPanels = fileChooserDialog.getCustomVfsUiPanels();
                    for (CustomVfsUiPanel panel : customPanels) {
                        if (panel instanceof HadoopVfsFileChooserDialog) {
                            HadoopVfsFileChooserDialog hadoopDialog = ((HadoopVfsFileChooserDialog) panel);
                            namedClusterWidget = hadoopDialog.getNamedClusterWidget();
                            namedClusterWidget.initiate();
                            hadoopDialog.setNamedCluster(clusterName);
                            hadoopDialog.initializeConnectionPanel(initialFile);
                        }
                    }
                    if (resolvedInitialFile) {
                        fileChooserDialog.initialFile = initialFile;
                    }
                    selectedFile = fileChooserDialog.open(shell, new String[] { Schemes.HDFS_SCHEME },
                            Schemes.HDFS_SCHEME, false, path, new String[] { "*.*" }, FILETYPES, true,
                            VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, false);
                }
            }
        }

        CustomVfsUiPanel currentPanel = fileChooserDialog.getCurrentPanel();
        if (currentPanel instanceof HadoopVfsFileChooserDialog) {
            namedClusterWidget = ((HadoopVfsFileChooserDialog) currentPanel).getNamedClusterWidget();
        }

        if (selectedFile != null) {
            String url = selectedFile.getURL().toString();
            if (currentPanel.getVfsSchemeDisplayText().equals(LOCAL_ENVIRONMENT)) {
                wFields.getActiveTableItem().setText(wFields.getActiveTableColumn() - 1, LOCAL_ENVIRONMENT);
            } else if (currentPanel.getVfsSchemeDisplayText().equals(S3_ENVIRONMENT)) {
                wFields.getActiveTableItem().setText(wFields.getActiveTableColumn() - 1, S3_ENVIRONMENT);
            } else if (namedClusterWidget != null && namedClusterWidget.getSelectedNamedCluster() != null) {
                url = jobEntry.getUrlPath(url);
                wFields.getActiveTableItem().setText(wFields.getActiveTableColumn() - 1,
                        namedClusterWidget.getSelectedNamedCluster().getName());
            }
            wFields.getActiveTableItem().setText(wFields.getActiveTableColumn(), url);
        }

        return selectedFile;

    } catch (KettleFileException ex) {
        log.logError(BaseMessages.getString(PKG, "HadoopFileInputDialog.FileBrowser.KettleFileException"));
        return selectedFile;
    } catch (FileSystemException ex) {
        log.logError(BaseMessages.getString(PKG, "HadoopFileInputDialog.FileBrowser.FileSystemException"));
        return selectedFile;
    }
}

---

From source file:org.pentaho.big.data.kettle.plugins.hdfs.trans.HadoopFileInputDialog.java

private SelectionAdapter getFileDirectoryListener() {

    return new SelectionAdapter() {
        @Override/*w w  w .  j  ava 2s.c  o  m*/
        public void widgetSelected(SelectionEvent e) {
            try {
                // Setup file type filtering
                String[] fileFilters = null;
                String[] fileFilterNames = null;
                if (!wCompression.getText().equals("None")) {
                    fileFilters = new String[] { "*.zip;*.gz", "*.txt;*.csv", "*.csv", "*.txt", "*" };
                    fileFilterNames = new String[] {
                            BaseMessages.getString(BASE_PKG, "System.FileType.ZIPFiles"),
                            BaseMessages.getString(BASE_PKG, "TextFileInputDialog.FileType.TextAndCSVFiles"),
                            BaseMessages.getString(BASE_PKG, "System.FileType.CSVFiles"),
                            BaseMessages.getString(BASE_PKG, "System.FileType.TextFiles"),
                            BaseMessages.getString(BASE_PKG, "System.FileType.AllFiles") };
                } else {
                    fileFilters = new String[] { "*", "*.txt;*.csv", "*.csv", "*.txt" };
                    fileFilterNames = new String[] {
                            BaseMessages.getString(BASE_PKG, "System.FileType.AllFiles"),
                            BaseMessages.getString(BASE_PKG, "TextFileInputDialog.FileType.TextAndCSVFiles"),
                            BaseMessages.getString(BASE_PKG, "System.FileType.CSVFiles"),
                            BaseMessages.getString(BASE_PKG, "System.FileType.TextFiles") };
                }

                String clusterName = wFilenameList.getActiveTableItem()
                        .getText(wFilenameList.getActiveTableColumn() - 1);
                String path = wFilenameList.getActiveTableItem().getText(wFilenameList.getActiveTableColumn());

                // Get current file
                FileObject rootFile = null;
                FileObject initialFile = null;
                FileObject defaultInitialFile = null;

                boolean isCluster = false;
                if (!clusterName.equals(LOCAL_ENVIRONMENT) && !clusterName.equals(S3_ENVIRONMENT)) {
                    if (Const.isEmpty(path)) {
                        path = "/";
                    }
                    NamedCluster namedCluster = namedClusterService.getNamedClusterByName(clusterName,
                            getMetaStore());
                    if (namedCluster == null) {
                        return;
                    }
                    isCluster = true;
                    path = namedCluster.processURLsubstitution(path, getMetaStore(), transMeta);
                }

                boolean resolvedInitialFile = false;

                if (path != null) {
                    String fileName = transMeta.environmentSubstitute(path);
                    if (fileName != null && !fileName.equals("")) {
                        try {
                            initialFile = KettleVFS.getFileObject(fileName);
                            resolvedInitialFile = true;
                        } catch (Exception ex) {
                            showMessageAndLog(
                                    BaseMessages.getString(PKG, "HadoopFileInputDialog.Connection.Error.title"),
                                    BaseMessages.getString(PKG, "HadoopFileInputDialog.Connection.error"),
                                    ex.getMessage());
                            return;
                        }
                        File startFile = new File(System.getProperty("user.home"));
                        defaultInitialFile = KettleVFS.getFileObject(startFile.getAbsolutePath());
                        rootFile = initialFile.getFileSystem().getRoot();
                    } else {
                        defaultInitialFile = KettleVFS.getFileObject(Spoon.getInstance().getLastFileOpened());
                    }
                }

                if (rootFile == null) {
                    if (defaultInitialFile == null) {
                        return;
                    }
                    rootFile = defaultInitialFile.getFileSystem().getRoot();
                    initialFile = defaultInitialFile;
                }

                VfsFileChooserDialog fileChooserDialog = Spoon.getInstance().getVfsFileChooserDialog(rootFile,
                        initialFile);
                fileChooserDialog.defaultInitialFile = defaultInitialFile;

                NamedClusterWidgetImpl namedClusterWidget = null;

                FileObject selectedFile = null;

                if (clusterName.equals(LOCAL_ENVIRONMENT)) {
                    selectedFile = fileChooserDialog.open(shell, new String[] { "file" }, "file", true, path,
                            fileFilters, fileFilterNames, false,
                            VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, false);
                } else if (clusterName.equals(S3_ENVIRONMENT)) {
                    selectedFile = fileChooserDialog.open(shell, new String[] { Schemes.S3_SCHEME },
                            Schemes.S3_SCHEME, true, path, fileFilters, fileFilterNames, false,
                            VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, true);
                } else {
                    NamedCluster namedCluster = namedClusterService.getNamedClusterByName(clusterName,
                            getMetaStore());
                    if (namedCluster != null) {
                        if (namedCluster.isMapr()) {
                            selectedFile = fileChooserDialog.open(shell, new String[] { Schemes.MAPRFS_SCHEME },
                                    Schemes.MAPRFS_SCHEME, true, path, fileFilters, fileFilterNames, false,
                                    VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, false);
                        } else {
                            List<CustomVfsUiPanel> customPanels = fileChooserDialog.getCustomVfsUiPanels();
                            for (CustomVfsUiPanel panel : customPanels) {
                                if (panel instanceof HadoopVfsFileChooserDialog) {
                                    HadoopVfsFileChooserDialog hadoopDialog = ((HadoopVfsFileChooserDialog) panel);
                                    namedClusterWidget = hadoopDialog.getNamedClusterWidget();
                                    namedClusterWidget.initiate();
                                    hadoopDialog.setNamedCluster(clusterName);
                                    hadoopDialog.initializeConnectionPanel(initialFile);
                                }
                            }
                            if (resolvedInitialFile) {
                                fileChooserDialog.initialFile = initialFile;
                            }
                            selectedFile = fileChooserDialog.open(shell, new String[] { Schemes.HDFS_SCHEME },
                                    Schemes.HDFS_SCHEME, false, path, fileFilters, fileFilterNames, true,
                                    VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, false);
                        }

                    }
                }

                CustomVfsUiPanel currentPanel = fileChooserDialog.getCurrentPanel();
                if (currentPanel instanceof HadoopVfsFileChooserDialog) {
                    namedClusterWidget = ((HadoopVfsFileChooserDialog) currentPanel).getNamedClusterWidget();
                }

                if (selectedFile != null) {
                    String url = selectedFile.getURL().toString();
                    if (currentPanel.getVfsSchemeDisplayText().equals(LOCAL_ENVIRONMENT)) {
                        wFilenameList.getActiveTableItem().setText(wFilenameList.getActiveTableColumn() - 1,
                                LOCAL_ENVIRONMENT);
                    } else if (currentPanel.getVfsSchemeDisplayText().equals(S3_ENVIRONMENT)) {
                        wFilenameList.getActiveTableItem().setText(wFilenameList.getActiveTableColumn() - 1,
                                S3_ENVIRONMENT);
                    } else if (isCluster) {
                        url = input.getUrlPath(url);
                        wFilenameList.getActiveTableItem().setText(wFilenameList.getActiveTableColumn() - 1,
                                clusterName);
                    }

                    wFilenameList.getActiveTableItem().setText(wFilenameList.getActiveTableColumn(), url);
                }
            } catch (KettleFileException ex) {
                log.logError(
                        BaseMessages.getString(PKG, "HadoopFileInputDialog.FileBrowser.KettleFileException"));
            } catch (FileSystemException ex) {
                log.logError(
                        BaseMessages.getString(PKG, "HadoopFileInputDialog.FileBrowser.FileSystemException"));
            }
        }
    };
}

---

From source file:org.pentaho.big.data.kettle.plugins.hdfs.trans.HadoopFileOutputDialog.java

public String open() {
    Shell parent = getParent();//  www  .  jav  a  2  s  .co m
    Display display = parent.getDisplay();

    shell = new Shell(parent, SWT.DIALOG_TRIM | SWT.RESIZE | SWT.MAX | SWT.MIN);
    props.setLook(shell);
    setShellImage(shell, input);

    ModifyListener lsMod = new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            input.setChanged();
        }
    };
    changed = input.hasChanged();

    FormLayout formLayout = new FormLayout();
    formLayout.marginWidth = Const.FORM_MARGIN;
    formLayout.marginHeight = Const.FORM_MARGIN;

    shell.setLayout(formLayout);
    shell.setText(BaseMessages.getString(PKG, "HadoopFileOutputDialog.DialogTitle"));

    int middle = props.getMiddlePct();
    int margin = Const.MARGIN;

    // Stepname line
    wlStepname = new Label(shell, SWT.RIGHT);
    wlStepname.setText(BaseMessages.getString(BASE_PKG, "System.Label.StepName"));
    props.setLook(wlStepname);
    fdlStepname = new FormData();
    fdlStepname.left = new FormAttachment(0, 0);
    fdlStepname.top = new FormAttachment(0, margin);
    fdlStepname.right = new FormAttachment(middle, -margin);
    wlStepname.setLayoutData(fdlStepname);
    wStepname = new Text(shell, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
    wStepname.setText(stepname);
    props.setLook(wStepname);
    wStepname.addModifyListener(lsMod);
    fdStepname = new FormData();
    fdStepname.left = new FormAttachment(middle, 0);
    fdStepname.top = new FormAttachment(0, margin);
    fdStepname.right = new FormAttachment(100, 0);
    wStepname.setLayoutData(fdStepname);

    wTabFolder = new CTabFolder(shell, SWT.BORDER);
    props.setLook(wTabFolder, Props.WIDGET_STYLE_TAB);
    wTabFolder.setSimple(false);

    // ////////////////////////
    // START OF FILE TAB///
    // /
    wFileTab = new CTabItem(wTabFolder, SWT.NONE);
    wFileTab.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.FileTab.TabTitle"));

    Composite wFileComp = new Composite(wTabFolder, SWT.NONE);
    props.setLook(wFileComp);

    FormLayout fileLayout = new FormLayout();
    fileLayout.marginWidth = 3;
    fileLayout.marginHeight = 3;
    wFileComp.setLayout(fileLayout);

    namedClusterWidget = new NamedClusterWidgetImpl(wFileComp, true, namedClusterService,
            runtimeTestActionService, runtimeTester);
    namedClusterWidget.initiate();
    props.setLook(namedClusterWidget);
    FormData fd = new FormData();
    fd.right = new FormAttachment(100, 0);
    fd.top = new FormAttachment(0, 0);
    fd.left = new FormAttachment(0, 235);
    namedClusterWidget.setLayoutData(fd);

    namedClusterWidget.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent evt) {
            String ncName = ((Combo) evt.getSource()).getText();
            NamedCluster nc = namedClusterService.getNamedClusterByName(ncName, getMetaStore());
            if (nc != null) {
                HadoopFileOutputMeta meta = (HadoopFileOutputMeta) input;
                meta.setSourceConfigurationName(nc.getName());
            }
        }
    });

    // Filename line
    wlFilename = new Label(wFileComp, SWT.RIGHT);
    wlFilename.setText(BaseMessages.getString(PKG, "HadoopFileOutputDialog.Filename.Label"));
    props.setLook(wlFilename);
    fdlFilename = new FormData();
    fdlFilename.left = new FormAttachment(0, 0);
    fdlFilename.top = new FormAttachment(namedClusterWidget, margin);
    fdlFilename.right = new FormAttachment(middle, -margin);
    wlFilename.setLayoutData(fdlFilename);

    wbFilename = new Button(wFileComp, SWT.PUSH | SWT.CENTER);
    props.setLook(wbFilename);
    wbFilename.setText(BaseMessages.getString(BASE_PKG, "System.Button.Browse"));
    fdbFilename = new FormData();
    fdbFilename.right = new FormAttachment(100, 0);
    fdbFilename.top = new FormAttachment(namedClusterWidget, 0);
    wbFilename.setLayoutData(fdbFilename);

    wFilename = new TextVar(transMeta, wFileComp, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
    props.setLook(wFilename);
    wFilename.addModifyListener(lsMod);
    fdFilename = new FormData();
    fdFilename.left = new FormAttachment(middle, 0);
    fdFilename.top = new FormAttachment(namedClusterWidget, margin);
    fdFilename.right = new FormAttachment(wbFilename, -margin);
    wFilename.setLayoutData(fdFilename);

    // Create Parent Folder
    wlCreateParentFolder = new Label(wFileComp, SWT.RIGHT);
    wlCreateParentFolder
            .setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.CreateParentFolder.Label"));
    props.setLook(wlCreateParentFolder);
    fdlCreateParentFolder = new FormData();
    fdlCreateParentFolder.left = new FormAttachment(0, 0);
    fdlCreateParentFolder.top = new FormAttachment(wFilename, margin);
    fdlCreateParentFolder.right = new FormAttachment(middle, -margin);
    wlCreateParentFolder.setLayoutData(fdlCreateParentFolder);
    wCreateParentFolder = new Button(wFileComp, SWT.CHECK);
    wCreateParentFolder.setToolTipText(
            BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.CreateParentFolder.Tooltip"));
    props.setLook(wCreateParentFolder);
    fdCreateParentFolder = new FormData();
    fdCreateParentFolder.left = new FormAttachment(middle, 0);
    fdCreateParentFolder.top = new FormAttachment(wFilename, margin);
    fdCreateParentFolder.right = new FormAttachment(100, 0);
    wCreateParentFolder.setLayoutData(fdCreateParentFolder);
    wCreateParentFolder.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    // Open new File at Init
    wlDoNotOpenNewFileInit = new Label(wFileComp, SWT.RIGHT);
    wlDoNotOpenNewFileInit
            .setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.DoNotOpenNewFileInit.Label"));
    props.setLook(wlDoNotOpenNewFileInit);
    fdlDoNotOpenNewFileInit = new FormData();
    fdlDoNotOpenNewFileInit.left = new FormAttachment(0, 0);
    fdlDoNotOpenNewFileInit.top = new FormAttachment(wCreateParentFolder, margin);
    fdlDoNotOpenNewFileInit.right = new FormAttachment(middle, -margin);
    wlDoNotOpenNewFileInit.setLayoutData(fdlDoNotOpenNewFileInit);
    wDoNotOpenNewFileInit = new Button(wFileComp, SWT.CHECK);
    wDoNotOpenNewFileInit.setToolTipText(
            BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.DoNotOpenNewFileInit.Tooltip"));
    props.setLook(wDoNotOpenNewFileInit);
    fdDoNotOpenNewFileInit = new FormData();
    fdDoNotOpenNewFileInit.left = new FormAttachment(middle, 0);
    fdDoNotOpenNewFileInit.top = new FormAttachment(wCreateParentFolder, margin);
    fdDoNotOpenNewFileInit.right = new FormAttachment(100, 0);
    wDoNotOpenNewFileInit.setLayoutData(fdDoNotOpenNewFileInit);
    wDoNotOpenNewFileInit.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    /* next Lines */
    // FileNameInField line
    wlFileNameInField = new Label(wFileComp, SWT.RIGHT);
    wlFileNameInField.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.FileNameInField.Label"));
    props.setLook(wlFileNameInField);
    fdlFileNameInField = new FormData();
    fdlFileNameInField.left = new FormAttachment(0, 0);
    fdlFileNameInField.top = new FormAttachment(wDoNotOpenNewFileInit, margin);
    fdlFileNameInField.right = new FormAttachment(middle, -margin);
    wlFileNameInField.setLayoutData(fdlFileNameInField);
    wFileNameInField = new Button(wFileComp, SWT.CHECK);
    props.setLook(wFileNameInField);
    fdFileNameInField = new FormData();
    fdFileNameInField.left = new FormAttachment(middle, 0);
    fdFileNameInField.top = new FormAttachment(wDoNotOpenNewFileInit, margin);
    fdFileNameInField.right = new FormAttachment(100, 0);
    wFileNameInField.setLayoutData(fdFileNameInField);
    wFileNameInField.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
            activeFileNameField();
        }
    });

    // FileNameField Line
    wlFileNameField = new Label(wFileComp, SWT.RIGHT);
    wlFileNameField.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.FileNameField.Label")); //$NON-NLS-1$
    props.setLook(wlFileNameField);
    fdlFileNameField = new FormData();
    fdlFileNameField.left = new FormAttachment(0, 0);
    fdlFileNameField.right = new FormAttachment(middle, -margin);
    fdlFileNameField.top = new FormAttachment(wFileNameInField, margin);
    wlFileNameField.setLayoutData(fdlFileNameField);

    wFileNameField = new ComboVar(transMeta, wFileComp, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
    props.setLook(wFileNameField);
    wFileNameField.addModifyListener(lsMod);
    fdFileNameField = new FormData();
    fdFileNameField.left = new FormAttachment(middle, 0);
    fdFileNameField.top = new FormAttachment(wFileNameInField, margin);
    fdFileNameField.right = new FormAttachment(100, 0);
    wFileNameField.setLayoutData(fdFileNameField);
    wFileNameField.setEnabled(false);
    wFileNameField.addFocusListener(new FocusListener() {
        public void focusLost(org.eclipse.swt.events.FocusEvent e) {
        }

        public void focusGained(org.eclipse.swt.events.FocusEvent e) {
            Cursor busy = new Cursor(shell.getDisplay(), SWT.CURSOR_WAIT);
            shell.setCursor(busy);
            getFields();
            shell.setCursor(null);
            busy.dispose();
        }
    });
    /* End */

    // Extension line
    wlExtension = new Label(wFileComp, SWT.RIGHT);
    wlExtension.setText(BaseMessages.getString(BASE_PKG, "System.Label.Extension"));
    props.setLook(wlExtension);
    fdlExtension = new FormData();
    fdlExtension.left = new FormAttachment(0, 0);
    fdlExtension.top = new FormAttachment(wFileNameField, margin);
    fdlExtension.right = new FormAttachment(middle, -margin);
    wlExtension.setLayoutData(fdlExtension);
    wExtension = new TextVar(transMeta, wFileComp, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
    wExtension.setText("");
    props.setLook(wExtension);
    wExtension.addModifyListener(lsMod);
    fdExtension = new FormData();
    fdExtension.left = new FormAttachment(middle, 0);
    fdExtension.top = new FormAttachment(wFileNameField, margin);
    fdExtension.right = new FormAttachment(100, 0);
    wExtension.setLayoutData(fdExtension);

    // Create multi-part file?
    wlAddStepnr = new Label(wFileComp, SWT.RIGHT);
    wlAddStepnr.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.AddStepnr.Label"));
    props.setLook(wlAddStepnr);
    fdlAddStepnr = new FormData();
    fdlAddStepnr.left = new FormAttachment(0, 0);
    fdlAddStepnr.top = new FormAttachment(wExtension, margin);
    fdlAddStepnr.right = new FormAttachment(middle, -margin);
    wlAddStepnr.setLayoutData(fdlAddStepnr);
    wAddStepnr = new Button(wFileComp, SWT.CHECK);
    props.setLook(wAddStepnr);
    fdAddStepnr = new FormData();
    fdAddStepnr.left = new FormAttachment(middle, 0);
    fdAddStepnr.top = new FormAttachment(wExtension, margin);
    fdAddStepnr.right = new FormAttachment(100, 0);
    wAddStepnr.setLayoutData(fdAddStepnr);
    wAddStepnr.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    // Create multi-part file?
    wlAddPartnr = new Label(wFileComp, SWT.RIGHT);
    wlAddPartnr.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.AddPartnr.Label"));
    props.setLook(wlAddPartnr);
    fdlAddPartnr = new FormData();
    fdlAddPartnr.left = new FormAttachment(0, 0);
    fdlAddPartnr.top = new FormAttachment(wAddStepnr, margin);
    fdlAddPartnr.right = new FormAttachment(middle, -margin);
    wlAddPartnr.setLayoutData(fdlAddPartnr);
    wAddPartnr = new Button(wFileComp, SWT.CHECK);
    props.setLook(wAddPartnr);
    fdAddPartnr = new FormData();
    fdAddPartnr.left = new FormAttachment(middle, 0);
    fdAddPartnr.top = new FormAttachment(wAddStepnr, margin);
    fdAddPartnr.right = new FormAttachment(100, 0);
    wAddPartnr.setLayoutData(fdAddPartnr);
    wAddPartnr.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    // Create multi-part file?
    wlAddDate = new Label(wFileComp, SWT.RIGHT);
    wlAddDate.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.AddDate.Label"));
    props.setLook(wlAddDate);
    fdlAddDate = new FormData();
    fdlAddDate.left = new FormAttachment(0, 0);
    fdlAddDate.top = new FormAttachment(wAddPartnr, margin);
    fdlAddDate.right = new FormAttachment(middle, -margin);
    wlAddDate.setLayoutData(fdlAddDate);
    wAddDate = new Button(wFileComp, SWT.CHECK);
    props.setLook(wAddDate);
    fdAddDate = new FormData();
    fdAddDate.left = new FormAttachment(middle, 0);
    fdAddDate.top = new FormAttachment(wAddPartnr, margin);
    fdAddDate.right = new FormAttachment(100, 0);
    wAddDate.setLayoutData(fdAddDate);
    wAddDate.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
            // System.out.println("wAddDate.getSelection()="+wAddDate.getSelection());
        }
    });
    // Create multi-part file?
    wlAddTime = new Label(wFileComp, SWT.RIGHT);
    wlAddTime.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.AddTime.Label"));
    props.setLook(wlAddTime);
    fdlAddTime = new FormData();
    fdlAddTime.left = new FormAttachment(0, 0);
    fdlAddTime.top = new FormAttachment(wAddDate, margin);
    fdlAddTime.right = new FormAttachment(middle, -margin);
    wlAddTime.setLayoutData(fdlAddTime);
    wAddTime = new Button(wFileComp, SWT.CHECK);
    props.setLook(wAddTime);
    fdAddTime = new FormData();
    fdAddTime.left = new FormAttachment(middle, 0);
    fdAddTime.top = new FormAttachment(wAddDate, margin);
    fdAddTime.right = new FormAttachment(100, 0);
    wAddTime.setLayoutData(fdAddTime);
    wAddTime.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    // Specify date time format?
    wlSpecifyFormat = new Label(wFileComp, SWT.RIGHT);
    wlSpecifyFormat.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.SpecifyFormat.Label"));
    props.setLook(wlSpecifyFormat);
    fdlSpecifyFormat = new FormData();
    fdlSpecifyFormat.left = new FormAttachment(0, 0);
    fdlSpecifyFormat.top = new FormAttachment(wAddTime, margin);
    fdlSpecifyFormat.right = new FormAttachment(middle, -margin);
    wlSpecifyFormat.setLayoutData(fdlSpecifyFormat);
    wSpecifyFormat = new Button(wFileComp, SWT.CHECK);
    props.setLook(wSpecifyFormat);
    wSpecifyFormat
            .setToolTipText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.SpecifyFormat.Tooltip"));
    fdSpecifyFormat = new FormData();
    fdSpecifyFormat.left = new FormAttachment(middle, 0);
    fdSpecifyFormat.top = new FormAttachment(wAddTime, margin);
    fdSpecifyFormat.right = new FormAttachment(100, 0);
    wSpecifyFormat.setLayoutData(fdSpecifyFormat);
    wSpecifyFormat.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
            setDateTimeFormat();
        }
    });

    // DateTimeFormat
    wlDateTimeFormat = new Label(wFileComp, SWT.RIGHT);
    wlDateTimeFormat.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.DateTimeFormat.Label"));
    props.setLook(wlDateTimeFormat);
    fdlDateTimeFormat = new FormData();
    fdlDateTimeFormat.left = new FormAttachment(0, 0);
    fdlDateTimeFormat.top = new FormAttachment(wSpecifyFormat, margin);
    fdlDateTimeFormat.right = new FormAttachment(middle, -margin);
    wlDateTimeFormat.setLayoutData(fdlDateTimeFormat);
    wDateTimeFormat = new CCombo(wFileComp, SWT.BORDER | SWT.READ_ONLY);
    wDateTimeFormat.setEditable(true);
    props.setLook(wDateTimeFormat);
    wDateTimeFormat.addModifyListener(lsMod);
    fdDateTimeFormat = new FormData();
    fdDateTimeFormat.left = new FormAttachment(middle, 0);
    fdDateTimeFormat.top = new FormAttachment(wSpecifyFormat, margin);
    fdDateTimeFormat.right = new FormAttachment(100, 0);
    wDateTimeFormat.setLayoutData(fdDateTimeFormat);
    String[] dates = Const.getDateFormats();
    fillWithSupportedDateFormats(wDateTimeFormat, dates);
    wbShowFiles = new Button(wFileComp, SWT.PUSH | SWT.CENTER);
    props.setLook(wbShowFiles);
    wbShowFiles.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.ShowFiles.Button"));
    fdbShowFiles = new FormData();
    fdbShowFiles.left = new FormAttachment(middle, 0);
    fdbShowFiles.top = new FormAttachment(wDateTimeFormat, margin * 2);
    wbShowFiles.setLayoutData(fdbShowFiles);
    wbShowFiles.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            HadoopFileOutputMeta tfoi = new HadoopFileOutputMeta(namedClusterService, runtimeTestActionService,
                    runtimeTester);
            getInfo(tfoi);
            String[] files = tfoi.getFiles(transMeta);
            if (files != null && files.length > 0) {
                EnterSelectionDialog esd = new EnterSelectionDialog(shell, files,
                        BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.SelectOutputFiles.DialogTitle"),
                        BaseMessages.getString(BASE_PKG,
                                "TextFileOutputDialog.SelectOutputFiles.DialogMessage"));
                esd.setViewOnly();
                esd.open();
            } else {
                MessageBox mb = new MessageBox(shell, SWT.OK | SWT.ICON_ERROR);
                mb.setMessage(
                        BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.NoFilesFound.DialogMessage"));
                mb.setText(BaseMessages.getString(BASE_PKG, "System.Dialog.Error.Title"));
                mb.open();
            }
        }
    });

    // Add File to the result files name
    wlAddToResult = new Label(wFileComp, SWT.RIGHT);
    wlAddToResult.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.AddFileToResult.Label"));
    props.setLook(wlAddToResult);
    fdlAddToResult = new FormData();
    fdlAddToResult.left = new FormAttachment(0, 0);
    fdlAddToResult.top = new FormAttachment(wbShowFiles, 2 * margin);
    fdlAddToResult.right = new FormAttachment(middle, -margin);
    wlAddToResult.setLayoutData(fdlAddToResult);
    wAddToResult = new Button(wFileComp, SWT.CHECK);
    wAddToResult
            .setToolTipText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.AddFileToResult.Tooltip"));
    props.setLook(wAddToResult);
    fdAddToResult = new FormData();
    fdAddToResult.left = new FormAttachment(middle, 0);
    fdAddToResult.top = new FormAttachment(wbShowFiles, 2 * margin);
    fdAddToResult.right = new FormAttachment(100, 0);
    wAddToResult.setLayoutData(fdAddToResult);
    SelectionAdapter lsSelR = new SelectionAdapter() {
        public void widgetSelected(SelectionEvent arg0) {
            input.setChanged();
        }
    };
    wAddToResult.addSelectionListener(lsSelR);

    fdFileComp = new FormData();
    fdFileComp.left = new FormAttachment(0, 0);
    fdFileComp.top = new FormAttachment(0, 0);
    fdFileComp.right = new FormAttachment(100, 0);
    fdFileComp.bottom = new FormAttachment(100, 0);
    wFileComp.setLayoutData(fdFileComp);

    wFileComp.layout();
    wFileTab.setControl(wFileComp);

    // ///////////////////////////////////////////////////////////
    // / END OF FILE TAB
    // ///////////////////////////////////////////////////////////

    // ////////////////////////
    // START OF CONTENT TAB///
    // /
    wContentTab = new CTabItem(wTabFolder, SWT.NONE);
    wContentTab.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.ContentTab.TabTitle"));

    FormLayout contentLayout = new FormLayout();
    contentLayout.marginWidth = 3;
    contentLayout.marginHeight = 3;

    Composite wContentComp = new Composite(wTabFolder, SWT.NONE);
    props.setLook(wContentComp);
    wContentComp.setLayout(contentLayout);

    // Append to end of file?
    wlAppend = new Label(wContentComp, SWT.RIGHT);
    wlAppend.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Append.Label"));
    props.setLook(wlAppend);
    fdlAppend = new FormData();
    fdlAppend.left = new FormAttachment(0, 0);
    fdlAppend.top = new FormAttachment(0, 0);
    fdlAppend.right = new FormAttachment(middle, -margin);
    wlAppend.setLayoutData(fdlAppend);
    wAppend = new Button(wContentComp, SWT.CHECK);
    props.setLook(wAppend);
    fdAppend = new FormData();
    fdAppend.left = new FormAttachment(middle, 0);
    fdAppend.top = new FormAttachment(0, 0);
    fdAppend.right = new FormAttachment(100, 0);
    wAppend.setLayoutData(fdAppend);
    wAppend.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    wlSeparator = new Label(wContentComp, SWT.RIGHT);
    wlSeparator.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Separator.Label"));
    props.setLook(wlSeparator);
    fdlSeparator = new FormData();
    fdlSeparator.left = new FormAttachment(0, 0);
    fdlSeparator.top = new FormAttachment(wAppend, margin);
    fdlSeparator.right = new FormAttachment(middle, -margin);
    wlSeparator.setLayoutData(fdlSeparator);

    wbSeparator = new Button(wContentComp, SWT.PUSH | SWT.CENTER);
    props.setLook(wbSeparator);
    wbSeparator.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Separator.Button"));
    fdbSeparator = new FormData();
    fdbSeparator.right = new FormAttachment(100, 0);
    fdbSeparator.top = new FormAttachment(wAppend, 0);
    wbSeparator.setLayoutData(fdbSeparator);
    wbSeparator.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent se) {
            // wSeparator.insert("\t");
            wSeparator.getTextWidget().insert("\t");
        }
    });

    wSeparator = new TextVar(transMeta, wContentComp, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
    props.setLook(wSeparator);
    wSeparator.addModifyListener(lsMod);
    fdSeparator = new FormData();
    fdSeparator.left = new FormAttachment(middle, 0);
    fdSeparator.top = new FormAttachment(wAppend, margin);
    fdSeparator.right = new FormAttachment(wbSeparator, -margin);
    wSeparator.setLayoutData(fdSeparator);

    // Enclosure line...
    wlEnclosure = new Label(wContentComp, SWT.RIGHT);
    wlEnclosure.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Enclosure.Label"));
    props.setLook(wlEnclosure);
    fdlEnclosure = new FormData();
    fdlEnclosure.left = new FormAttachment(0, 0);
    fdlEnclosure.top = new FormAttachment(wSeparator, margin);
    fdlEnclosure.right = new FormAttachment(middle, -margin);
    wlEnclosure.setLayoutData(fdlEnclosure);
    wEnclosure = new TextVar(transMeta, wContentComp, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
    props.setLook(wEnclosure);
    wEnclosure.addModifyListener(lsMod);
    fdEnclosure = new FormData();
    fdEnclosure.left = new FormAttachment(middle, 0);
    fdEnclosure.top = new FormAttachment(wSeparator, margin);
    fdEnclosure.right = new FormAttachment(100, 0);
    wEnclosure.setLayoutData(fdEnclosure);

    wlEnclForced = new Label(wContentComp, SWT.RIGHT);
    wlEnclForced.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.EnclForced.Label"));
    props.setLook(wlEnclForced);
    fdlEnclForced = new FormData();
    fdlEnclForced.left = new FormAttachment(0, 0);
    fdlEnclForced.top = new FormAttachment(wEnclosure, margin);
    fdlEnclForced.right = new FormAttachment(middle, -margin);
    wlEnclForced.setLayoutData(fdlEnclForced);
    wEnclForced = new Button(wContentComp, SWT.CHECK);
    props.setLook(wEnclForced);
    fdEnclForced = new FormData();
    fdEnclForced.left = new FormAttachment(middle, 0);
    fdEnclForced.top = new FormAttachment(wEnclosure, margin);
    fdEnclForced.right = new FormAttachment(100, 0);
    wEnclForced.setLayoutData(fdEnclForced);
    wEnclForced.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    wlHeader = new Label(wContentComp, SWT.RIGHT);
    wlHeader.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Header.Label"));
    props.setLook(wlHeader);
    fdlHeader = new FormData();
    fdlHeader.left = new FormAttachment(0, 0);
    fdlHeader.top = new FormAttachment(wEnclForced, margin);
    fdlHeader.right = new FormAttachment(middle, -margin);
    wlHeader.setLayoutData(fdlHeader);
    wHeader = new Button(wContentComp, SWT.CHECK);
    props.setLook(wHeader);
    fdHeader = new FormData();
    fdHeader.left = new FormAttachment(middle, 0);
    fdHeader.top = new FormAttachment(wEnclForced, margin);
    fdHeader.right = new FormAttachment(100, 0);
    wHeader.setLayoutData(fdHeader);
    wHeader.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    wlFooter = new Label(wContentComp, SWT.RIGHT);
    wlFooter.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Footer.Label"));
    props.setLook(wlFooter);
    fdlFooter = new FormData();
    fdlFooter.left = new FormAttachment(0, 0);
    fdlFooter.top = new FormAttachment(wHeader, margin);
    fdlFooter.right = new FormAttachment(middle, -margin);
    wlFooter.setLayoutData(fdlFooter);
    wFooter = new Button(wContentComp, SWT.CHECK);
    props.setLook(wFooter);
    fdFooter = new FormData();
    fdFooter.left = new FormAttachment(middle, 0);
    fdFooter.top = new FormAttachment(wHeader, margin);
    fdFooter.right = new FormAttachment(100, 0);
    wFooter.setLayoutData(fdFooter);
    wFooter.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    wlFormat = new Label(wContentComp, SWT.RIGHT);
    wlFormat.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Format.Label"));
    props.setLook(wlFormat);
    fdlFormat = new FormData();
    fdlFormat.left = new FormAttachment(0, 0);
    fdlFormat.top = new FormAttachment(wFooter, margin);
    fdlFormat.right = new FormAttachment(middle, -margin);
    wlFormat.setLayoutData(fdlFormat);
    wFormat = new CCombo(wContentComp, SWT.BORDER | SWT.READ_ONLY);
    wFormat.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Format.Label"));
    props.setLook(wFormat);

    for (int i = 0; i < HadoopFileOutputMeta.formatMapperLineTerminator.length; i++) {
        wFormat.add(BaseMessages.getString(BASE_PKG,
                "TextFileOutputDialog.Format." + HadoopFileOutputMeta.formatMapperLineTerminator[i]));
    }
    wFormat.select(0);
    wFormat.addModifyListener(lsMod);
    fdFormat = new FormData();
    fdFormat.left = new FormAttachment(middle, 0);
    fdFormat.top = new FormAttachment(wFooter, margin);
    fdFormat.right = new FormAttachment(100, 0);
    wFormat.setLayoutData(fdFormat);

    wlCompression = new Label(wContentComp, SWT.RIGHT);
    wlCompression.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Compression.Label"));
    props.setLook(wlCompression);
    fdlCompression = new FormData();
    fdlCompression.left = new FormAttachment(0, 0);
    fdlCompression.top = new FormAttachment(wFormat, margin);
    fdlCompression.right = new FormAttachment(middle, -margin);
    wlCompression.setLayoutData(fdlCompression);
    wCompression = new CCombo(wContentComp, SWT.BORDER | SWT.READ_ONLY);
    wCompression.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Compression.Label"));
    props.setLook(wCompression);

    wCompression.setItems(CompressionProviderFactory.getInstance().getCompressionProviderNames());
    wCompression.addModifyListener(lsMod);
    fdCompression = new FormData();
    fdCompression.left = new FormAttachment(middle, 0);
    fdCompression.top = new FormAttachment(wFormat, margin);
    fdCompression.right = new FormAttachment(100, 0);
    wCompression.setLayoutData(fdCompression);

    wlEncoding = new Label(wContentComp, SWT.RIGHT);
    wlEncoding.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Encoding.Label"));
    props.setLook(wlEncoding);
    fdlEncoding = new FormData();
    fdlEncoding.left = new FormAttachment(0, 0);
    fdlEncoding.top = new FormAttachment(wCompression, margin);
    fdlEncoding.right = new FormAttachment(middle, -margin);
    wlEncoding.setLayoutData(fdlEncoding);
    wEncoding = new CCombo(wContentComp, SWT.BORDER | SWT.READ_ONLY);
    wEncoding.setEditable(true);
    props.setLook(wEncoding);
    wEncoding.addModifyListener(lsMod);
    fdEncoding = new FormData();
    fdEncoding.left = new FormAttachment(middle, 0);
    fdEncoding.top = new FormAttachment(wCompression, margin);
    fdEncoding.right = new FormAttachment(100, 0);
    wEncoding.setLayoutData(fdEncoding);
    wEncoding.addFocusListener(new FocusListener() {
        public void focusLost(org.eclipse.swt.events.FocusEvent e) {
        }

        public void focusGained(org.eclipse.swt.events.FocusEvent e) {
            Cursor busy = new Cursor(shell.getDisplay(), SWT.CURSOR_WAIT);
            shell.setCursor(busy);
            setEncodings();
            shell.setCursor(null);
            busy.dispose();
        }
    });

    wlPad = new Label(wContentComp, SWT.RIGHT);
    wlPad.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.Pad.Label"));
    props.setLook(wlPad);
    fdlPad = new FormData();
    fdlPad.left = new FormAttachment(0, 0);
    fdlPad.top = new FormAttachment(wEncoding, margin);
    fdlPad.right = new FormAttachment(middle, -margin);
    wlPad.setLayoutData(fdlPad);
    wPad = new Button(wContentComp, SWT.CHECK);
    props.setLook(wPad);
    fdPad = new FormData();
    fdPad.left = new FormAttachment(middle, 0);
    fdPad.top = new FormAttachment(wEncoding, margin);
    fdPad.right = new FormAttachment(100, 0);
    wPad.setLayoutData(fdPad);
    wPad.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    wlFastDump = new Label(wContentComp, SWT.RIGHT);
    wlFastDump.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.FastDump.Label"));
    props.setLook(wlFastDump);
    fdlFastDump = new FormData();
    fdlFastDump.left = new FormAttachment(0, 0);
    fdlFastDump.top = new FormAttachment(wPad, margin);
    fdlFastDump.right = new FormAttachment(middle, -margin);
    wlFastDump.setLayoutData(fdlFastDump);
    wFastDump = new Button(wContentComp, SWT.CHECK);
    props.setLook(wFastDump);
    fdFastDump = new FormData();
    fdFastDump.left = new FormAttachment(middle, 0);
    fdFastDump.top = new FormAttachment(wPad, margin);
    fdFastDump.right = new FormAttachment(100, 0);
    wFastDump.setLayoutData(fdFastDump);
    wFastDump.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            input.setChanged();
        }
    });

    wlSplitEvery = new Label(wContentComp, SWT.RIGHT);
    wlSplitEvery.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.SplitEvery.Label"));
    props.setLook(wlSplitEvery);
    fdlSplitEvery = new FormData();
    fdlSplitEvery.left = new FormAttachment(0, 0);
    fdlSplitEvery.top = new FormAttachment(wFastDump, margin);
    fdlSplitEvery.right = new FormAttachment(middle, -margin);
    wlSplitEvery.setLayoutData(fdlSplitEvery);
    wSplitEvery = new Text(wContentComp, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
    props.setLook(wSplitEvery);
    wSplitEvery.addModifyListener(lsMod);
    fdSplitEvery = new FormData();
    fdSplitEvery.left = new FormAttachment(middle, 0);
    fdSplitEvery.top = new FormAttachment(wFastDump, margin);
    fdSplitEvery.right = new FormAttachment(100, 0);
    wSplitEvery.setLayoutData(fdSplitEvery);

    // Bruise:
    wlEndedLine = new Label(wContentComp, SWT.RIGHT);
    wlEndedLine.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.EndedLine.Label"));
    props.setLook(wlEndedLine);
    fdlEndedLine = new FormData();
    fdlEndedLine.left = new FormAttachment(0, 0);
    fdlEndedLine.top = new FormAttachment(wSplitEvery, margin);
    fdlEndedLine.right = new FormAttachment(middle, -margin);
    wlEndedLine.setLayoutData(fdlEndedLine);
    wEndedLine = new Text(wContentComp, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
    props.setLook(wEndedLine);
    wEndedLine.addModifyListener(lsMod);
    fdEndedLine = new FormData();
    fdEndedLine.left = new FormAttachment(middle, 0);
    fdEndedLine.top = new FormAttachment(wSplitEvery, margin);
    fdEndedLine.right = new FormAttachment(100, 0);
    wEndedLine.setLayoutData(fdEndedLine);

    fdContentComp = new FormData();
    fdContentComp.left = new FormAttachment(0, 0);
    fdContentComp.top = new FormAttachment(0, 0);
    fdContentComp.right = new FormAttachment(100, 0);
    fdContentComp.bottom = new FormAttachment(100, 0);
    wContentComp.setLayoutData(fdContentComp);

    wContentComp.layout();
    wContentTab.setControl(wContentComp);

    // ///////////////////////////////////////////////////////////
    // / END OF CONTENT TAB
    // ///////////////////////////////////////////////////////////

    // Fields tab...
    //
    wFieldsTab = new CTabItem(wTabFolder, SWT.NONE);
    wFieldsTab.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.FieldsTab.TabTitle"));

    FormLayout fieldsLayout = new FormLayout();
    fieldsLayout.marginWidth = Const.FORM_MARGIN;
    fieldsLayout.marginHeight = Const.FORM_MARGIN;

    Composite wFieldsComp = new Composite(wTabFolder, SWT.NONE);
    wFieldsComp.setLayout(fieldsLayout);
    props.setLook(wFieldsComp);

    wGet = new Button(wFieldsComp, SWT.PUSH);
    wGet.setText(BaseMessages.getString(BASE_PKG, "System.Button.GetFields"));
    wGet.setToolTipText(BaseMessages.getString(BASE_PKG, "System.Tooltip.GetFields"));

    wMinWidth = new Button(wFieldsComp, SWT.PUSH);
    wMinWidth.setText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.MinWidth.Button"));
    wMinWidth.setToolTipText(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.MinWidth.Tooltip"));

    setButtonPositions(new Button[] { wGet, wMinWidth }, margin, null);

    final int FieldsCols = 10;
    final int FieldsRows = input.getOutputFields().length;

    // Prepare a list of possible formats...
    String[] nums = Const.getNumberFormats();
    int totsize = dates.length + nums.length;
    String[] formats = new String[totsize];
    for (int x = 0; x < dates.length; x++) {
        formats[x] = dates[x];
    }
    for (int x = 0; x < nums.length; x++) {
        formats[dates.length + x] = nums[x];
    }
    colinf = new ColumnInfo[FieldsCols];
    colinf[0] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.NameColumn.Column"),
            ColumnInfo.COLUMN_TYPE_CCOMBO, new String[] { "" }, false);
    colinf[1] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.TypeColumn.Column"),
            ColumnInfo.COLUMN_TYPE_CCOMBO, ValueMetaBase.getTypes());
    colinf[2] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.FormatColumn.Column"),
            ColumnInfo.COLUMN_TYPE_CCOMBO, formats);
    colinf[3] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.LengthColumn.Column"),
            ColumnInfo.COLUMN_TYPE_TEXT, false);
    colinf[4] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.PrecisionColumn.Column"),
            ColumnInfo.COLUMN_TYPE_TEXT, false);
    colinf[5] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.CurrencyColumn.Column"),
            ColumnInfo.COLUMN_TYPE_TEXT, false);
    colinf[6] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.DecimalColumn.Column"),
            ColumnInfo.COLUMN_TYPE_TEXT, false);
    colinf[7] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.GroupColumn.Column"),
            ColumnInfo.COLUMN_TYPE_TEXT, false);
    colinf[8] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.TrimTypeColumn.Column"),
            ColumnInfo.COLUMN_TYPE_CCOMBO, ValueMetaBase.trimTypeDesc, true);
    colinf[9] = new ColumnInfo(BaseMessages.getString(BASE_PKG, "TextFileOutputDialog.NullColumn.Column"),
            ColumnInfo.COLUMN_TYPE_TEXT, false);

    wFields = new TableView(transMeta, wFieldsComp, SWT.BORDER | SWT.FULL_SELECTION | SWT.MULTI, colinf,
            FieldsRows, lsMod, props);

    fdFields = new FormData();
    fdFields.left = new FormAttachment(0, 0);
    fdFields.top = new FormAttachment(0, 0);
    fdFields.right = new FormAttachment(100, 0);
    fdFields.bottom = new FormAttachment(wGet, -margin);
    wFields.setLayoutData(fdFields);

    //
    // Search the fields in the background

    final Runnable runnable = new Runnable() {
        public void run() {
            StepMeta stepMeta = transMeta.findStep(stepname);
            if (stepMeta != null) {
                try {
                    RowMetaInterface row = transMeta.getPrevStepFields(stepMeta);

                    // Remember these fields...
                    for (int i = 0; i < row.size(); i++) {
                        inputFields.put(row.getValueMeta(i).getName(), Integer.valueOf(i));
                    }
                    setComboBoxes();
                } catch (KettleException e) {
                    logError(BaseMessages.getString(BASE_PKG, "System.Dialog.GetFieldsFailed.Message"));
                }
            }
        }
    };
    new Thread(runnable).start();

    fdFieldsComp = new FormData();
    fdFieldsComp.left = new FormAttachment(0, 0);
    fdFieldsComp.top = new FormAttachment(0, 0);
    fdFieldsComp.right = new FormAttachment(100, 0);
    fdFieldsComp.bottom = new FormAttachment(100, 0);
    wFieldsComp.setLayoutData(fdFieldsComp);

    wFieldsComp.layout();
    wFieldsTab.setControl(wFieldsComp);

    fdTabFolder = new FormData();
    fdTabFolder.left = new FormAttachment(0, 0);
    fdTabFolder.top = new FormAttachment(wStepname, margin);
    fdTabFolder.right = new FormAttachment(100, 0);
    fdTabFolder.bottom = new FormAttachment(100, -50);
    wTabFolder.setLayoutData(fdTabFolder);

    wOK = new Button(shell, SWT.PUSH);
    wOK.setText(BaseMessages.getString(BASE_PKG, "System.Button.OK"));

    wCancel = new Button(shell, SWT.PUSH);
    wCancel.setText(BaseMessages.getString(BASE_PKG, "System.Button.Cancel"));

    positionBottomRightButtons(shell, new Button[] { wOK, wCancel }, margin, wTabFolder);

    // Add listeners
    lsOK = new Listener() {
        public void handleEvent(Event e) {
            ok();
        }
    };
    lsGet = new Listener() {
        public void handleEvent(Event e) {
            get();
        }
    };
    lsMinWidth = new Listener() {
        public void handleEvent(Event e) {
            setMinimalWidth();
        }
    };
    lsCancel = new Listener() {
        public void handleEvent(Event e) {
            cancel();
        }
    };

    wOK.addListener(SWT.Selection, lsOK);
    wGet.addListener(SWT.Selection, lsGet);
    wMinWidth.addListener(SWT.Selection, lsMinWidth);
    wCancel.addListener(SWT.Selection, lsCancel);

    lsDef = new SelectionAdapter() {
        public void widgetDefaultSelected(SelectionEvent e) {
            ok();
        }
    };

    wStepname.addSelectionListener(lsDef);
    wFilename.addSelectionListener(lsDef);
    wSeparator.addSelectionListener(lsDef);

    // Whenever something changes, set the tooltip to the expanded version:
    wFilename.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            wFilename.setToolTipText(transMeta.environmentSubstitute(wFilename.getText()));
        }
    });

    // Listen to the Browse... button
    wbFilename.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            try {
                // Setup file type filtering
                String[] fileFilters = new String[] { "*.txt", "*.csv", "*" };
                String[] fileFilterNames = new String[] {
                        BaseMessages.getString(BASE_PKG, "System.FileType.TextFiles"),
                        BaseMessages.getString(BASE_PKG, "System.FileType.CSVFiles"),
                        BaseMessages.getString(BASE_PKG, "System.FileType.AllFiles") };

                NamedCluster namedCluster = namedClusterWidget.getSelectedNamedCluster();
                if (namedCluster == null) {
                    return;
                }

                String path = wFilename.getText();

                // Get current file
                FileObject rootFile = null;
                FileObject initialFile = null;
                FileObject defaultInitialFile = null;

                if (Utils.isEmpty(path)) {
                    path = "/";
                }
                path = namedCluster.processURLsubstitution(path, getMetaStore(), transMeta);

                boolean resolvedInitialFile = false;

                if (path != null) {

                    String fileName = transMeta.environmentSubstitute(path);

                    if (fileName != null && !fileName.equals("")) {
                        try {
                            initialFile = KettleVFS.getFileObject(fileName);
                            resolvedInitialFile = true;
                        } catch (Exception ex) {
                            showMessageAndLog(
                                    BaseMessages.getString(PKG,
                                            "HadoopFileOutputDialog.Connection.Error.title"),
                                    BaseMessages.getString(PKG, "HadoopFileOutputDialog.Connection.error"),
                                    ex.getMessage());
                            return;
                        }
                        File startFile = new File(System.getProperty("user.home"));
                        defaultInitialFile = KettleVFS.getFileObject(startFile.getAbsolutePath());
                        rootFile = initialFile.getFileSystem().getRoot();
                    } else {
                        defaultInitialFile = KettleVFS.getFileObject(Spoon.getInstance().getLastFileOpened());
                    }
                }

                if (rootFile == null) {
                    if (defaultInitialFile == null) {
                        return;
                    }
                    rootFile = defaultInitialFile.getFileSystem().getRoot();
                    initialFile = defaultInitialFile;
                }

                VfsFileChooserDialog fileChooserDialog = Spoon.getInstance().getVfsFileChooserDialog(rootFile,
                        initialFile);
                fileChooserDialog.defaultInitialFile = defaultInitialFile;
                FileObject selectedFile = null;

                if (namedCluster != null) {
                    if (namedCluster.isMapr()) {
                        selectedFile = fileChooserDialog.open(shell, new String[] { Schemes.MAPRFS_SCHEME },
                                Schemes.MAPRFS_SCHEME, true, path, fileFilters, fileFilterNames, true,
                                VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, false);
                    } else {
                        List<CustomVfsUiPanel> customPanels = fileChooserDialog.getCustomVfsUiPanels();
                        String ncName = null;
                        HadoopVfsFileChooserDialog hadoopDialog = null;
                        for (CustomVfsUiPanel panel : customPanels) {
                            if (panel instanceof HadoopVfsFileChooserDialog) {
                                hadoopDialog = ((HadoopVfsFileChooserDialog) panel);
                                NamedClusterWidgetImpl ncWidget = hadoopDialog.getNamedClusterWidget();
                                ncWidget.initiate();
                                ncName = null;
                                if (initialFile != null) {
                                    HadoopFileOutputMeta meta = (HadoopFileOutputMeta) input;
                                    ncName = meta.getSourceConfigurationName();
                                }
                                hadoopDialog.setNamedCluster(ncName);
                                hadoopDialog.initializeConnectionPanel(initialFile);
                            }
                        }
                        if (resolvedInitialFile) {
                            fileChooserDialog.initialFile = initialFile;
                        }
                        selectedFile = fileChooserDialog.open(shell, new String[] { Schemes.HDFS_SCHEME },
                                Schemes.HDFS_SCHEME, true, path, fileFilters, fileFilterNames, true,
                                VfsFileChooserDialog.VFS_DIALOG_OPEN_FILE_OR_DIRECTORY, false, false);
                    }
                }

                if (selectedFile != null) {
                    String filename = selectedFile.getURL().toString();

                    String extension = wExtension.getText();
                    if (extension != null && filename.endsWith("." + extension)) {
                        // The extension is filled in and matches the end
                        // of the selected file => Strip off the extension.
                        wFilename.setText(getUrlPath(
                                filename.substring(0, filename.length() - (extension.length() + 1))));
                    } else {
                        wFilename.setText(getUrlPath(filename));
                    }
                }
            } catch (KettleFileException ex) {
                log.logError(
                        BaseMessages.getString(PKG, "HadoopFileInputDialog.FileBrowser.KettleFileException"));
            } catch (FileSystemException ex) {
                log.logError(
                        BaseMessages.getString(PKG, "HadoopFileInputDialog.FileBrowser.FileSystemException"));
            }
        }
    });

    // Detect X or ALT-F4 or something that kills this window...
    shell.addShellListener(new ShellAdapter() {
        public void shellClosed(ShellEvent e) {
            cancel();
        }
    });

    lsResize = new Listener() {
        public void handleEvent(Event event) {
            Point size = shell.getSize();
            wFields.setSize(size.x - 10, size.y - 50);
            wFields.table.setSize(size.x - 10, size.y - 50);
            wFields.redraw();
        }
    };
    shell.addListener(SWT.Resize, lsResize);

    wTabFolder.setSelection(0);

    // Set the shell size, based upon previous time...
    setSize();

    getData();
    activeFileNameField();
    enableParentFolder();

    shell.open();
    while (!shell.isDisposed()) {
        if (!display.readAndDispatch()) {
            display.sleep();
        }
    }
    return stepname;
}

---

From source file:org.pentaho.big.data.kettle.plugins.job.AbstractJobEntryController.java

protected FileObject browseVfs(FileObject root, FileObject initial, int dialogMode, String[] schemeRestrictions,
        boolean showFileScheme, String defaultScheme, NamedCluster namedCluster, boolean showLocation,
        boolean showCustomUI) throws KettleFileException {
    if (initial == null) {
        initial = KettleVFS.getFileObject(Spoon.getInstance().getLastFileOpened());
    }/*from  w ww . j ava 2  s .  com*/
    if (root == null) {
        try {
            root = initial.getFileSystem().getRoot();
        } catch (FileSystemException e) {
            throw new KettleFileException(e);
        }
    }

    VfsFileChooserHelper fileChooserHelper = new VfsFileChooserHelper(getShell(),
            Spoon.getInstance().getVfsFileChooserDialog(root, initial), jobEntry);
    fileChooserHelper.setDefaultScheme(defaultScheme);
    fileChooserHelper.setSchemeRestrictions(schemeRestrictions);
    fileChooserHelper.setShowFileScheme(showFileScheme);
    if (namedCluster != null) {
        fileChooserHelper.setNamedCluster(namedCluster);
    }
    try {
        return fileChooserHelper.browse(getFileFilters(), getFileFilterNames(), initial.getName().getURI(),
                dialogMode, showLocation, showCustomUI);
    } catch (KettleException e) {
        throw new KettleFileException(e);
    } catch (FileSystemException e) {
        throw new KettleFileException(e);
    }
}

---

From source file:org.pentaho.big.data.plugins.common.ui.VfsFileChooserHelper.java

public FileObject browse(String[] fileFilters, String[] fileFilterNames, String fileUri, FileSystemOptions opts,
        int fileDialogMode, boolean showLocation, boolean showCustomUI)
        throws KettleException, FileSystemException {
    // Get current file
    FileObject rootFile = null;/*w w w . j  a  v a2  s. co  m*/
    FileObject initialFile = null;

    if (fileUri != null) {
        initialFile = KettleVFS.getFileObject(fileUri, variableSpace, opts);
    } else {
        initialFile = KettleVFS.getFileObject(Spoon.getInstance().getLastFileOpened());
    }
    rootFile = initialFile.getFileSystem().getRoot();
    fileChooserDialog.setRootFile(rootFile);
    fileChooserDialog.setInitialFile(initialFile);
    fileChooserDialog.defaultInitialFile = rootFile;

    FileObject selectedFile = null;
    selectedFile = fileChooserDialog.open(shell, this.schemeRestrictions, getDefaultScheme(), showFileScheme(),
            initialFile.getName().getPath(), fileFilters, fileFilterNames,
            returnsUserAuthenticatedFileObjects(), fileDialogMode, showLocation, showCustomUI);

    return selectedFile;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »