JTextField - Dokumentarten

IntegerDocument

Als erstes das IntegerDocument (es lässt euch nur Zahlen eingeben!)

<code=java> //zuerst wie es gesetzt wird JTextField tmp = new JTextField(); tmp.setDocument(new IntegerDocument());

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

public class IntegerDocument extends PlainDocument {

  public void insertString(int offset, String s, AttributeSet attributeSet) throws BadLocationException
   {
     try{
            Integer.parseInt(s);
        }
        catch(Exception ex)   //only allow integer values
        {
           Toolkit.getDefaultToolkit().beep(); //macht ein DßT
           //System.out.println("Keine Zahl!");
           return ;
        }
     super.insertString(offset,s, attributeSet);
   }

} </code=java> Dies ist ganz simple und ich glaube für jeden zu verstehen

DoubleDocument

Nun hier noch ein DoubleDocument (damit auch Kommazahlen funktionieren!)

<code=java> //Aufruf JTextField text = new JTextField(new DoubleDocument(text)); text.setText("12.10");

//andere Klasse

  public class DoubleDocument extends PlainDocument
 {
   private boolean bDot = false;
   private JTextField jtTxt = null;

   public DoubleDocument(JTextField txt)
   {
     this.jtTxt = txt;
   }

   public void insertString(int offset, String s, AttributeSet attributeSet) throws BadLocationException
   {
     bDot = jtTxt.getText().toString().indexOf(".") == -1 ? false : true;
     try{
       if(s.indexOf(".") != -1 && s.length() > 1) //überprüfe einen ganzen String und nicht 1 Zeichen
         bDot = true;
       System.out.println(">>>> 3 >> " + bDot);
       if(!s.equals(".")) //wenn es sich um keinen KommaPunkt handelt
         Double.parseDouble(s);
       else if(bDot)
         throw new Exception();
       else
         bDot = true;
     }
     catch(Exception ex)   //only allow integer values
     {
       Toolkit.getDefaultToolkit().beep(); //macht einen Ton
       //System.out.println("Keine Zahl!");
       return ;
     }
     super.insertString(offset,s, attributeSet);
   }
 }

</code=java>

DateDocument

Nun ein DateDocument, was schon bißchen schwieriger zu verstehen ist, weil man gewisse Abfragen hat...

<code=java> //zuerst, wie setze ich es JTextField tmp = new JTextField(); tmp.setDocument(new DateDocument(tmp));

import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.text.*; import java.awt.event.KeyEvent; import java.text.*; import java.util.Date; import java.util.GregorianCalendar;

public class DateDocument extends PlainDocument {

 public String initString = "yyyy MM dd";
 private int ivorher = 0;

 Date datum = new Date();
 private String str;
 private static int sep1 = 4, sep2 = 7;
 private JTextComponent textComponent;
 private int newOffset;

 /**
  * Überprüft eingegebenes Zeichen auf seine Gültigkeit->
  * Buchstaben oder sonstige Zeichen sind nicht zulässig
  * @param tc JTextComponent
  */
 public DateDocument(JTextComponent tc)
 {
   textComponent = tc;
   try{
        insertString(0,initString,null);
      }
      catch(Exception ex) {
         ex.printStackTrace();
      }
 }

 /**
  * Versucht das eingegebene Zeichen auf einen Integer zu parsen. Zusätzlich wird
  * überprüft, wo sich der Cursor befindet (womöglich vor einem Trennzeichen, das
  * übersprungen werden soll). Tage und Monate werden bereits während der Eingabe
  * auf ihre Gültigkeit (z.B. Tag: 32 -> falsch, Monat: 13 -> falsch) überprüft.
  * @param offset  Position im String (ist zu vergleichem mit dem Initialisierungsstring)
  * @param s       Zeichen, das überprüft wird
  * @param attributeSet  AttributeSet wird nur an die Vaterklasse weitergeleitet
  * @throws BadLocationException  wird geworfen, wenn das Zeichen nicht geparst werden kann
  */
 public void insertString(int offset, String s, AttributeSet attributeSet) throws BadLocationException
 {
    if(s.equals(initString))
       super.insertString(offset,s,attributeSet);
    else
    {
        try
        {
           //DateFormat format = DateFormat.getDateInstance();
           SimpleDateFormat format = new SimpleDateFormat(initString);
           format.setLenient(false);       //ßberprüfung auf korrektes Datum
           Date dDatum = format.parse(s);
           super.remove(0,textComponent.getText().length());
           super.insertString(offset,s,attributeSet);
        }
        catch(Exception ex)
        {
            try
            {
              Integer.parseInt(s);

              newOffset = offset;
              if(atSeparator(offset))
              {
                newOffset++;
                textComponent.setCaretPosition(newOffset);
              }
              if(!dateIsOk(//textComponent.getText(0,newOffset)+
              s,newOffset))
              {
                 Toolkit.getDefaultToolkit().beep();
                 return;
              }

              super.remove(newOffset,1);
              super.insertString(newOffset,s,attributeSet);
            }

            catch(Exception ex2)
            {
              return; //only allow integer values
            }
        }
    }
 }

 /**
  *
  * @param offset  Position im String (ist zu vergleichen mit dem Inititialisierungsstring)
  * @param length  Länge des Strings
  * @throws BadLocationException  Wenn eine Position nicht verwendet bzw. ermittelt werden kann
  */
 public void remove(int offset, int length) throws BadLocationException
 {
    if(atSeparator(offset))
      textComponent.setCaretPosition(offset-1);
    else textComponent.setCaretPosition(offset);
 }

