JTextField - Dokumentarten: Unterschied zwischen den Versionen

Aus Byte-Welt Wiki
Zur Navigation springenZur Suche springen
K
Zeile 2: Zeile 2:
 
Als erstes das IntegerDocument (es lässt euch nur Zahlen eingeben!)
 
Als erstes das IntegerDocument (es lässt euch nur Zahlen eingeben!)
  
<code=java>
+
<syntaxhighlight lang="java">
 
//zuerst wie es gesetzt wird
 
//zuerst wie es gesetzt wird
 
JTextField tmp = new JTextField();
 
JTextField tmp = new JTextField();
Zeile 28: Zeile 28:
 
     }
 
     }
 
}
 
}
</code=java>
+
</syntaxhighlight>
 
Dies ist ganz simple und ich glaube für jeden zu verstehen
 
Dies ist ganz simple und ich glaube für jeden zu verstehen
  
Zeile 35: Zeile 35:
 
Nun hier noch ein DoubleDocument (damit auch Kommazahlen funktionieren!)
 
Nun hier noch ein DoubleDocument (damit auch Kommazahlen funktionieren!)
  
<code=java>
+
<syntaxhighlight lang="java">
 
//Aufruf
 
//Aufruf
 
JTextField text = new JTextField(new DoubleDocument(text));
 
JTextField text = new JTextField(new DoubleDocument(text));
Zeile 75: Zeile 75:
 
     }
 
     }
 
   }
 
   }
</code=java>
+
</syntaxhighlight>
  
  
Zeile 81: Zeile 81:
 
Nun ein DateDocument, was schon bißchen schwieriger zu verstehen ist, weil man gewisse Abfragen hat...
 
Nun ein DateDocument, was schon bißchen schwieriger zu verstehen ist, weil man gewisse Abfragen hat...
  
<code=java>
+
<syntaxhighlight lang="java">
 
//zuerst, wie setze ich es
 
//zuerst, wie setze ich es
 
JTextField tmp = new JTextField();
 
JTextField tmp = new JTextField();
Zeile 281: Zeile 281:
 
   }
 
   }
 
}
 
}
</code=java>
+
</syntaxhighlight>
 
Am besten ist, ihr spielt erst mal mit dem Integerdocument rum, wenn ihr das Datedocument noch nicht versteht.
 
Am besten ist, ihr spielt erst mal mit dem Integerdocument rum, wenn ihr das Datedocument noch nicht versteht.
  
Zeile 289: Zeile 289:
 
Zuweisen geht wie beim "normalen" DoubleDocument -> <code>DoubleDocument(JTextField)</code> also.
 
Zuweisen geht wie beim "normalen" DoubleDocument -> <code>DoubleDocument(JTextField)</code> also.
  
<code=java>
+
<syntaxhighlight lang="java">
 
JTextField myField = new JTextField();
 
JTextField myField = new JTextField();
 
myField.setDocument(new NegativeDoubleDocument());
 
myField.setDocument(new NegativeDoubleDocument());
 
myField.setText("110000,100");
 
myField.setText("110000,100");
 
myField.setText("-200,20"); //das geht auch, alle "," werden durch "." ersetzt
 
myField.setText("-200,20"); //das geht auch, alle "," werden durch "." ersetzt
</code=java>
+
</syntaxhighlight>
  
 
Nun noch der Code von NegativeDoubleDocument.
 
Nun noch der Code von NegativeDoubleDocument.
<code=java>
+
<syntaxhighlight lang="java">
 
import javax.swing.text.PlainDocument;
 
import javax.swing.text.PlainDocument;
 
import javax.swing.text.AttributeSet;
 
import javax.swing.text.AttributeSet;
Zeile 375: Zeile 375:
 
     }
 
     }
 
}
 
}
</code=java>
+
</syntaxhighlight>
  
  
Zeile 382: Zeile 382:
  
 
Wir könnten einen DocumentFilter setzen, etwa so:
 
Wir könnten einen DocumentFilter setzen, etwa so:
<code=java>
+
<syntaxhighlight lang="java">
 
int MAX = 8;
 
int MAX = 8;
 
JTextField textfield = new JTextField(MAX);
 
JTextField textfield = new JTextField(MAX);
 
((AbstractDocument) textfield.getDocument()).setDocumentFilter(new DocumentSizeFilter(MAX, "[A-Za-z]+"));
 
((AbstractDocument) textfield.getDocument()).setDocumentFilter(new DocumentSizeFilter(MAX, "[A-Za-z]+"));
</code=java>
+
</syntaxhighlight>
  
<code=java>
+
<syntaxhighlight lang="java">
 
import javax.swing.text.*;
 
import javax.swing.text.*;
 
import java.awt.*;
 
import java.awt.*;
Zeile 412: Zeile 412:
 
     }
 
     }
 
}
 
}
</code=java>
+
</syntaxhighlight>
  
 
[[Kategorie:Java]]
 
[[Kategorie:Java]]

Version vom 10. März 2018, 13:51 Uhr

IntegerDocument

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

//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);
    }
}

Dies ist ganz simple und ich glaube für jeden zu verstehen


DoubleDocument

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

//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);
    }
  }


DateDocument

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

//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;
    }
  }
}

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.

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

Nun noch der Code von NegativeDoubleDocument.

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 <!--- OPTIONAL ---!>
              else if(s.equals("±"))
              {
                String strTmp = getText(0,offset);
                if(strTmp.indexOf("±") != -1)
                  strTmp = strTmp.replaceAll("±","");
                else
                  strTmp = "±" + strTmp;
                replace(0,getLength(),null,attributeSet);
                super.insertString(0,strTmp,attributeSet);
                return; //damit aufgehört wird
              }
              //ENDE OPTIONAL!!
             //wenn das aktuelle Zeichen kein punkt ist oder wenn es ein Punkt ist und schon ein Punkt eingegegeben ist
              else if(!s.equals(".") || bDot)  // ==   if(!(s.equals(".") && !bDot))
                Double.parseDouble(s);
            }
            catch(Exception ex)
            {
              Toolkit.getDefaultToolkit().beep();
              return;
            }
            super.insertString(offset,s, attributeSet);
          }
    }
}


DocumentFilter

Zitat: "Ich will ein JTextField so verändern, dass man maximal 8 Zeichen eingeben kann und nur Groß- und kleinbuchstaben zugelassen sind (also keine Sonderzeichen, Punkte, usw.)."

Wir könnten einen DocumentFilter setzen, etwa so:

int MAX = 8;
JTextField textfield = new JTextField(MAX);
((AbstractDocument) textfield.getDocument()).setDocumentFilter(new DocumentSizeFilter(MAX, "[A-Za-z]+"));
import javax.swing.text.*;
import java.awt.*;
import javax.swing.*;

public class DocumentSizeFilter extends DocumentFilter {
    private final int maxCharacters;
    private final String pattern;

    public DocumentSizeFilter(final int maxChars, final String pattern) {
        maxCharacters = maxChars;
        this.pattern = pattern;
    }

    @Override
    public void replace(FilterBypass fb, int offs, int length, String str, AttributeSet a)
            throws BadLocationException {
        if (str.matches(pattern) && (fb.getDocument().getLength() + str.length() - length) <= maxCharacters) {
            super.replace(fb, offs, length, str, a);
        } else {
            Toolkit.getDefaultToolkit().beep();
        }
    }
}

--thE_29 (26.08.2004)