CaretListener

[Saban]

Morgen!

ich will eine JTextArea eingrenzen, also nach z. B. 10 Zeichen soll eine neue Zeile erzwungen werden und noch 100 Zeichen also 10 Zeilen soll die Eingabe des Users ignoriert werden. Nun hab ich auf paar Seiten was von einem CaretListener gehört, welcher für mein Vorhaben perfekt geeignet sein soll. Ich find leider nur keine Seite wo der CaretListener und seine Funktionen beschrieben werden ich hab bis jetzt nur was von einem CaretUpdate gelesen...

Kann mir jemand vllt eine nützliche ANFÄNGERFREUNDLICHE seite posten

Danke im voraus!

Grüße

Saban

[Dragon8]

Die Java Doku ist zwar nun wahrscheinlich nicht die anfängerfreundlichste seite, aber ich finde, der eine Satz der dort zum CaretListener steht reicht eigentlich aus.

Jedes mal wenn der Cursor in der Textarea seine Position verändert wird die Methode des Listeners ausgelöst. Ob das nun die perfekte Methode ist um dein Problem zu lösen, bezweifle ich leider gerade etwas, weil die Veränderung der Cursor Position ja nicht unbedingt heißt, dass auch was eingegeben wurde.

[Saban]

Hi,

erst mal danke für deine Antwort ich schau mir die Doku gleich mal an!

Ich wollte eigentlich nur wissen was ich alles beim CaretListener abfragen kann oder ob er wie ein ActionListener aufgerufen wird, weils ja auch ein Listener ist oder sonstiges ich wollt halt nur ein bisschen Programmcode...

Was würdest du an meiner Stelle nehmen wenn deiner Meinung nach der CaretListener nicht zur Aufgabe passt?

MfG

Saban

[Dragon8]

Also der CaretListener wird wahrscheinlich ebenso wie der von dir genannten ActionListener aufgerufen. Eben, jedes mal wenn sich der Cursor bewegt. Und über das übergebende CaretEvent Objekt kannst du dir halt zum einen die aktuelle Position des Cursors holen und zum anderen die Position, wenn vorhanden, des Endes einer Makierung.

Also auf die Schnelle würde ich wahrscheinlich eher nen KeyListener nehmen. Und jedesmal wenn die Methode keyTyped() ausgelöst würde, überprüfen ob der Text in der TextArea geändert wurde und dementsprechend dann handeln.

[Saban]

Das hab ich mir auch schon überlegt gehabt... Mein Gedanke war aber was ist wenn jemand jetzt z. B. "Hallo@All" tippt dann 4x die LöschenTaste tippt dann wird doch ne neue Zeile angefangen, da ja der KeyType über 10 sein müsste oder etwa nicht?

Grüße

Saban

[Dragon8]

Deswegen würde ich dir empfehlen nicht stur nur die Tastaturanschläge zu zählen, sondern jedes mal die Zeichen die in der TextArea vorhanden sind.

Und wenn die Textlänge halt nen vielfaches von 10 ist, setzte jeweils nach 10 Zeichen ein ein Zeilenumbruch.

Natürlich solltest du nach jedem neu eingetippten oder gelöschten Zeichen überprüfen ob deine Zeilenumbrüche noch immer an der richtigen Position sitzen.

[Saban]

Ok so weit komm ich mit aber daran wie ich des umsetzen soll (also meinem Programm erklären ) ist mir noch nicht so ganz klar hast vllt da noch nen tipp oder so?

Grüße

Saban

[Dragon8]

Naja du fügst zu erst der TextArea den KeyListener hinzu. In dem KeyListener überschreibst du die Methode keyTyped().

In dieser Methode holst du dir den Text aus der entsprechenden TextArea und überprüfst die Länge. Wenn sie ein vielfaches von 10 ist, fügst du einfach an jeder 10ten Stelle im Text einen Zeilenumbruch ein (Tipp: "\n").

Bevor du das tust, wäre natürlich auch sinnvoll, zu schauen ob schon zeilenumbrüche drin sind und diese eventuell rauszulöschen.

[Saban]

Hmmm...

ich hätte mich vllt besser ausdrücken sollen...

