source: src/main/java/genius/gui/tree/WeightSlider.java@ 84

package genius.gui.tree;

import java.awt.*;
import java.awt.event.*;
import java.text.*;
import javax.swing.*;
import javax.swing.event.*;

import genius.core.issue.*;
import genius.core.utility.*;

/**
* @author Richard Noorlandt
* 
* Wouter: WeightSlider is a GUI component in the Tree,
* it is always there but may be invisible (if the objective/issue has no weight).
*/

public class WeightSlider extends JPanel implements ChangeListener, ItemListener {

        private static final long serialVersionUID = 4049454839954128143L;
        //Attributes
        static final int MIN_VALUE = 0;
        static final int MAX_VALUE = 1000;
        
        static final Color BACKGROUND = Color.white;
        
        //private Objective objective;
        //private Evaluator evaluator;
        private NegotiatorTreeTableModel tableModel;
        private Objective objective; // for which objective is this the weight slider
        private JCheckBox lock;
        private JSlider slider;
        private JFormattedTextField valueField;
        
        private double weight = 0; // < Might change, should probably be done from within objective, model or evaluator. Ony the question is: which?
        
        
        
        //Constructors
        
        //public WeightSlider(Objective obj) {
        public WeightSlider(NegotiatorTreeTableModel model, Objective obj) {
                tableModel = model;
                objective = obj;
                
                this.setBackground(BACKGROUND);
                this.setLayout(new FlowLayout());
                
                slider = new JSlider(MIN_VALUE, MAX_VALUE);
                //slider.setBackground(BACKGROUND);
                slider.setToolTipText("Drag to change the weight");
                slider.addChangeListener(this);
                this.add(slider);
                
                NumberFormat format = NumberFormat.getNumberInstance();
                format.setMaximumFractionDigits(2);
                valueField = new JFormattedTextField(format);
                valueField.setColumns(4);
                valueField.setToolTipText("Fill in a weight between 0 and 1");
                valueField.setEditable(false);
                this.add(valueField);
        
                lock = new JCheckBox();
                lock.setBackground(BACKGROUND);
                lock.setToolTipText("Lock weight");
                lock.addItemListener(this);
                this.add(lock);
                
                // Wouter: new code using the hasWeight field.
                boolean hasweight=true;
                AdditiveUtilitySpace us=tableModel.getUtilitySpace();
                if (us != null)
                {
                        Evaluator ev=us.getEvaluator(obj.getNumber());
                        //if (ev==null) System.out.println("no evaluator found for "+obj);
                        if (ev instanceof EvaluatorObjective) // should always be the case?? 
                                hasweight=((EvaluatorObjective)ev).getHasWeight();
                }
                setVisible(hasweight);

                
                //Added by Herbert
                if((tableModel.getUtilitySpace() != null) && tableModel.getUtilitySpace().getEvaluator(obj.getNumber())== null || obj.getName().equals("root")){
                        slider.setVisible(false);
                        valueField.setVisible(false);
                        lock.setVisible(false);
                }
        
                updatePreferredSize();
                
        }
        
        
        //Methods       
        
        /**
         * Sets this slider to be visible or invisible, dependent on whether there is an evaluator available. When there is no evaluator, the
         * slider wil always be invisible.
         * @param vis True makes the slider visible, false wil hide the slider.
         */
        public void setVisible(boolean vis){
                if(((tableModel.getUtilitySpace() != null) && (tableModel.getUtilitySpace().getEvaluator(objective.getNumber()) == null)) || (objective.getName().equals("root"))){
                        slider.setVisible(false);
                        valueField.setVisible(false);
                        lock.setVisible(false);
                }else{
                        slider.setVisible(vis);
                        valueField.setVisible(vis);
                        lock.setVisible(vis);
                }
        }
        
        /**
         * Converts an int between MIN_VALUE and MAX_VALUE to a double between 0 and 1. This method is
         * necessary because JSlider only works on int, and weights are doubles between 0 and 1.
         * @param value the value to be converted.
         * @return the value converted to a double.
         */
        private double convertToDouble(int value) {
                if (value < MIN_VALUE)
                        return 0;
                if (value > MAX_VALUE)
                        return 1;
                
                return (double)value / (double)( (MAX_VALUE) - MIN_VALUE);
        }
        
        /**
         * Converts a double between 0 and 1 to an int between MIN_VALUE and MAX_VALUE. This method is
         * necessary because JSlider only works on int, and weights are in doubles between 0 and 1.
         * @param value the value to e converted.
         * @return the value converted to an int between MIN_VALUE and MAX_VALUE.
         */
        private int convertToInt(double value) {
                if (value < 0)
                        return MIN_VALUE;
                if (value > 1)
                        return MAX_VALUE;
                
                return (int)(value*((double)MAX_VALUE - (double)MIN_VALUE)) + MIN_VALUE;
        }
        
        /**
         * 
         * @return the weight.
         */
        public double getWeight() {
                return weight;
        }
        
        /**
         * 
         * @param newWeight the new weight.
         */
        public void setWeight(double newWeight) {
                weight = newWeight;
                valueField.setValue(weight);
                slider.setValue(convertToInt(weight));
                // Wouter: try to call explicit treeStructureChanged after change.
                tableModel.treeNodesChanged(objective, objective.getPath().getPath());
        }
        
        public Objective getObjective() {
                return objective;
        }
        
        //public void setObjective(Objective obj) {
        //
        //}
        
        /**
         * Tries to set the new weight, and signals the NegotiatorTreeTableModel that weights are updated.
         * @param newWeight the new weight.
         */
        public void changeWeight(double newWeight) {
                weight = tableModel.getUtilitySpace().setWeight(objective, newWeight);
                tableModel.updateWeights(this, weight);
                setWeight(weight); //redundant

        }
        
        public void stateChanged(ChangeEvent e) {
                if (e.getSource() != slider){
                        return;
                }
                double newWeight = convertToDouble(slider.getValue());
                valueField.setValue(newWeight);
                changeWeight(newWeight);
        }
        
        /**
         * Implementation of ItemListener, which is registered on the checkbox. If the checkbox state changes,
         * the slider and textfield will be locked or unlocked. An unchecked checkbox means that the weight
         * can be changed.
         * @param e as defined by the ItemListener interface.
         */
        public void itemStateChanged(ItemEvent e) {
                if (e.getStateChange() == ItemEvent.SELECTED) {
                        slider.setEnabled(false);
                        valueField.setEnabled(false);
                        tableModel.getUtilitySpace().lock(objective);
                }
                //Otherwise, it is deselected
                else {
                        slider.setEnabled(true);
                        valueField.setEnabled(true);
                        tableModel.getUtilitySpace().unlock(objective);
                }
        }
        
        /**
         * Calculates and sets this objects preferred size, based on its subcomponents.
         *
         */
        protected void updatePreferredSize() {
                int prefHeight = lock.getPreferredSize().height;
                if (slider.getPreferredSize().height > prefHeight)
                        prefHeight = slider.getPreferredSize().height;
                if (valueField.getPreferredSize().height > prefHeight)
                        prefHeight = valueField.getPreferredSize().height;
                
                int prefWidth = lock.getPreferredSize().width +  slider.getPreferredSize().width + valueField.getPreferredSize().width;
                
                this.setPreferredSize(new Dimension(prefWidth, prefHeight));
        }
        
        public void forceRedraw(){
                try{
                this.changeWeight(this.getWeight());
                }catch(Exception e){
                        //do nothing, maybe we don't have a weight
                }
                this.setVisible(true);
                this.repaint();
        }
}