iprestrictortable.java

用java写的ftp服务器程序

        if(!canBeRemoved()) {
            return;
        }
        
        // save the changed data if any 
        stopCellEditing();
        
        // get current selection
        int selRow = m_table.getSelectedRow();
        if(selRow == -1) {
            selRow = m_entries.size() - 1;
        }
        
        // remove row
        m_entries.remove(selRow);
        fireTableChanged( new TableModelEvent(this, selRow, selRow,
             TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE) );
        
        // select another row
        if(m_entries.isEmpty()) {
            setButtonStatus();
        }
        else {
            if(selRow == m_entries.size()) {
                --selRow;
            }
            m_table.setRowSelectionInterval(selRow, selRow);
        }
    }
    
    /**
     * Move up a row.
     */
    public void moveUpRow() {
        
        // row cannot be moved up
        if(!canBeMovedUp()) {
            return;
        }
        
        // save the changed data if any 
        stopCellEditing();
        
        // change the entry positions
        int selRow = m_table.getSelectedRow();
        Entry ent1 = (Entry)m_entries.get(selRow);
        Entry ent2 = (Entry)m_entries.get(selRow - 1);
        
        m_entries.set(selRow, ent2);
        m_entries.set(selRow - 1, ent1);
        
        // notify listeners and update the table selection
        fireTableChanged( new TableModelEvent(this, selRow - 1, selRow,
              TableModelEvent.ALL_COLUMNS, TableModelEvent.UPDATE) );
        m_table.setRowSelectionInterval(selRow - 1, selRow - 1);
    }
    
    /**
     * Move down a row.
     */
    public void moveDownRow() {
        
        // row cannot be moved down
        if(!canBeMovedDown()) {
            return;
        }
        
        // save the changed data if any 
        stopCellEditing();
        
        // change the entry positions
        int selRow = m_table.getSelectedRow();
        Entry ent1 = (Entry)m_entries.get(selRow);
        Entry ent2 = (Entry)m_entries.get(selRow + 1);
        
        m_entries.set(selRow, ent2);
        m_entries.set(selRow + 1, ent1);
        
        // notify listeners and update the table selection
        fireTableChanged( new TableModelEvent(this, selRow, selRow + 1,
              TableModelEvent.ALL_COLUMNS, TableModelEvent.UPDATE) );
        m_table.setRowSelectionInterval(selRow + 1, selRow + 1);
    }
    
    /**
     * Get data.
     */
    public Object[][] getData() {
        stopCellEditing();
        Object[][] retVal = new Object[m_entries.size()][2];
        for(int i=0; i<m_entries.size(); ++i) {
            Entry entry = (Entry)m_entries.get(i);
            retVal[i][0] = entry.m_pattern;
            retVal[i][1] = entry.m_allow;
        }
        return retVal;
    }
    
    /**
     * Set data.
     */
    public void setData(Object[][] objs) {
        cancelCellEditing();
        m_entries.clear();
        if(objs != null) {
            for(int i=0; i<objs.length; ++i) {
                Entry entry = new Entry();
                entry.m_pattern = (String)objs[i][0];
                entry.m_allow = (Boolean)objs[i][1];
                m_entries.add(entry);
            }
        }
        fireTableChanged( new TableModelEvent(this) );
        if(m_entries.isEmpty()) {
            setButtonStatus();
        }
        else {
            m_table.setRowSelectionInterval(0, 0);
        }
    }  
    
    /**
     * Cancel editing
     */
    public void cancelCellEditing() {
        if(m_table.isEditing()) {
            int row = m_table.getEditingRow();
            int col = m_table.getEditingColumn();
            if( (row != -1) && (col != -1) ) {
                TableCellEditor editor = m_table.getCellEditor();
                editor.cancelCellEditing();
            }
        }
    }
    
    /**
     * Stop editing
     */
    public void stopCellEditing() {
        if(m_table.isEditing()) {
            int row = m_table.getEditingRow();
            int col = m_table.getEditingColumn();
            if( (row != -1) && (col != -1) ) {
                TableCellEditor editor = m_table.getCellEditor();
                editor.stopCellEditing();
            }
        }
    }

    /**
     * If row selection changed - fire button status.
     */
    public void valueChanged(ListSelectionEvent e) {
        setButtonStatus();
    }
    
    ///////////////////////////////////////////////////////////////////////
    ///////////////////// Table Model Implementation //////////////////////
    /**
     * Add new listener.
     */
    public void addTableModelListener(TableModelListener l) {
        m_modelListeners.add(TableModelListener.class, l);
    }
    
    /**
     * Get column class.
     */
    public Class getColumnClass(int colIdx) {
        Class type = null;
        if(colIdx == 0) {
            type = String.class;
        }
        else {
            type = Boolean.class;
        }
        return type;
    }
    
    /**
     * Get column count.      
     */
    public int getColumnCount() {
        return HEADER.length;
    }
     
    /**
     * Get header name.
     */
    public String getColumnName(int col) {
        return HEADER[col];
    }
    
    /**
     * Get row count.
     */
    public int getRowCount() {
        return m_entries.size();
    }
    
    /**
     * Get value.
     */
    public Object getValueAt(int row, int col) {
        if(m_entries == null) {
            return null;
        }
        
        Entry entry = (Entry)m_entries.get(row);
        Object retVal = null;
        if(col == 0) {
            retVal = entry.m_pattern;
        }
        else {
            retVal = entry.m_allow;
        }
        return retVal;
    }
    
    /**
     * Cells are editable.
     */
    public boolean isCellEditable(int row, int col) {
        return true;
    }
    
    /**
     * Set value.
     */
    public void setValueAt(Object val, int row, int col) {
        if(m_entries == null) {
            return;
        }
        
        Entry entry = (Entry)m_entries.get(row);
        if(col == 0) {
            entry.m_pattern = (String)val;
        }
        else {
            entry.m_allow = (Boolean)val;
        }
    }
    
    /**
     * Remove listener.
     */
    public void removeTableModelListener(TableModelListener l) {
        m_modelListeners.remove(TableModelListener.class, l);
    }
    
    /**
     * Event handler.
     */
    private void fireTableChanged(TableModelEvent e) {
        Object[] listeners = m_modelListeners.getListenerList();
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i] == TableModelListener.class) {
                ((TableModelListener)listeners[i+1]).tableChanged(e);
            }
        }
    }
            
    ///////////////////// Inner class to hold IP and permission //////////////////
    private static class Entry {
        public String m_pattern = "*";
        public Boolean m_allow = Boolean.TRUE;
    }
}