src/java/org/tsho/dmc2/ui/components/GetFloat.java

   1 /***************************************************************************
   2  * DMC, Dynamical Model Cruncher, simulates and analyzes low-dimensional
   3  * dynamical systems
   4  * Copyright (C) 2002   Alfredo Medio and Giampaolo Gallo
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2 of the License, or at your
   9  * option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * For a copy of the GNU General Public, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  18  * USA
  19  *
  20  * Contact:  Alfredo Medio   Medio@unive.it
  21  *
  22  * adapted by Daniele Pizzoni <auouo@tin.it>
  23  *
  24  ***************************************************************************/
  25 package org.tsho.dmc2.ui.components;
  26 import java.awt.Color;
  27 import java.io.Serializable;
  28
  29 import javax.swing.JTextField;
  30 import java.awt.event.*;
  31 import javax.swing.event.DocumentEvent;
  32 import javax.swing.event.DocumentListener;
  33 import javax.swing.text.BadLocationException;
  34 import javax.swing.text.Document;
  35
  36 import org.jfree.data.Range;
  37 import org.tsho.dmc2.ui.InvalidData;
  38
  39
  40 /**
  41  *  @author Giampaolo Gallo
  42  *  @author Daniele Pizzoni <auouo@tin.it>
  43  */
  44 public final class GetFloat extends JTextField implements Serializable {
  45     protected double value;
  46
  47     protected boolean valid;
  48     protected boolean outOfRange;
  49     protected boolean ignoreValid;
  50
  51     protected Range validRange;
  52
  53     protected String name = "field";
  54
  55     public static final String INVALID_FIELD_MESSAGE = "empty or not valid";
  56     public static final String INVALID_RANGE_FIELD_MESSAGE = "out of range";
  57
  58     public GetFloat() {
  59         super();
  60         init();
  61     }
  62
  63
  64     public GetFloat(int len) {
  65         super(len);
  66         init();
  67     }
  68
  69     public GetFloat(String name, int len, Range range) {
  70         super(len);
  71
  72         this.name = name;
  73         validRange = range;
  74         init();
  75     }
  76
  77     public GetFloat(String name, int len) {
  78         super(len);
  79
  80         this.name = name;
  81         init();
  82     }
  83
  84     public GetFloat(int len, double initialValue) {
  85         super(len);
  86         init();
  87         try {
  88             this.getDocument().insertString(
  89                 0,
  90                 new String(Double.toString(initialValue)),
  91                 null);
  92         }
  93         catch (BadLocationException e) {}
  94     }
  95
  96     private void init() {
  97         valid = false;
  98         ignoreValid = false;
  99         outOfRange = false;
 100
 101         this.getDocument().addDocumentListener(new MyDocumentListener());
 102
 103         addFocusListener(new FocusAdapter() {
 104             public void focusGained(FocusEvent evt) {
 105                 selectAll();
 106             }
 107         });
 108         //super.setBorder(BorderFactory.createLineBorder(null));
 109     }
 110
 111     public void syncText() {
 112         if (valid)
 113             setText(Double.toString(value));
 114         else
 115             setText("");
 116     }
 117
 118     public void syncValue() {
 119         String s = getText();
 120         try {
 121             value = Double.valueOf(s).doubleValue();
 122             valid = true;
 123         }
 124         catch (NumberFormatException e) {
 125             value = 0.0;
 126             valid = false;
 127         }
 128     }
 129
 130     public void setValue(double value) {
 131         this.value = value;
 132         setText(Double.toString(value));
 133     }
 134
 135     public double getValue() throws InvalidData {
 136         if (!valid && !ignoreValid) {
 137             if (outOfRange) {
 138                 String message = name
 139                        + ": "
 140                        + INVALID_RANGE_FIELD_MESSAGE
 141                        + " ("
 142                        + validRange.getLowerBound()
 143                        + " < "
 144                        +  validRange.getUpperBound()
 145                        + ")";
 146                 throw new InvalidData(message);
 147             }
 148             else {
 149                 InvalidData e=new InvalidData(name+": "+INVALID_FIELD_MESSAGE);
 150                 throw e;
 151             }
 152         }
 153
 154         return value;
 155     }
 156
 157     public boolean isValid() {
 158         return valid;
 159     }
 160
 161     private class MyDocumentListener implements DocumentListener {
 162         public void insertUpdate(DocumentEvent e) {
 163             update(e);
 164         }
 165         public void removeUpdate(DocumentEvent e) {
 166             update(e);
 167         }
 168         public void changedUpdate(DocumentEvent e) {}
 169
 170         private void update(DocumentEvent e) {
 171             Document d = (Document)e.getDocument();
 172             String s = null;
 173             try {
 174                 s = d.getText(0, d.getLength());
 175             }
 176             catch (BadLocationException e1) {}
 177
 178             if (s != null && s.length() > 0) {
 179                 try {
 180                     value = Double.valueOf(s).doubleValue();
 181                     valid = true;
 182                 }
 183                 catch (NumberFormatException e2) {
 184                     value = 0.0;
 185                     valid = false;
 186                     outOfRange = false;
 187                 }
 188
 189                 if (valid != false
 190                     && validRange != null && !validRange.contains(value)) {
 191
 192                     value = 0.0;
 193                     valid = false;
 194                     outOfRange = true;
 195                 }
 196
 197                 setForeground(valid ? Color.black : Color.red);
 198             }
 199             if (s.length() == 0) {
 200                 value = 0.0;
 201                 valid = false;
 202             }
 203         }
 204     }
 205         /**
 206          * @return
 207          */
 208         public boolean isIgnoreValid() {
 209                 return ignoreValid;
 210         }
 211
 212         /**
 213          * @param b
 214          */
 215         public void setIgnoreValid(boolean b) {
 216                 ignoreValid = b;
 217         }
 218 }