source: src/main/java/genius/gui/uncertainty/PairwiseComparisonPanel.java@ 30

package genius.gui.uncertainty;

import java.awt.Component;
import java.awt.Dimension;
import java.util.Hashtable;

import javax.swing.BoxLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.JTextField;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

import genius.gui.panels.ButtonPanel;
import genius.gui.panels.ExtendedCheckboxPanel;
import genius.gui.panels.LabelAndComponent;

public class PairwiseComparisonPanel extends JPanel{
        
        private static final long serialVersionUID = 7745677414933157895L;
        
        private PairwiseComparisonModel model;
        
        private final JLabel label;
        private final JLabel numberOfCompsLabel;
        
        private JPanel uncertaintyLevelPanel = new JPanel();
        private JSlider uncertaintySlider;
        private LabelAndComponent uncertaintyComp;
        private JTextField generatedCompsField;

        private JSlider errorSlider;
        private LabelAndComponent errorComp;
        
        private ExtendedCheckboxPanel experimentalBox;
        private final ButtonPanel okButton;


        public PairwiseComparisonPanel(PairwiseComparisonModel model) {
                
                this.model = model;
                this.setPreferredSize(new Dimension(900,200)); 

                this.label = new JLabel("Set Pairwise Comparison User Model Parameters");
//              this.label.setPreferredSize(new Dimension(500, 35));
                this.numberOfCompsLabel = new JLabel("(Maximum Number of Comparisons = " +this.model.calculateMaxNumberOfComparisons() +")");
//              this.numberOfCompsLabel.setPreferredSize(new Dimension(500, 35));
                
                
                this.uncertaintySlider = createUncertaintySlider();
                this.uncertaintyComp = new LabelAndComponent("Uncertainty Level / \n (No Of Comparisons)", uncertaintySlider);
                uncertaintyComp.getLabel().setPreferredSize(new Dimension(300, 50));

                this.generatedCompsField = new JTextField(String.valueOf(model.calculateMaxNumberOfComparisons()),8);
                uncertaintyLevelPanel.add(uncertaintyComp);
                uncertaintyLevelPanel.add(generatedCompsField);         
                uncertaintyLevelPanel.setMaximumSize(new Dimension(800, 50));

                
                this.errorSlider = createErrorSlider();
                this.errorComp = new LabelAndComponent(" Error Rate   ", errorSlider);
                this.errorComp.setMaximumSize(new Dimension(500, 30));

                label.setAlignmentX(Component.CENTER_ALIGNMENT);
                numberOfCompsLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
                uncertaintyLevelPanel.setAlignmentX(Component.CENTER_ALIGNMENT);
                experimentalBox = new ExtendedCheckboxPanel("Experimental Setup (Agent has access to real utility function)", 
                                model.getExperimentalModel());
                experimentalBox.setMaximumSize(new Dimension(500,150));
                experimentalBox.setAlignmentX(Component.CENTER_ALIGNMENT);
                experimentalBox.getCheckBox().setSelected(true);

                
                okButton = new ButtonPanel("OK", model.getConfirmationModel());
                okButton.setMaximumSize(new Dimension (150,150)) ;
                okButton.setAlignmentX(Component.CENTER_ALIGNMENT);
                connect();
                
                setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
                add(label);
                add(numberOfCompsLabel);
                add(uncertaintyLevelPanel);
                add(errorComp);
                add(experimentalBox);
                add(okButton);
        }
        
        public void connect() {
                uncertaintySlider.addChangeListener(new ChangeListener() {
                        @Override
                        public void stateChanged(ChangeEvent e) {
                                System.out.println(e.getSource());
                                if (e.getSource() != generatedCompsField) {
                                        generatedCompsField.setText(String.valueOf((int)((1-(double)uncertaintySlider.getValue()/100)
                                                        * model.calculateMaxNumberOfComparisons())));
                                        model.getUncertaintyModel().setText(generatedCompsField.getText());
                                }
                        }                       
                });             
                
                generatedCompsField.addActionListener(new ActionListener() {
                        @Override
                        public void actionPerformed(ActionEvent e) {
                        if (e.getSource() != uncertaintySlider) {
                                model.getUncertaintyModel().setText(generatedCompsField.getText());
                                uncertaintySlider.setValue((int)(100*((double)model.calculateMaxNumberOfComparisons() 
                                                - Double.parseDouble(generatedCompsField.getText()))/(double)model.calculateMaxNumberOfComparisons()));
                      }
                        }
                });
        }
        
        private JSlider createUncertaintySlider() {
                JSlider slider = new JSlider(JSlider.HORIZONTAL,0,100,0);
                slider.setMajorTickSpacing( 1 );                
                slider.setMinorTickSpacing( 2 );                
                Hashtable<Integer, JLabel> sliderLabelsTable = new Hashtable<Integer, JLabel>();
                sliderLabelsTable.put( 0 , new JLabel("0%") );
                sliderLabelsTable.put( 100 , new JLabel("100%") );
            slider.setLabelTable(sliderLabelsTable);
            slider.setPaintLabels(true);
//          slider.addChangeListener(new ChangeListener() {
//                      @Override
//                      public void stateChanged(ChangeEvent e) {
//                                      model.getUncertaintyModel().setText(String.valueOf((double) slider.getValue() / 100));
//                                      
//                      }                       
//              });             
                return slider;
        }
        
        private JSlider createErrorSlider() {
                JSlider slider = new JSlider(JSlider.HORIZONTAL,0,100,0);
                slider.setMajorTickSpacing( 1 );                
                slider.setMinorTickSpacing( 2 );                
                Hashtable<Integer, JLabel> sliderLabelsTable = new Hashtable<Integer, JLabel>();
                sliderLabelsTable.put( 0 , new JLabel("0%") );
                sliderLabelsTable.put( 100 , new JLabel("100%") );
            slider.setLabelTable(sliderLabelsTable);
            slider.setPaintLabels(true);
            slider.setMaximumSize(new Dimension(50,50));
            slider.addChangeListener(new ChangeListener() {
                        @Override
                        public void stateChanged(ChangeEvent e) {
                                model.getErrorModel().setText(String.valueOf((double) slider.getValue() / 100));
                }                       
        });                     
                return slider;
        }
        
        
}