servicetimespanel.java

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

        setLeftComponent(scroll);
        setRightComponent(descrPane);
        this.setBorder(new EmptyBorder(5,0,5,0));
        setListeners();
    }


    public void setEnabled(boolean enabled) {
        if (enabled) {
            //if the panel is enabled the allClass radioButton can be enabled only if all of the class have a service
            //time distribution with a mean value, in the reference station contained in STPA.
            Vector validC = checker.checkForServiceTimesParametricSimulationAvaibleClasses(STPA.getReferenceStation());
            if ((validC.size() < cd.getClassKeys().size()) || (cd.getClassKeys().size() == 1) ) allClass.setEnabled(false);
                else allClass.setEnabled(true);
        }
        else allClass.setEnabled(false);
        singleClass.setEnabled(enabled);
        fromLabel.setEnabled(enabled);
        from.setEnabled(false);
        toLabel.setEnabled(enabled);
        to.setEnabled(enabled);
        stepsLabel.setEnabled(enabled);
        steps.setEnabled(enabled);
        description.setEnabled(enabled);
        classChooserLabel.setEnabled(enabled);
        if (!enabled) classChooser.setEnabled(enabled);
        else if (singleClass.isSelected()) classChooser.setEnabled(enabled);
        stationChooserLabel.setEnabled(enabled);
        stationChooser.setEnabled(enabled);
        if (!enabled) {
            scroll.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_NEVER);
            descrPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_NEVER);
        }
        else  {
            scroll.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
            descrPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
        }
        if (!enabled) {
            title.setTitleColor(Color.LIGHT_GRAY);
            descriptionTitle.setTitleColor(Color.LIGHT_GRAY);
        }
        else {
            title.setTitleColor(DEFAULT_TITLE_COLOR);
            descriptionTitle.setTitleColor(DEFAULT_TITLE_COLOR);
        }
    }

    private void setListeners() {
        to.addChangeListener(new ChangeListener() {
            public void stateChanged (ChangeEvent e) {
                Object tValue = to.getValue();
                if (tValue instanceof Double) {
                    STPA.setFinalValue(((Double)tValue).doubleValue());
                }
                else if (tValue instanceof Integer) {
                    STPA.setFinalValue(((Integer)tValue).doubleValue());
                }
                to.setValue(new Double(STPA.getFinalValue()));
            }
        });
        steps.addChangeListener(new ChangeListener() {
            public void stateChanged (ChangeEvent e) {
                if (steps.getValue() instanceof Integer) {
                    Integer sValue = (Integer)steps.getValue();
                    STPA.setNumberOfSteps(sValue.intValue());
                }
                steps.setValue(new Integer(STPA.getNumberOfSteps()));
            }
        });
        allClass.addItemListener(new ItemListener() {
            public void itemStateChanged(ItemEvent e) {
                if (e.getStateChange() == ItemEvent.SELECTED) {
                    STPA.setSingleClass(false);
                    fromLabel.setText("From (%):");
                    toLabel.setText("To (%): ");
                    STPA.setDefaultInitialValue();
                    STPA.setDefaultFinalValue();
                    from.setText(Double.toString(STPA.getInitialValue()));
                    to.setModel(new SpinnerNumberModel(STPA.getFinalValue(),0.1,Double.MAX_VALUE,0.1));
                    to.setValue(new Double(STPA.getFinalValue()));
                    to.setToolTipText("Sets the final proportion of service time with respect to the initial");
                    classChooser.removeAllItems();
                    classChooser.addItem("All classes");
                    classChooser.setEnabled(false);
                    description.setText(DESCRIPTION);
                }
            }
        });
        singleClass.addItemListener(new ItemListener() {
            public void itemStateChanged(ItemEvent e) {
                if (e.getStateChange() == ItemEvent.SELECTED) {
                    STPA.setSingleClass(true);
                    //get the vector containing the keys of the valid classes. A class is valid if its service
                    //time distribution is load independent (inside the reference station of the STPA) and has a mean value.
                    Vector validC = checker.checkForServiceTimesParametricSimulationAvaibleClasses(STPA.getReferenceStation());
                    String[] classNames = new String[validC.size()];
                    for (int i=0;i<validC.size();i++) {
                        classNames[i] = cd.getClassName(validC.get(i));
                    }
                    classChooser.setEnabled(true);
                    ItemListener listener = classChooser.getItemListeners()[0];
                    classChooser.removeItemListener(listener);
                    classChooser.removeAllItems();
                    for (int i=0;i<classNames.length;i++) classChooser.addItem(classNames[i]);
                    classChooser.addItemListener(listener);
                    //if no classes where previously associated, associate
                    //the first one
                    if (!validC.contains(STPA.getReferenceClass())) {
                        STPA.setReferenceClass(validC.get(0));
                    }
                    classChooser.setSelectedItem(cd.getClassName(STPA.getReferenceClass()));
                    fromLabel.setText("From (s):");
                    toLabel.setText("To (s):");
                    STPA.setDefaultInitialValue();
                    STPA.setDefaultFinalValue();
                    from.setText(Double.toString(STPA.getInitialValue()));
                    to.setModel(new SpinnerNumberModel(STPA.getFinalValue(),0.001,Double.MAX_VALUE,0.001));
                    to.setValue(new Double(STPA.getFinalValue()));
                    to.setToolTipText("Sets the final arrival rate in job/sec");
                    description.setText(DESCRIPTION_SINGLE);
                }
            }
        });
        classChooser.addItemListener(new ItemListener() {
            public void itemStateChanged(ItemEvent e) {
                String className = (String)classChooser.getSelectedItem();
                Object classKey = null;
                Vector classes = cd.getClassKeys();
                //for cycle used to get the key of the selected class
                for (int i=0;i<classes.size();i++) {
                    if (cd.getClassName(classes.get(i)).equals(className)) {
                        classKey = classes.get(i);
                        break;
                    }
                }
                STPA.setReferenceClass(classKey);
                STPA.setDefaultInitialValue();
                STPA.setDefaultFinalValue();
                from.setText(Double.toString(STPA.getInitialValue()));
                to.setValue(new Double(STPA.getFinalValue()));
            }
        });
        stationChooser.addItemListener(new ItemListener() {
            public void itemStateChanged(ItemEvent e) {
                String stationName = (String)stationChooser.getSelectedItem();
                STPA.setReferenceStation(getStationKey(stationName));
                //get the vector containing the keys of the valid classes. A class is valid if its service
                //time distribution is load independent (inside the reference station of the STPA) and has a mean value.
                Vector validC = checker.checkForServiceTimesParametricSimulationAvaibleClasses(STPA.getReferenceStation());
                if (STPA.isSingleClass()) {
                    String[] classes = new String[validC.size()];
                    for (int i=0;i<validC.size();i++) {
                        classes[i] = cd.getClassName(validC.get(i));
                    }
                    //if the reference station of the STPA is no more valid get the first avaible
                    if (!validC.contains(STPA.getReferenceClass())) {
                        STPA.setReferenceClass(validC.get(0));
                    }
                    STPA.setDefaultInitialValue();
                    STPA.setDefaultFinalValue();
                    from.setText(Double.toString(STPA.getInitialValue()));
                    to.setValue(new Double(STPA.getFinalValue()));
                    ItemListener listener = classChooser.getItemListeners()[0];
                    classChooser.removeItemListener(listener);
                    classChooser.removeAllItems();
                    for (int i=0;i<classes.length;i++) classChooser.addItem(classes[i]);
                    classChooser.setEnabled(true);
                    classChooser.setSelectedItem(cd.getClassName(STPA.getReferenceClass()));
                    classChooser.addItemListener(listener);
                    singleClass.setSelected(true);
                    allClass.setSelected(false);
                    //if the number of avaible classes is less than the total number of classes the all class service
                    //time parametric analysis is no more avaible.
                    if (validC.size() < cd.getClassKeys().size()) allClass.setEnabled(false);
                    else allClass.setEnabled(true);
                }
                else {
                    //if the number of avaible classes is less than the total number of classes the all class service
                    //time parametric analysis is no more avaible...
                    if (validC.size() < cd.getClassKeys().size()) {
                        STPA.setSingleClass(true);
                        String[] classes = new String[validC.size()];
                        for (int i=0;i<validC.size();i++) {
                            classes[i] = cd.getClassName(validC.get(i));
                        }
                        //set the reference class to the STPA...
                        STPA.setReferenceClass(validC.get(0));
                        STPA.setDefaultInitialValue();
                        STPA.setDefaultFinalValue();
                        from.setText(Double.toString(STPA.getInitialValue()));
                        to.setModel(new SpinnerNumberModel(STPA.getFinalValue(),0.001,Double.MAX_VALUE,0.001));
                        to.setValue(new Double(STPA.getFinalValue()));
                        //... and set the STPA to be single class
                        singleClass.setSelected(true);
                        allClass.setEnabled(false);
                        description.setText(DESCRIPTION_SINGLE);
                    }
                    else {
                        allClass.setEnabled(true);
                        classChooser.setEnabled(false);
                        singleClass.setSelected(false);
                        allClass.setSelected(true);
                    }
                }
            }
        });
    }
}