importexportpanel_3.java

eq跨平台查询工具源码 eq跨平台查询工具源码

            DataTransferObject dto = (DataTransferObject)v.elementAt(i);
            
            if (!dto.hasDataFile(type)) {
                GUIUtilities.displayErrorMessage(
                "You must provide a valid data file for each selected table.");
                return false;
            }
            
        }
        
        return true;
    }
    
    /** <p>Defines the table model for the table to file
     *  selection for the transfer. */
    class TableTransferModel extends AbstractTableModel {
        
        /** The data for this model */
        private Vector data;
        /** The browse button label */
        private final String BROWSE = "Browse";
        /** Header values for the table */
        private final String[] header = {"Table Name", "File Path", ""};
        
        /** <p>Constructs a new table model with no data. */
        public TableTransferModel() {}
        
        /** <p>Constructs a new table model with the specified data.
         *
         *  @param the data to be displayed
         */
        public TableTransferModel(Vector data) {
            this.data = data;
        }
        
        public boolean hasData() {
            return data != null;
        }
        
        public int getRowCount() {
            return data.size();
        }
        
        public int getColumnCount() {
            return 3;
        }
        
        public void setColumnDataVector(Vector data) {
            this.data = data;
            if (table.isEditing()) {
                fireTableRowsUpdated(0, data.size());
            }
        }
        
        /** <p>Sets the data file for the specified row
         *  to the specified file.
         *
         *  @param the row (<code>Vector</code> index)
         *  @param the file name
         */
        public void setDataFile(int row, String fileName) {
            DataTransferObject obj = (DataTransferObject)data.elementAt(row);
            obj.setFileName(getFileName(fileName));
            fireTableRowsUpdated(row, row);
        }
        
        public Vector getDataVector() {
            return data;
        }
        
        public Object getValueAt(int row, int col) {
            DataTransferObject obj = (DataTransferObject)data.elementAt(row);
            
            switch(col) {
                case 0:
                    return obj.getTableName();
                case 1:
                    return obj.getFileName();
                case 2:
                    return BROWSE;
                default:
                    return null;
            }
        }
        
        public void setValueAt(Object value, int row, int col) {
            DataTransferObject obj = (DataTransferObject)data.elementAt(row);
            
            switch (col) {
                case 0:
                    obj.setTableName((String)value);
                    break;
                case 1:
                    obj.setFileName(getFileName(value.toString()));
                    break;
            }
            
            fireTableRowsUpdated(row, row);
        }
        
        private String getFileName(String value) {
            // make sure we have the right file extension
            if (parent.getTransferType() == ImportExportProcess.EXPORT) {
                String defaultExtension = null;
                String fileExtension = findExtension(value);

                int transferFormat = parent.getTransferFormat();
                if (transferFormat == ImportExportProcess.XML) {
                    defaultExtension = ".xml";
                }
                else if (transferFormat == ImportExportProcess.EXCEL) {
                    defaultExtension = ".xls";
                }

                if (defaultExtension != null &&
                        !defaultExtension.equalsIgnoreCase(fileExtension)) {
                    value += defaultExtension;
                }

            }
            return value;
        }

        private String findExtension(String fileName) {
            int index = fileName.lastIndexOf('.');
            if (index != -1) {
                return fileName.substring(index);
            }
            return null;
        }
        
        public String getColumnName(int col) {
            return header[col];
        }
        
        public boolean isCellEditable(int row, int col) {
            return (col > 0);
        }
        
    } // TableTransferModel
    
    
    public class BrowseButtonEditor extends DefaultCellEditor {
        
        protected JButton button;
        private String label;
        private boolean isPushed;
        
        public BrowseButtonEditor(JCheckBox checkBox) {
            super(checkBox);
            button = new JButton();
            
            button.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    fireEditingStopped();
                }
            });
        }
        
        public Component getTableCellEditorComponent(JTable table, 
                                                     Object value,
                                                     boolean isSelected, 
                                                     int row, 
                                                     int column) {
            label = value.toString();
            button.setText(label);
            isPushed = true;
            return button;
        }
        
        public Object getCellEditorValue() {
            
            if (isPushed) {
                FileChooserDialog fileChooser = null;
                
                if (lastPath == null) {
                    fileChooser = new FileChooserDialog();
                } else {
                    fileChooser = new FileChooserDialog(lastPath);
                }

                String dialogTitle = null;                
                if (parent.getTransferType() == ImportExportProcess.EXPORT) {
                    dialogTitle = "Select Export File...";
                } else {
                    dialogTitle = "Select Import File...";
                }

                fileChooser.setDialogTitle(dialogTitle);
                fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                fileChooser.setDialogType(JFileChooser.OPEN_DIALOG);

                int result = fileChooser.showDialog(GUIUtilities.getParentFrame(), "Select");                
                if (result == JFileChooser.CANCEL_OPTION) {
                    return label;
                }

                File fileName = fileChooser.getSelectedFile();
                if (parent.getTransferType() == ImportExportProcess.IMPORT) {
                    
                    if (fileName == null || (!fileName.exists() && !fileName.isFile()))
                        JOptionPane.showMessageDialog(GUIUtilities.getParentFrame(),
                        "Invalid File Name", "Error",
                        JOptionPane.ERROR_MESSAGE);
                    
                }
                
                lastPath = fileName.getParent();                
                tableModel.setDataFile(table.getEditingRow(), fileName.getAbsolutePath());
            }
            
            isPushed = false;
            return label;
        }
        
        public boolean stopCellEditing() {
            isPushed = false;
            return super.stopCellEditing();
        }
        
        protected void fireEditingStopped() {
            super.fireEditingStopped();
        }
        
    } // BrowseButtonEditor
    
    class BrowseButtonRenderer extends JButton
    implements TableCellRenderer {
        
        public BrowseButtonRenderer() {
            setMargin(new Insets(1,1,1,1));
        }
        
        public Component getTableCellRendererComponent(JTable table, Object value,
        boolean isSelected, boolean hasFocus, int row, int column) {
            setText(value.toString());
            return this;
        }
        
    } // BrowseButtonRenderer
    
}