ldstrategyeditor.java

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

    protected void setNumberOfRanges(int newNumber) {
        if (newNumber > MAXRANGES) {
            refreshComponents();
            return;
        }
        /*If new number is lesser than 0, reset to 0*/
        if(newNumber < 1){
            setNumberOfRanges(1);
            return;
        }
        int oldNumber = strategy.getRangeNumber();
        /*If new number is greater than former one, just add */
        if(newNumber > oldNumber){
            for(int i = oldNumber; i<newNumber; i++){
                addRange();
            }
        }else if(newNumber < oldNumber){
            /*otherwise, just delete*/
            for(int i = oldNumber-1; i >= newNumber; i--){
                deleteRange(i);
            }
        }
        refreshComponents();
    }

    /**
     * Adds a new range to the strategy
     */
    protected void addRange() {
        if (strategy.getRangeNumber() >= MAXRANGES)
            return;
        strategy.addRange();
        refreshComponents();
    }

    /**
     * synchronizes components to display coherently global number of ranges
     */
    protected void refreshComponents(){
        rangesTable.tableChanged(new TableModelEvent(rangesTable.getModel()));
        try{
            rangesNumSpinner.setValue(new Integer(strategy.getRangeNumber()));
        }catch(NumberFormatException nfe){}
    }

    /**
     * delete a range from strategy given the index the range to be deleted is displayed at
     * inside the table.
     */
    protected void deleteRange(int index){
        strategy.deleteRange(strategy.getAllRanges()[index]);
        refreshComponents();
    }

    /**
     * Multiple deletion of ranges. Indexes to ship call to precedent method, are retrieved
     * through classtable methods (get selected rows)
     */
    protected void deleteSelectedClasses(){
        int[] rows = rangesTable.getSelectedRows();
        for(int i=rows.length-1; i>=0; i--){
            deleteRange(rows[i]);
        }
    }
// -------------------------------------------------------------------------------------------------

//---------------------------- Table containing strategy parameters --------------------------------

    /**
     * Table that must display all of data about user classes. Customization of table
     * settings is obtained via inheritation of <code>JTable</code> Class.
     */
    protected class LDStrategyTable extends JTable{
        /*This button allow a single range to be deleted directly from the table.
        Corresponding value contained into cell must be zero.*/
        public JButton deleteButton = new JButton(){
            {
                setAction(deleteRange);
                setFocusable(false);
            }
        };
        /** Editor to select distribution type */
        protected ComboBoxCellEditor distributionEditor = ComboBoxCellEditor.getEditorInstance(distributions.keySet().toArray());

        public LDStrategyTable() {
            super();
            this.setModel(new LDStrategyTableModel());
            this.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        }

        /*Set of column dimensions*/
        protected int[] columnSizes = new int[]{20,20,80,150,30, 18};

        //Sets a table model for visualization and editing of data
        public void setModel(LDStrategyTableModel tabMod){
            super.setModel(tabMod);
            sizeColumnsAndRows();
            setDefaultRenderer(String.class, new GrayCellRenderer());
            setDefaultEditor(Object.class, new jmt.gui.exact.table.ExactCellEditor());
        }

        //returns a component to be contained inside a table column(or cell)
        public TableCellRenderer getCellRenderer(int row, int column){
            // Delete buttons
            if(column == 5 && row > 0) return new ButtonCellEditor(deleteButton);
            else if (column == 5 && row == 0) return getDefaultRenderer(String.class);
            else if (column == 2)
                return ComboBoxCellEditor.getRendererInstance();
            else return getDefaultRenderer(getModel().getColumnClass(column));
        }

        /*returns customized editor for table cells.*/
        public TableCellEditor getCellEditor(int row, int column){
            if(column == 2)
                return distributionEditor;
            else if (column == 5)
                return new ButtonCellEditor(new JButton(deleteRange));
            else return super.getCellEditor(row, column);
        }

        //set sizes for columns and rows of this table.
        protected 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]);
                }
            }
        }
    }

    /**
     * Table data model to implement customized data editing
     */
    protected class LDStrategyTableModel extends AbstractTableModel{
        //Names of columns contained in table. Columns containing buttons have empty names
        protected String[] columnNames = new String[]{"From", "To", "Distribution",
                                            "Mean", "C", ""};

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


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

        /**returns number of rows to be displayed in the table. In this case, global
         * number of ranges*/
        public int getRowCount() {
            return strategy.getRangeNumber();
        }

        /**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) {
            if (rowIndex == 0 && (columnIndex == 0 || columnIndex == 5))
                return false;
            if (columnIndex == 1)
                return false;
            // If distribution does not have C, avoid editing
            else if (columnIndex == 4 &&
                    !((Distribution)distributions.get(getValueAt(rowIndex, 2))).hasC())
                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 = strategy.getAllRanges()[rowIndex];
            switch(columnIndex){
                case(0):{
                    return new Integer(strategy.getRangeFrom(key));
                }case(1):{
                    int value = strategy.getRangeTo(key);
                    if (value > 0)
                        return new Integer(value);
                    else
                        return "\u221E"; // Infinity character
                }case(2):{
                    return strategy.getRangeDistribution(key).getName();
                }case(3):{
                    return strategy.getRangeDistributionMean(key);
                }case(4):{
                    if (strategy.getRangeDistribution(key).hasC())
                        return FormatNumber(strategy.getRangeDistribution(key).getC());
                    else
                        return null;
                }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 = strategy.getAllRanges()[rowIndex];
            switch(columnIndex){
                case(0):
                    try {
                        strategy.setRangeFrom(key, Integer.parseInt((String)aValue));
                    } catch (NumberFormatException e) {}
                    break;
                case(2):
                    strategy.setRangeDistribution(key, (Distribution)distributions.get(aValue));
                    break;
                case(3):
                    strategy.setRangeDistributionMean(key, (String)aValue);
                    break;
                case(4):
                    try{
                        strategy.setRangeDistributionC(key, Double.parseDouble((String)aValue));
                    }catch(NumberFormatException nfe){}
                    break;
            }

            // If from or distribution has changed, need to repaint the table
            if(columnIndex == 0 || columnIndex == 2)
                repaint();
        }

        /**
         * Helper method used to formats given number into string according to default rules.
         * @param d bouble to be converted
         * @return string representation of given number
         */
        protected String FormatNumber(double d) {
            DecimalFormat nf = new DecimalFormat();
            String ret;
            // If module of number is greater than 1e4 or lesser than 1e-4 uses exponential notation
            if (Math.abs(d) >= 1e-4 && Math.abs(d) <= 1e4 || d == 0) {
                nf.applyPattern("#.####");
                ret = nf.format(d);
                if (ret.length() > 7)
                    ret = ret.substring(0, 6);
            }
            else{
                nf.applyPattern("0.00E00");
                ret = nf.format(d);
            }
            return ret;
        }


    }
// -------------------------------------------------------------------------------------------------

}