stationspanel.java

一个用于排队系统仿真的开源软件,有非常形象的图象仿真过程!

        super.repaint();
    }

    /**
     * called by the Wizard when the panel becomes active
     */
    public void gotFocus() {
        comboEditor.clearCache();
    }

    /**
     * Called when an other panel is selected. This method will set a default station as reference
     * station of any closed class without it.
     */
    public void lostFocus() {
        Vector classes = classData.getClassKeys();
        // Perform check only if valids stations are created to be reference station
        if (data.getStationKeysNoSourceSink().size() > 0)
            for (int i=0; i<classes.size(); i++) {
                Object classKey = classes.get(i);
                // If this is a closed class and it has no reference source or a deleted one
                if (classData.getClassType(classKey) == CLASS_TYPE_CLOSED &&
                        (classData.getClassRefStation(classKey) == null ||
                                !data.getStationKeys().contains(classData.getClassRefStation(classKey)))) {
                    // Sets the first station as reference station
                    classData.setClassRefStation(classKey, data.getStationKeysNoSourceSink().get(0));
                }
            }

        // Aborts editing of table
        TableCellEditor editor = stationTable.getCellEditor();
        if (editor != null)
            editor.stopCellEditing();
    }

    /*delete a class from model given the index the class to be deleted is displayed at
    inside the table.*/
    private void deleteStation(int index){
        data.deleteStation(data.getStationKeys().get(index));
        refreshComponents();
    }

    /*Modify global number of classes for this model all at once.*/
    private void setNumberOfStations(int newNumber){
        /*If new number is greater than a certain number, don't do anything and cancel
        number modification inside spinner*/
        if(newNumber > MAX_NUMBER_OF_STATIONS){
            setNumberOfStations(MAX_NUMBER_OF_STATIONS);
            return;
        }
        /*If new number is not valid, reset to 0*/
        if(newNumber < 0){
            setNumberOfStations(0);
            return;
        }
        int oldNumber = data.getStationKeys().size();
        /*If new number is greater than former one, just add */
        if(newNumber > oldNumber){
            for(int i = oldNumber; i<newNumber; i++){
                addStation();
            }
        }else if(newNumber < oldNumber){
            /*otherwise, just delete*/
            for(int i = oldNumber-1; i >= newNumber; i--){
                deleteStation(i);
            }
        }
        refreshComponents();
    }

//---------------------------- Table containing classes parameters --------------------------
/*Table that must display all of data about user classes. Customization of table settings is
obtained via inheritation of <code>JTable</code> Class.*/


    private class StationTable extends JTable{

        /*This button allow a single userclass to be deleted directly from the table.
        Corresponding value contained into cell must be zero.*/
        JButton deleteButton= new JButton(){
            {
                setAction(deleteStation);
                setFocusable(false);
            }
        };

        /*Set of column dimensions*/
        int[] columnSizes = new int[]{120,120,18};

        //Sets a table model for visualization and editing of data
        public void setModel(StationTableModel tabMod){
            super.setModel(tabMod);
            sizeColumnsAndRows();
            setRowHeight(ROW_HEIGHT);
            setDefaultRenderer(String.class, new jmt.gui.exact.table.DisabledCellRenderer());
        }

        //returns a component to be contained inside a table column(or cell)
        public TableCellRenderer getCellRenderer(int row, int column){
            if (column == 1)
                return comboEditor.getRenderer();
            //Addition of column that contains delete buttons
            else if(column == getColumnCount()-1)
                if (isCellEditable(row, column))
                    return new ButtonCellEditor(deleteButton);
                else
                    return new DisabledCellRenderer();
            else return getDefaultRenderer(getModel().getColumnClass(column));
        }

        /*returns customized editor for table cells.*/
        public TableCellEditor getCellEditor(int row, int column){
            if(column == 1){
                return comboEditor.getEditor(stationTypes);
            }else if(column == getColumnCount()-1){
                return new ButtonCellEditor(deleteButton);
            }
            else return super.getCellEditor(row, column);
        }

        //set sizes for columns and rows of this table.
        private void sizeColumnsAndRows(){
            for (int i = 0; i < columnSizes.length && i < getColumnCount(); i++) {
                this.getColumnModel().getColumn(i).setPreferredWidth(columnSizes[i]);
                if(i==columnSizes.length-1){
                    //delete button and containing table cells as well, must be square
                    this.getColumnModel().getColumn(i).setMaxWidth(columnSizes[i]);
                    this.setRowHeight(columnSizes[i]);
                }
            }
        }

        public boolean isCellEditable(int row, int column) {
            // Avoid deletion of sources and sinks
            String stationType = data.getStationType(data.getStationKeys().get(row));
            return !((column == getColumnCount() - 1 || column == 1)
                    && (stationType.equals(STATION_TYPE_SOURCE) || stationType.equals(STATION_TYPE_SINK)));
        }
    }

//------------------------------------Table model for classes panel --------------------------
/*Table data model to implement customized data editing*/

    private class StationTableModel extends AbstractTableModel{

        //Names of columns contained in table. Columns containing buttons have empty names
        String[] columnNames = new String[]{"Name", "Type", ""};

        //Class declarations for this table's columns.
        Class[] colClasses = new Class[]{String.class, JComboBox.class, JButton.class};


        /**Creates a new instance of class table model*/
        public StationTableModel(){
            super();
        }

        /**returns number of rows to be displayed in the table. In this case, global
         * number of classes*/
        public int getRowCount() {
            if(data.getStationKeys()!=null) return data.getStationKeys().size();
            else return 0;
        }

        /**Returns total number of columns*/
        public int getColumnCount() {
            return columnNames.length;
        }

        /**Returns name for each column (given its index) to be displayed
         * inside table header*/
        public String getColumnName(int columnIndex) {
            if(columnIndex<columnNames.length) return columnNames[columnIndex];
            else return null;
        }

        /**Returns class describing data contained in specific column.*/
        public Class getColumnClass(int columnIndex) {
            if(columnIndex < colClasses.length) return colClasses[columnIndex];
            else return Object.class;
        }

        /**Tells wether data contained in a specific cell(given row and column index)
         * is editable or not. In this case distribution column is not editable, as
         * editing functionality is implemented via edit button*/
        public boolean isCellEditable(int rowIndex, int columnIndex) {
            //can edit station type only if type is contained in combo box list
            if(columnIndex==1){
                String type = data.getStationType(data.getStationKeys().get(rowIndex));
                for(int i=0; i<stationTypes.length; i++){
                    if(stationTypes[i].equals(type)){
                        return true;
                    }
                }
                return false;
            }
            return true;
        }

        /**retrieves value to be displayed in table cell from the underlying model
         * data structure implementation.*/
        public Object getValueAt(int rowIndex, int columnIndex) {
            Object key = data.getStationKeys().get(rowIndex);
            switch(columnIndex){
                case(0):{
                    return data.getStationName(key);
                }case(1):{
                    return data.getStationType(key);
                }default:{
                    return null;
                }
            }
        }

        /**Puts edited values to the underlying data structure for model implementation*/
        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
            Object key = data.getStationKeys().get(rowIndex);
            switch(columnIndex){
                case(0):{
                    data.setStationName((String)aValue, key);
                    break;
                }case(1):{
                    data.setStationType((String)aValue, key);
                    break;
                }
            }
        }

        public void addTableModelListener(TableModelListener l) {
        }

        public void removeTableModelListener(TableModelListener l) {
        }

    }

}