Die Sache ist wenn man mehr als 10 Zeichen eingibt dann zeigt es die TextArea nicht mehr an weil Sie zu klein ist. Darum gehts mir nur darum das nach jedem 10 Zeichen ein Zeilenumbruch kommt wenn aber schon nach dem 7 Zeichen einer gemacht wird dann passt es ja eigentlich solange die maximale Zeichenzahl nicht 100 überschreitet...

Eigentlich bleibt doch die Überprüfung trotzdem die selbe oder kann man evtl auch für jede Zeile einzeln prüfen?

Danke für deine Hilfe

MfG

Saban

[Dragon8]

Ach soooo, es geht quasi darum, dass die Zeile am Ende der TextArea umgebrochen werden soll, na sag das doch gleich.

Dann schau dir mal bitte die Funktion setLineWrap(boolean) der JTextArea an.

Für die maximale Anzahl an Zeichen in der TextArea habe ich jetzt leider gerade keine Funktion gefunden, da wäre dann vll wieder angebracht, den KeyListener zu nehmen und bei jedem neuen Zeichen zu schauen ob die Maximal Anzahl überschritten wurde.

[Saban]

Hey des ist ja Klasse danke!

Ich schau mal vllt kann man das auch so machen das er die Wörter am Ende in Silben trennt oder das ganze Wort in die neue Zeile setzt aber das krieg ich scho irgendwie hin genauso wie die maximale Zeichenanzahl

Danke für deine Hilfe!

Grüße

Java_Neuling

[ksg9-sebastian]

Der CaretListener ist für das Problem der falsche Ansatz. Du solltest einen DocumentListener verwenden.

Da ich sowas schon selbst implementiert hab mal der Code:

Ist noch viel zeugs dabei was du nicht benötigst, aber das kannst ja rauswerfen.

Ich hatte auch mal eine Implementierung welche sauber umbricht (=> Wenn möglich werden ganze Wörter umgebrochen). Mit dem Code unten werden Wörter auch zerhackt.

Der Code gehört in eine Klasse welche ein Document erweitert (siehe API javax.swing / javax.swing.text).

