// Copyright 2005, FreeHEP.
   package hep.wired.util;
   
   import java.awt.*;
   import java.awt.event.*;
   import java.beans.*;
   import java.util.*;
   import java.text.*;
   
  import javax.swing.*;
  import javax.swing.event.*;
  import javax.swing.plaf.*;
  
  import org.freehep.swing.layout.TableLayout;
  import org.freehep.util.ScientificFormat;
  
  /***
   * FIXME WIRED-440 Should move to freehep-swing ?
   *
   * @author Mark Donszelmann
   * @version $Id: NumberSlider.java 2026 2005-07-08 23:31:30Z duns $
   */
  public class NumberSlider extends JSlider {
      
  /* FIXME WIRED-441, should be NumberFormat */
      private Format format;
      
      private BoundedDoubleRangeModel model;
      
      // For testing purposes
      public NumberSlider() {
          this(NumberSlider.VERTICAL, -40, 360, 0);
      }
      
      public NumberSlider(int orientation, double min, double max, double def) {
          this(orientation, min, max, def, false);
      }
      
      public NumberSlider(int orientation, double min, double max, double def, boolean log) {
          super(orientation);
          
          setModel(new DefaultBoundedDoubleRangeModel(def, 0, min, max, log));
                 
          setFormat(new ScientificFormat(2, 8, false));
          
          int ticks = model.isLogarithmic() ? (int)Math.round(DefaultBoundedDoubleRangeModel.log10(max)) - (int)Math.round(DefaultBoundedDoubleRangeModel.log10(min)) 
                                            : 10;
          int increment = model.getMaximum() / ticks;
  
          setMajorTickSpacing(increment);
          if (!log) setMinorTickSpacing(getMajorTickSpacingDouble()/2);
          setPaintTicks(true);  
          setLabelTable(createStandardLabels(increment, 100.0));
          setPaintLabels(true);
              
          setPaintTrack(true);
  
          addChangeListener(new ChangeListener() {
              public void stateChanged(ChangeEvent event) {
                  setToolTipText(String.valueOf(getValueDouble()));
              }
          });
  
          reset();
      }
  
      public void setModel(BoundedDoubleRangeModel model) {
          super.setModel(model);
          this.model = model;
      }
  
      public void reset() {
          setValue(model.getDefaultValueDouble());
      }
  
  /* FIXME WIRED-441 Should be NumberFormat */
      public Format getFormat() {
          return format;
      }
      
  /* FIXME WIRED-441 Should be NumberFormat */
      public void setFormat(Format format) {
          if (!(format instanceof ScientificFormat) && !(format instanceof NumberFormat)) throw new RuntimeException("Format needs to be ScientificFormat or NumberFOrmat"); 
          this.format = format;
      }
      
      public boolean isLogarithmic() {
          return model.isLogarithmic();
      }
      
      public void setLogarithmic(boolean log) {
          model.setLogarithmic(log);
          
          if (log) {
              setMinorTickSpacing(0.0);
          }
      }
      
      public void setMajorTickSpacing(double d) {
         super.setMajorTickSpacing((int)(d / model.getFactor()));
     }
     
     public double getMajorTickSpacingDouble() {
         return super.getMajorTickSpacing() * model.getFactor();
     }
         
     public void setMinorTickSpacing(double d) {
         super.setMinorTickSpacing((int)(d / model.getFactor()));
     }
     
     public double getMinorTickSpacingDouble() {
         return super.getMinorTickSpacing() * model.getFactor();
     }
       
     public void setExtent(double d) {
         model.setExtent(d);
     }
     
     public double getExtentDouble() {
         return model.getExtentDouble();
     }
              
     public double getValueDouble() {
         return model.getValueDouble();
     }
             
     public void setValue(double value) {
         model.setValue(value);
     }
     
     public double getMinimumDouble() {
         return model.getMinimumDouble();
     }
     
     public void setMinimum(double min) {
         model.setMinimum(min);
     }
     
     public double getMaximumDouble() {
         return model.getMaximumDouble();
     }
     
     public void setMaximum(double max) {
         model.setMaximum(max);
     }       
 
     private String format(double value) {
         if (format instanceof NumberFormat) {
             return ((NumberFormat)format).format(value);
         } else if (format instanceof ScientificFormat) {
             return ((ScientificFormat)format).format(value);
         }
         return ""+value;
     }
 
     public Hashtable createStandardLabels(double increment) {
         return createStandardLabels(increment, getMinimumDouble());
     }
 
     public Hashtable createStandardLabels(double increment, double value) {
         return createStandardLabels((int)(increment / model.getFactor()), value);
     }
 
     public Hashtable createStandardLabels(int increment, int value) {
         return createStandardLabels(increment, (double)value);
     }
 
     public Hashtable createStandardLabels(int increment) {
         return createStandardLabels(increment, getMinimumDouble());
     }
 
     public Hashtable createStandardLabels(int increment, double value) {
         if ( value > getMaximumDouble() || value < getMinimumDouble() ) {
             throw new IllegalArgumentException( "Slider label value point out of range." );
         }
 
         if ( increment <= 0 ) {
             throw new IllegalArgumentException( "Label incremement must be > 0" );
         }
 
         class SmartHashtable extends Hashtable implements PropertyChangeListener {
             int increment = 0;
             double value = 0;
 
             class LabelUIResource extends JLabel implements UIResource {
                 public LabelUIResource( String text, int alignment ) {
                     super( text, alignment );
                     setName("Slider.label");
                 }
             }
 
             public SmartHashtable( int increment, double value ) {
                 super();
                 this.increment = increment;
                 this.value = value;
                 createLabels();
             }
 
             public void propertyChange( PropertyChangeEvent e ) {
                 if ( e.getPropertyName().equals( "minimum" ) ||
                      e.getPropertyName().equals( "maximum" ) ) {
 
                     Enumeration keys = getLabelTable().keys();
                     Object key = null;
                     Hashtable hashtable = new Hashtable();
 
                     // Save the labels that were added by the developer
                     while ( keys.hasMoreElements() ) {
                         key = keys.nextElement();
                         Object value = getLabelTable().get( key );
                         if ( !(value instanceof LabelUIResource) ) {
                             hashtable.put( key, value );
                         }
                     }
 
                     clear();
                     createLabels();
 
                     // Add the saved labels
                     keys = hashtable.keys();
                     while ( keys.hasMoreElements() ) {
                         key = keys.nextElement();
                         put( key, hashtable.get( key ) );
                     }
 
                     ((JSlider)e.getSource()).setLabelTable( this );
                 }
             }
 
             void createLabels() {
                 int labelStart = getMinimum();
                 int labelMaximum = getMaximum();
                 for ( int labelIndex = labelStart; labelIndex <= labelMaximum; labelIndex += increment ) {
                     put( new Integer( labelIndex ), new LabelUIResource( format(model.getValueAt(labelIndex)), JLabel.CENTER ) );
                 }
             }
         }
 
         SmartHashtable table = new SmartHashtable( increment, value );
 
         if ( getLabelTable() != null && (getLabelTable() instanceof PropertyChangeListener) ) {
             removePropertyChangeListener( (PropertyChangeListener)getLabelTable() );
         }
 
         addPropertyChangeListener( table );
 
         return table;
     }
 
     private static void add(JPanel p, final NumberSlider s) {
         s.addChangeListener(new ChangeListener() {
             public void stateChanged(ChangeEvent e) {
                 System.err.println(e.getSource().hashCode()+" "+s.getValueDouble());  
             }
         });
         p.add(s);
     }
 
 /*
     public static void main(String[] args) {
         JPanel p = new JPanel();
         p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));
         
         add(p, new NumberSlider(NumberSlider.VERTICAL, -40, 360, 0));
         add(p, new NumberSlider(NumberSlider.VERTICAL, 0, 2000, 100));
         add(p, new NumberSlider(NumberSlider.VERTICAL, -100, 0, -30));
         add(p, new NumberSlider(NumberSlider.VERTICAL, -0.01, 0.03, 0));
         add(p, new NumberSlider(NumberSlider.VERTICAL, 0, 0.00001, 0));
         add(p, new NumberSlider(NumberSlider.VERTICAL, 0.01, 1000, 200));
         NumberSlider n = new NumberSlider(NumberSlider.VERTICAL, 0.01, 1000, 200, true);
         n.setLogarithmic(true);
         add(p, n);
         
         JFrame f = new JFrame();
         f.getContentPane().add(p);
         f.setSize(800, 600);
         f.show();
     }    
 */
 }