tabledefinitionpanel.java

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

    public void fireEditingStopped() {        
        table.editingStopped(null);
        if (table.isEditing()) {
            table.removeEditor();
        }        
    }
    
    /** <p>Deletes the selected row from the table.
     *  This will also modify the SQL generated text. */
    public void deleteRow() {
        table.editingStopped(null);
        if (table.isEditing()) {
            table.removeEditor();
        }
        
        int selection = table.getSelectedRow();
        if (selection == -1 || tableVector.size() == 0) {
            return;
        }
        
        tableVector.removeElementAt(selection);
        _model.fireTableRowsDeleted(selection, selection);
        
        if (tableVector.size() == 0) {
            tableVector.addElement(new ColumnData(true));
            _model.fireTableRowsInserted(0, 0);
        }
        
        addColumnLines(-1);
    }
    
    public void addMouseListener() {
        table.addMouseListener();
    }
    
    /** <p>Inserts a new column after the selected
     *  column moving the selected column up one row. */
    public void insertAfter() {
        fireEditingStopped();
        int selection = table.getSelectedRow();
        int newRow = selection + 1;

        if (selection == -1) {
            return;
        }
        else if (selection == tableVector.size()) {
            tableVector.add(new ColumnData());
        }
        else {
            tableVector.add(newRow, new ColumnData());
        }
        
        _model.fireTableRowsInserted(selection, newRow);        
        table.setRowSelectionInterval(newRow, newRow);
        table.setColumnSelectionInterval(1, 1);
        
        table.setEditingRow(newRow);
        table.setEditingColumn(1);
        ((DefaultCellEditor)table.getCellEditor(newRow, 1)).
                                            getComponent().requestFocus();
    }

    public TableCellEditor getCellEditor(int row, int col) {
        return table.getCellEditor(row, col);
    }
    
    public void setEditingColumn(int col) {
        table.setEditingColumn(col);
    }

    public void setRowSelectionInterval(int row) {
        table.setRowSelectionInterval(row, row);
    }

    public void setColumnSelectionInterval(int col) {
        table.setColumnSelectionInterval(col, col);
    }

    public void setTableColumnData(ColumnData[] cda) {
        tableVector = new Vector(cda.length);
        for (int i = 0; i < cda.length; i++) {
            tableVector.add(cda[i]);
        }       
        _model.fireTableDataChanged();
        addColumnLines(-1);
    }
    
    public ColumnData[] getTableColumnData() {
        int v_size = tableVector.size();
        ColumnData[] cda = new ColumnData[v_size];
        
        for (int i = 0; i < v_size; i++) {
            cda[i] = tableVector.elementAt(i);
        }
        return cda;
    }
    
    public abstract String getSQLText();
    
    public Vector getTableColumnDataVector() {
        return tableVector;
    }
    
    /**
     * The table view display.
     */
    private class DatabaseTable extends DefaultTable
                                implements MouseListener {
        
        public DatabaseTable(TableModel _model) {
            super(_model);
            //setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
            getTableHeader().setReorderingAllowed(false);
            setRowHeight(20);
            setCellSelectionEnabled(true);
            setColumnSelectionAllowed(false);
            setRowSelectionAllowed(false);
            setSurrendersFocusOnKeystroke(true);
        }
        
        public void addMouseListener() {
            addMouseListener(this);
        }
        
        public void mouseClicked(MouseEvent e) {
            int mouseX = e.getX();
            int mouseY = e.getY();
            
            int col = columnAtPoint(new Point(mouseX, mouseY));
            if (col != 0) {
                return;
            }

            ColumnData[] cda = getTableColumnData();
            int row = rowAtPoint(new Point(mouseX, mouseY));
            for (int i = 0; i < cda.length; i++) {
                if (i == row && !cda[i].isPrimaryKey()) {
                    cda[i].setPrimaryKey(true);
                } else {
                    cda[i].setPrimaryKey(false);
                }                
            }

            _model.fireTableRowsUpdated(0, cda.length);
            addColumnLines(-1);
        }
        
        public void mouseEntered(MouseEvent e) {}
        public void mouseExited(MouseEvent e) {}
        public void mousePressed(MouseEvent e) {}
        public void mouseReleased(MouseEvent e) {}
        
    } // class DatabaseTable
    
    
    /**
     * The table's model.
     */
    protected class CreateTableModel extends AbstractPrintableTableModel {
        
        protected String[] header = {EMPTY, "Name", "Datatype",
                                     "Size", "Scale", "Required"};

        public CreateTableModel() {
            tableVector = new Vector<ColumnData>();
            tableVector.addElement(new ColumnData());
        }
        
        public CreateTableModel(Vector<ColumnData> data) {
            tableVector = data;
        }
        
        public void setColumnDataArray(ColumnData[] cda) {
            
            if (cda != null) {
                if (tableVector == null) {
                    tableVector = new Vector<ColumnData>(cda.length);
                }
                else {
                    tableVector.clear();
                }

                for (int i = 0; i < cda.length; i++) {
                    tableVector.add(cda[i]);
                }
            }
            else {
                tableVector.clear();
            }
            
            fireTableDataChanged();
        }
        
        public int getColumnCount() {
            return header.length;
        }
        
        public int getRowCount() {
            return tableVector.size();
        }
        
        /**
         * Returns the printable value at the specified row and column.
         *
         * @param row - the row index
         * @param col - the column index
         * @return the value to print
         */
        public String getPrintValueAt(int row, int col) {
            if (col > 0) {
                Object value = getValueAt(row, col);
                if (value != null) {
                    return value.toString();
                }
                return EMPTY;
            }
            else {
                ColumnData cd = tableVector.elementAt(row);
                if (cd.isPrimaryKey()) {
                    if (cd.isForeignKey()) {
                        return "PFK";
                    }
                    return "PK";
                } else if (cd.isForeignKey()) {
                    return "FK";
                }
                return EMPTY;
            }
        }

        public Object getValueAt(int row, int col) {
            
            if (row >= tableVector.size()) {
                return null;
            }
            
            ColumnData cd = tableVector.elementAt(row);
            
            switch(col) {
                
                case 0:
                    return cd;
                case 1:
                    return cd.getColumnName();
                    
                case 2:
                    return cd.getColumnType();
                    
                case 3:
                    return new Integer(cd.getColumnSize());
                    
                case 4:
                    return new Integer(cd.getColumnScale());

//                case 5:
//                    return cd.getDefaultValue();

                case 5:
                    return new Boolean(cd.isRequired());
                    
                default:
                    return null;
                    
            }
        }
        
        public void setValueAt(Object value, int row, int col) {
            ColumnData cd = tableVector.elementAt(row);

            //Log.debug("setValueAt [row: "+row+" col: "+col+" value: "+value+"]");
            
            switch (col) {
                case 0:
                    if (cd.isPrimaryKey()) {
                        cd.setKeyType(PRIMARY);
                    } else if (cd.isForeignKey()) {
                        cd.setKeyType(FOREIGN);
                    } else {
                        cd.setKeyType(null);
                    }
                    break;
                case 1:
                    cd.setColumnName((String)value);
                    break;
                case 2:
                    cd.setColumnType((String)value);
                    break;
                case 3:
                    cd.setColumnSize(Integer.parseInt((String)value));
                    break;
                case 4:
                    cd.setColumnScale(Integer.parseInt((String)value));
                    break;
//                case 5:
//                    cd.setDefaultValue((String)value);
//                    break;
                case 5:
                    cd.setColumnRequired(((Boolean)value).booleanValue() ? 0 : 1);
                    break;
            }
            
            fireTableRowsUpdated(row, row);
        }
        
        public boolean isCellEditable(int row, int col) {
            return editing && col != 0;
        }
        
        public String getColumnName(int col) {
            return header[col];
        }
        
        public Class getColumnClass(int col) {
            if (col == 5) {
                return Boolean.class;
            }
            else if (col == 3 || col == 4) {
                return Integer.class;
            }
            else {
                return String.class;
            }
        }
        
        public void addNewRow() {
            ColumnData cd = tableVector.lastElement();
            if (!cd.isNewColumn()) {
                tableVector.addElement(new ColumnData(true));
            }
            
        }
        
    } // class CreateTableModel
    
    private class DataTypeSelectionTableCell extends BrowsingCellEditor 
                                             implements DataTypeSelectionListener {

        private int lastEditingRow;
        private int lastEditingColumn;
        
        public DataTypeSelectionTableCell() {}

        public void actionPerformed(ActionEvent e) {
            // store the current edit row and column
            lastEditingRow = table.getEditingRow();
            lastEditingColumn = table.getEditingColumn();

            fireEditingStopped();
            if (dataTypes == null || dataTypes.length == 0) {
                GUIUtilities.displayWarningMessage("Data type values are not available");
                return;
            }
            
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    new DataTypesDialog(GUIUtilities.getParentFrame(), 
                                        DataTypeSelectionTableCell.this,
                                        dataTypes);
               } 
            });
        }
        
        /**
         * Called when the selction is cancelled.
         */
        public void dataTypeSelectionCancelled() {
            fireEditingCanceled();
        }

        /**
         * Called when a data type has been selected.
         *
         * @param the data type value string
         */
        public void dataTypeSelected(String dataType) {
            //setDelegateValue(dataType);
            if (lastEditingRow != -1 && lastEditingColumn != -1) {
                _model.setValueAt(dataType, lastEditingRow, lastEditingColumn);
                tableChanged(lastEditingColumn, lastEditingRow, dataType);
            }
            fireEditingStopped();

            // reset row and column values
            lastEditingRow = -1;
            lastEditingColumn = -1;
        }

    } // class DataTypeSelectionTableCell
    
}