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 ±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 }