001    /* $Id: VariableRangeSlider.java 12 2007-07-27 09:48:53Z ringler $
002     * This class is part of the de.mospace.swing library.
003     * Copyright (C) 2005-2006 Moritz Ringler
004     *
005     * This program is free software; you can redistribute it and/or
006     * modify it under the terms of the GNU General Public License
007     * as published by the Free Software Foundation; either version 2
008     * of the License, or (at your option) any later version.
009     *
010     * This program is distributed in the hope that it will be useful,
011     * but WITHOUT ANY WARRANTY; without even the implied warranty of
012     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
013     * GNU General Public License for more details.
014     *
015     * You should have received a copy of the GNU General Public License
016     * along with this program; if not, write to the Free Software
017     * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
018     */
019    package de.mospace.swing;
020    
021    import java.awt.BorderLayout;
022    import java.awt.Dimension;
023    import java.awt.event.ActionEvent;
024    import java.awt.event.ActionListener;
025    import java.awt.event.KeyEvent;
026    import java.beans.PropertyChangeEvent;
027    import java.beans.PropertyChangeListener;
028    import java.text.DecimalFormat;
029    import java.text.DecimalFormatSymbols;
030    import java.text.ParseException;
031    import java.util.ArrayList;
032    import java.util.Iterator;
033    import java.util.List;
034    import java.util.Locale;
035    import javax.swing.AbstractAction;
036    import javax.swing.JFormattedTextField;
037    import javax.swing.JLabel;
038    import javax.swing.JPanel;
039    import javax.swing.JSlider;
040    import javax.swing.JSpinner;
041    import javax.swing.KeyStroke;
042    import javax.swing.SpinnerNumberModel;
043    import javax.swing.Timer;
044    import javax.swing.event.ChangeEvent;
045    import javax.swing.event.ChangeListener;
046    
047    /** A JSlider whose range and
048     *  central value can be modified by the user.
049     *
050     *  @version $Revision: 12 $ ($Date: 2007-07-27 11:48:53 +0200 (Fr, 27 Jul 2007) $)
051     *  @author Moritz Ringler
052     **/
053    public class VariableRangeSlider extends JPanel {
054    
055        /** A constant holding the maximum value allowed for
056         *  logrange in {@link #setLogRange(int) setLogRange(int)}.
057         **/
058        public final static int    MAX_LOG_RANGE     =
059                 (int) (Math.log(Double.MAX_VALUE)/Math.log(10.) - 1.);
060    
061        /** A constant holding the minimum value allowed for
062         *  logrange in {@link #setLogRange(int) setLogRange(int)}.
063         **/
064        public final static int    MIN_LOG_RANGE     = - MAX_LOG_RANGE;
065    
066        /** A constant holding the largest positive finite
067         *  value the slider can assume. **/
068    
069        public final static double MAX_VALUE = Double.MAX_VALUE/10.;
070        /** A constant holding the smallest positive nonzero value
071         *  the slider can assume.
072         **/
073        public final static double MIN_VALUE = Double.MIN_VALUE*10.;
074    
075        /** The NumberFormat used to output the slider value.
076         **/
077        public final static DecimalFormat NUMBER_FORMAT =
078                new DecimalFormat("##0.#E0",        new DecimalFormatSymbols(Locale.US));
079        /** The slider will have 2 halfgridsize + 1 steps.
080         **/
081        private int halfgridsize = 100;
082    
083        /** The internal JSlider of the VariableRangeSlider.
084         **/
085        protected JSlider slider = new JSlider(JSlider.VERTICAL, -halfgridsize,
086                halfgridsize,0);
087    
088        /** The JTextField used to set and print the value of the slider.
089         **/
090        protected JFormattedTextField value =
091                new JFormattedTextField(NUMBER_FORMAT);
092    
093        /** The JSpinner used to set the power of ten that corresponds to
094         *  half the slider length.
095         **/
096        protected JSpinner range = new JSpinner(new SpinnerNumberModel(1,
097                MIN_LOG_RANGE, MAX_LOG_RANGE, 1));
098    
099        /** The List that holds all registered changeListeners. */
100        private final List changeListeners = new ArrayList();
101    
102            /** Tells the slider change listener whether the change is caused
103            by a slider reset. **/
104            private boolean isReset = false;
105        //It is necessary to use this timer because otherwise the user interface
106        //isn't properly updated when the slider is reset after dragging it with
107        //the mouse. This is ugly. Change it if you find a way.
108        /** Timer that resets the slider 1
109         *  milliseconds after it has been released.
110         **/
111        private final Timer resetSlider = new Timer(1, new ActionListener() {
112            public void actionPerformed(ActionEvent evt) {
113                isReset = true;
114                slider.setValueIsAdjusting(true);
115            slider.setValue(0);
116            slider.setValueIsAdjusting(false);
117            isReset = false;
118                resetSlider.stop();
119            }
120        });
121        private Dimension preferredSize;
122    
123    
124        /**
125         * Constructs a new slider with central value 0,
126         * range -10 to 10 and gridsize 201.
127         */
128        public VariableRangeSlider() {
129            value.setValue((Number) new Double(0.0));
130            initComponents();
131            configureUI();
132        }
133    
134        /**
135         * Constructs a new slider with the given central value,
136         * and range &#177;10<sup>logrange</sup> and gridsize 101.
137         */
138        public VariableRangeSlider(double value, int logrange){
139            setLogRange(logrange);
140            setValue(value);
141            initComponents();
142            configureUI();
143        }
144    
145        /** Coordinates the child components and determines when a ChangeEvent
146         *  is fired by adding appropriate EventListeners.
147         */
148        private void initComponents(){
149    
150            //text field
151            value.addPropertyChangeListener(new PropertyChangeListener(){
152                public void propertyChange(PropertyChangeEvent e) {
153                    if ("value".equals(e.getPropertyName())) {
154                        Number value = (Number) e.getNewValue();
155                        if (slider != null && value != null) {
156                            slider.setValue(0);
157                            fireStateChanged();
158                        }
159                    }
160                }
161            });
162            value.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,
163                    0),"check");
164            value.getActionMap().put("check", new AbstractAction(){
165                public void actionPerformed(ActionEvent e) {
166                    if (!value.isEditValid()) {
167                        value.selectAll();
168                    } else try {
169                        value.commitEdit();
170                    } catch (ParseException exc) { }
171                }
172            });
173    
174            //slider
175            slider.addChangeListener(new ChangeListener(){
176                public void stateChanged(ChangeEvent e){
177                    //Do nothing when the change is due to
178                    //a re-centering (reset) of the JSlider
179                //MIGHT LEAD TO WRONG BEHAVIOUR!
180                    if(isReset){
181                    return;
182                    }
183                    // Slider is moving
184                    // -> update the *text* of the formatted text field
185                    //    and make VariableRangeSlider fire a ChangeEvent
186                //if (slider.getValueIsAdjusting() && !isReset){
187                    if (slider.getValueIsAdjusting()){
188                        value.setText(getFormattedValue());
189                        fireStateChanged();
190                    }
191                    // Value has been changed with the slider
192                    // and slider has been released.
193                    // -> update the *value* of the formatted text field
194                    //    and reset slider to central position
195                    // Here the the formatted text field will make
196                    // the VariableRangeSlider fire a ChangeEvent after
197                    // the slider has been reset to zero.
198                    else if(slider.getValue() != 0){
199                        setTextFieldFromSlider();
200                    }
201                    // Slider rests and is in central position
202                    // -> do nothing
203                    //else if (getValue() == 0){
204                    //      return;
205                    //}
206                }
207            });
208        }
209    
210        /** Sets up the user interface of the slider.
211         **/
212        private void configureUI(){
213            //JTextField
214            value.setColumns(5);
215            value.setHorizontalAlignment(JFormattedTextField.RIGHT);
216    
217            //JSpinner
218            range.setPreferredSize(new Dimension(40,20));
219            ((JSpinner.DefaultEditor) range.getEditor()).getTextField().
220                setHorizontalAlignment(JFormattedTextField.LEFT);
221            JLabel spinnerLabel = new JLabel("\u00b11e");
222            JPanel spinnerPanel = new JPanel(new BorderLayout());
223            spinnerPanel.add(spinnerLabel, BorderLayout.WEST);
224            spinnerPanel.add(range, BorderLayout.CENTER);
225    
226            //this
227            setLayout(new BorderLayout());
228            add(slider, BorderLayout.CENTER);
229            add(value, BorderLayout.NORTH);
230            add(spinnerPanel, BorderLayout.SOUTH);
231    
232            //calculate the size of this component;
233            int[] x = new int[3];
234            x[0] = value.getPreferredSize().width;
235            x[1] = slider.getPreferredSize().width;
236            x[2] = range.getPreferredSize().width +
237                   spinnerLabel.getPreferredSize().width;
238            int xx = (x[0] > x[1]) ? x[0] : x[1];
239            if(x[2] > xx){
240                xx = x[2];
241            }
242            int y = value.getPreferredSize().height +
243                    slider.getPreferredSize().height +
244                    range.getPreferredSize().height;
245            preferredSize = new Dimension(xx,y);
246        }
247    
248        /** Reads the internal slider value and transfers it to the text field.
249         **/
250        private void setTextFieldFromSlider(){
251            double r  = Math.pow(10, (double) getLogRange());
252            double o = slider.getValue()*1./halfgridsize * r;
253            try{
254                setValue(((Number) value.getValue()).doubleValue()+o);
255            } catch (IllegalArgumentException ex){
256                slider.setValue(0);
257            }
258        }
259    
260        /** Sets the value of the slider to d and makes
261         * it resume a central position.
262         * @param d a legal double value
263         * @throws java.lang.IllegalArgumentException when d is out of range
264         * @see #MAX_VALUE
265         * @see #MIN_VALUE
266         **/
267         public void setValue(double d){
268            double r = (d>0)?d:-d;
269            if(r>MAX_VALUE/10 || (r<MIN_VALUE*10 && r != 0)){
270                throw new IllegalArgumentException(d + "is out of range!");
271            }
272            value.setValue((Number) new Double(d));
273            resetSlider.start();
274        }
275    
276        /** Gets the current value of the slider.
277         *  @return the value of the slider
278         **/
279        public double getValue(){
280            if (!slider.getValueIsAdjusting()){
281                return ((Number) value.getValue()).doubleValue();
282            } else {
283                double r  = Math.pow(10, (double) getLogRange());
284                double o = slider.getValue()*1./halfgridsize * r;
285                return ((Number) value.getValue()).doubleValue() + o;
286            }
287        }
288    
289        /** Gets the current value of the slider as a formatted String.
290         *  @return the value of the slider
291         *  @see #NUMBER_FORMAT
292         **/
293         public String getFormattedValue(){
294            return NUMBER_FORMAT.format(getValue());
295         }
296    
297    
298        /** Sets the number of steps used for the slider.
299         *  @param i will automatically be converted to an odd integer >= 3.
300         **/
301        public void setGridsize(int i){
302            //ensure gridsize makes sense;
303            if (i < 0){
304                i = - i;
305            }
306            if (i < 3){
307                i = 3;
308            }
309            halfgridsize = i/2; //integer division!!
310        }
311    
312        /** Gets the number of steps used for the slider.
313         *  @return the number of steps
314         **/
315        public int getGridsize(){
316            return halfgridsize*2+1;
317        }
318    
319        /** Sets the power of ten that corresponds to half the slider length.
320         *  @param lr log10 of the desired range
321         **/
322        public void setLogRange(int lr){
323            if(lr>MAX_LOG_RANGE || lr<MIN_LOG_RANGE){
324                throw new IllegalArgumentException(lr + " is out of range!");
325            } else {
326                range.setValue(new Integer(lr));
327            }
328        }
329    
330        /** Gets the power of ten that corresponds to half the slider length.
331         *  @return log10 of the current range
332         **/
333        public int getLogRange(){
334            return ((Integer) range.getValue()).intValue();
335        }
336    
337        /**
338         * Adds a <code>ChangeListener</code> to the slider.
339         * @param l the listener to be added
340         */
341        public synchronized void addChangeListener(ChangeListener l){
342            changeListeners.add( l );
343        }
344    
345        /**
346         * Removes a ChangeListener from the slider.
347         * @param l the listener to be removed
348         */
349        public synchronized void removeChangeListener(ChangeListener l ){
350            changeListeners.remove( l );
351        }
352    
353        /**
354         * Notifies all registered ChangeListeners.
355         */
356        protected synchronized void fireStateChanged(){
357            ChangeEvent e = new ChangeEvent(this);
358            Iterator listenersIt = changeListeners.iterator();
359            while(listenersIt.hasNext()){
360                ((ChangeListener) listenersIt.next()).stateChanged(e);
361            }
362        }
363    
364        /**
365         * Overrides method in superclass
366         * {@link java.awt.Component#getPreferredSize() java.awt.Component}.
367         */
368        public Dimension getPreferredSize(){
369            return preferredSize;
370        }
371    
372         /**
373         * Overrides method in superclass
374         * {@link java.awt.Component#getMinimumSize() java.awt.Component}.
375         */
376        public Dimension getMinimumSize(){
377            return getPreferredSize();
378        }
379    
380        /**
381         * Overrides method in superclass {@link java.awt.Component#preferredSize()
382         * java.awt.Component}.
383         * @deprecated
384         * @see #getPreferredSize
385         */
386        public Dimension preferredSize(){
387            return getPreferredSize();
388        }
389    
390        /**
391         * Overrides method in superclass
392         * {@link java.awt.Component#minimumSize() java.awt.Component}.
393         * @deprecated
394         * @see #getMinimumSize
395         */
396        public Dimension minimumSize(){
397            return getPreferredSize();
398        }
399    }