Gruß Sebastian

    /**

     * Diese Methode macht automatische Zeilenumbrüche nach einer bestimmten Anzahl Zeichen.

     * Die Anzahl Zeichen wird über die Variable charsPerLine festgelegt.

     * Wenn eine Zeile zu lang ist wird Text umgebrochen.

     *

     * @param str der String der bearbeitet werden soll

     * @return der fertig bearbeitete String

     */

    private WrapResult wordWrap(StringBuffer str, int offsetPosition)

    {

        WrapResult result = new WrapResult();

        StringBuffer wrapped = new StringBuffer();

        int charsInLine = 0;

        int lineCounter = 0;

        int linesInserted = 0;

        for (int i = 0; i < str.length(); i++)

        {

            String chr = String.valueOf(str.charAt(i));


            if (LINE_SEPARATOR.equals(chr))

            {

                charsInLine = 0;

                lineCounter++;

            }

            else

            {

                if (charsInLine == charsPerLine)

                {

                    wrapped.append(LINE_SEPARATOR);

                    charsInLine = 0;

                    lineCounter++;

                    if (offsetPosition >= i)

                    {

                        linesInserted++;

                    }

                }

                else

                {

                    charsInLine++;

                }

            }

            wrapped.append(chr);

        }

        result.setLinesInserted(linesInserted);

        result.setLines(lineCounter);

        result.setWrappedText(wrapped.toString());


        return result;


    }


    /**

     * Fügt einen String in das Dokument ein.

     *

     * Diese Methode wird bei jedem Tastendruck vom Framework aufgerufen

     */

    public void insertString(int offset, String insertString, AttributeSet arg2) throws BadLocationException

    {

        if (!lockedForChange)

        {

            boolean insertValid = true;

            if (validCharacters != null && insertString != null)

            {

                for (int i = 0; i < insertString.length(); i++)

                {

                    String chr = String.valueOf(insertString.charAt(i));

                    if (validCharacters.indexOf(chr) == -1)

                    {

                        insertValid = false;

                    }

                }

            }

            if (insertValid)

            {


                StringBuffer buf = getCompleteText();

                StringBuffer oldText = getCompleteText();

                buf.insert(offset, insertString);

                WrapResult result = wordWrap(buf, offset);

                if (result.getLines() <= maxRows)

                {

                    deleteAndInsert(result.getWrappedText());

                    // offset berechnen

                    offset += insertString.length();

                    offset += result.getLinesInserted();

                }

            }

        }

    }


    /**

     * Prüft das Dokument ob es korrekt ist.

     * In diesem Fall ob die Anzahl der Zeichen pro Zeile und die Anzahl der

     * Zeilen stimmt

     */

    protected boolean checkSyntax(String str)

    {

        return true;

    }


    public void remove(int fromIndex, int length) throws BadLocationException

    {

        if (!lockedForChange)

        {

            lockedForChange = true;

            int offset = fromIndex;

            StringBuffer buf = getCompleteText();

            StringBuffer oldText = getCompleteText();

            buf.delete(fromIndex, fromIndex + length);

            WrapResult result = wordWrap(buf, offset);

            if (result.getLines() <= maxRows)

            {

                deleteAndInsert(result.getWrappedText());

                // offset berechnen

                offset += result.getLinesInserted();

            }

        }

        lockedForChange = false;

    }



    /**

     * löscht den vorhandenen Text unf fügt neuen ein

     *

     * @param newText der neue Text

     */

    public void deleteAndInsert(String newText)

    {

        try

        {

            remove(0, getLength());

            if (newText != null)

            {

                super.insertString(0, newText, null);

            }

        }

        catch (BadLocationException e)

        {


        }


    }


    /**

     * gibt den kompletten Text zurück

     * @return den Inhalt

     */

    public StringBuffer getCompleteText()

    {

        StringBuffer compText = new StringBuffer();


        try

        {

            compText.append(getText(0, getLength()));

        }

        catch (BadLocationException e)

        {


        }


        return compText;

    }


    /**

     * maximale Anzahl Zeichen pro Zeile

     *

     * @return charsPerLine maximale Anzahl Zeichen pro Zeile

     */

    public int getCharsPerLine()

    {

        return charsPerLine;

    }


    /**

     * Legt die maximale Anzahl Zeichen pro Zeile fest

     *

     * @param charsPerLine Anzahl Zeichen pro Zeile

     */

    public void setCharsPerLine(int charsPerLine)

    {

        try

        {

            insertString(0, "", null);

        }

        catch (BadLocationException e)

        {

            // couldn't happen!

        }

        this.charsPerLine = charsPerLine;

    }


    /**

     * maximale Anzahl Zeilen

     *

     * @return maxRows Anzahl Zeilen

     */

    public int getMaxRows()

    {

        return maxRows;

    }


    /**

     * legt die maximale Anzahl an Zeilen fest

     *

     * @param maxRows Anzahl Zeilen

     */

    public void setMaxRows(int maxRows)

    {

        this.maxRows = maxRows;

    }


       /**

     * Diese Klasse speichert den Zustand einer Formatierung mit sämtlichen

     * relevanten Informationen

     */

    private class WrapResult

    {

        /** Anzahl der Zeilen */

        private int    lines;

        /** Anzahl der eingefügten Zeilen */

        private int    linesInserted;

        /** Der formatierte Text */

        private String wrappedText;


        /**

         * Gibt die Anzahl der Zeilen zurück

         *

         * @return the lines

         */

        public int getLines()

        {

            return lines;

        }


        /**

         * Setzt die Anzahl der Zeilen

         *

         * @param lines the lines to set

         */

        public void setLines(int lines)

        {

            this.lines = lines;

        }


        /**

         * Gibt den formatierten Text zurück

         *

         * @return the wrappedText

         */

        public String getWrappedText()

        {

            return wrappedText;

        }


        /**

         * Setzt den formatierten Text

         *

         * @param wrappedText the wrappedText to set

         */

        public void setWrappedText(String wrappedText)

        {

            this.wrappedText = wrappedText;

        }


        /**

         * Gibt die Anzahl der eingefügten Zeilen zurück

         *

         * @return the linesInserted

         */

        public int getLinesInserted()

        {

            return linesInserted;

        }


        /**

         * Setzt die Anzahl der eingefügten Zeilen

         *

         * @param linesInserted the linesInserted to set

         */

        public void setLinesInserted(int linesInserted)

        {

            this.linesInserted = linesInserted;

        }

    }

}