 /**
  * @param offset Position im String (ist zu vergleichen mit dem Initialisierungsstring)
  * @return boolean, true für Separater ist am offset, false für kein Separator
  */
 public boolean atSeparator(int offset)
 {
    return offset == sep1 || offset == sep2; //false
 }

 /**
  * Überprüft das eingegebene Datum auf seine Richtigkeit
  * @param txtDate  Zeichen (als String), das überprüft wird
  * @param off      Offset des Zeichens
  * @return         true für Datum ist ok, false für nicht möglich
  */
private boolean dateIsOk(String txtDate,int off)
{
  boolean ret = false;
  int curScan = 0;
  String cur = "";
  int len = 0;
  len = off+1;
  String svorher ="";
  String s ="";
  if(len < 1)
    curScan = 0;
  else curScan = len -1;

  try{
      s = initString.substring(len-1, len);
     if(curScan != 0)
        svorher = initString.substring(curScan-1, len-1);
     else
        svorher = "F";
     int izahl = Integer.parseInt(txtDate);

     if (s.compareTo("M")== 0)
     {
       if (svorher.compareTo("M") != 0)
       {
         if (izahl > 1)
           ret = false;
         else
           ret = true;
         ivorher = izahl;
       }
       else {
           if (ivorher == 1 && izahl > 2)
             ret = false;
           else if(ivorher == 0 && izahl == 0)
             ret = false;
           else
             ret = true;
           }
     }
     if (s.compareTo("d")==0 || s.compareTo("D")==0)
     {
       if (svorher.compareTo("d") !=0 && svorher.compareTo("D") !=0 )
       {
         if (izahl > 3)
           ret = false;
         else
           ret = true;
       ivorher = izahl;
       }
       else {
         if (ivorher == 3 && izahl > 1)
           ret = false;
         else if(ivorher == 0 && izahl == 0)
           ret = false;
         else
           ret = true;

       }
     }
     if(s.compareTo("y") == 0 || s.compareTo("Y")==0)
     {
       ret = true;
     }

   }catch(Exception ex){
     //ex.printStackTrace(System.out);   //soll nicht geworfen werden, weil Jahre noch nicht überprüft werden
                               //bringt Error, wenn an letzter Stelle noch Ziffer eingegeben wird.
   }
   finally{
     return ret;
   }
 }

} </code=java> Am besten ist, ihr spielt erst mal mit dem Integerdocument rum, wenn ihr das Datedocument noch nicht versteht.

NegativeDoubleDocument

Das DefaultKommazeichen ist ein . und er wandelt die , in einen Punkt um (auch während der Eingabe). Zuweisen geht wie beim "normalen" DoubleDocument -> DoubleDocument(JTextField) also.

<code=java> JTextField myField = new JTextField(); myField.setDocument(new NegativeDoubleDocument()); myField.setText("110000,100"); myField.setText("-200,20"); //das geht auch, alle "," werden durch "." ersetzt </code=java>

Nun noch der Code von NegativeDoubleDocument. <code=java> import javax.swing.text.PlainDocument; import javax.swing.text.AttributeSet; import javax.swing.text.BadLocationException; import javax.swing.JTextField; import java.awt.Toolkit;

public class NegativeDoubleDocument extends PlainDocument {

 private boolean bDot = false;
      /***************************************************************************
      * Funktion erlaubt ein minus oder + (nicht sichtbar) in den Zahlen
      * @param offset int
      * @param s string
      * @param attributeSet att
      * @throws BadLocationException
      **************************************************************************/
     public void insertString(int offset, String s, AttributeSet attributeSet) throws
         BadLocationException
     {
       try
           {
             if(s.equals(",")) //ersetzt den , durch einen Punkt
               s = ".";
             bDot = getText(0,getLength()).indexOf(".") == -1 ? false : true; //merkt sich ob ein Punkt oder nicht
             if (s.length() > 1)
             {
               //wenn der String größer als 1 ist, ist es eine ganze IP und somit eine Schleife
               for(int x = 0; x != s.length(); x++)
                 insertString(x,s.substring(x,x+1).replaceFirst(",","."),null); //ersetzt , durch Punkt
               //mach gar nix, weil die for schleife alles macht!
                 return;
             }
             else if(s.equals("-"))
             {
               String strTmp = getText(0,getLength()); //holt sich den Text
               System.out.println(strTmp);
               if(strTmp.indexOf("-")!=-1) //schaut nach ob ein minus vorhanden ist
                 strTmp = strTmp.replaceAll("-",""); //wenn ja weg
               else
                 strTmp = "-" + strTmp;
               replace(0,getLength(),null,attributeSet);
               super.insertString(0,strTmp,attributeSet);
               return;
             }
             else if(s.equals("+")) //bei einem + einfach ein weiteres - hinzufügen
             {
               if(getText(0,getLength()).indexOf("-")!=-1)
                 insertString(0,"-",attributeSet); //ruft sich selbst mit - auf und dann kommt obige ßberprüfung
               return;
             }
             //OPTIONAL!! STATT DEM ± kann man jedes Zeichen nehmen oder komplett weglassen
             //wenn man irgendwelche Zeichen zB noch haben will