EditText maxLines funktioniert nicht – Benutzer können noch mehr Zeilen eingeben als gesetzt

<EditText android:id="@+id/editText2" android:layout_height="wrap_content" android:layout_width="fill_parent" android:maxLines="5" android:lines="5"> </EditText> 

Der Benutzer kann mehr als 5 Zeilen eingeben, indem er die Eingabetaste / die nächste Zeilentaste drückt. Wie kann ich die Benutzereingabe auf eine feste Anzahl von Zeilen mit EditText beschränken?

  • Füge Layout als Ansicht in Android hinzu
  • Verständnis von Speicherverlusten in der Android-Anwendung
  • Wann sollte ich 9 Patch-Image in Android verwenden
  • Ändern der Standardfarbe von Android CheckBox Check Mark
  • Android: Was ist der inputType für den Benutzernamen
  • Kann ich das "easyResize" -Tastatur-Verhalten und eine Symbolleiste hinter der Statusleiste gleichzeitig haben?
  • Diese Version der Rendering-Bibliothek ist aktueller als deine Version von Android Studio. Bitte aktualisieren Sie Android Studio
  • Android loopj asynchttpclient Rückkehr Antwort
  • 13 Solutions collect form web for “EditText maxLines funktioniert nicht – Benutzer können noch mehr Zeilen eingeben als gesetzt”

    Das Attribut maxLines entspricht der maximalen Höhe des EditText , es steuert die äußeren Grenzen und nicht die inneren Textzeilen.

     <EditText android:id="@+id/edit_text" android:layout_width="match_parent" android:layout_height="wrap_content" android:inputType="text" android:maxLines="1" /> 

    Sie müssen nur sicherstellen, dass Sie das Attribut "inputType" gesetzt haben. Es funktioniert nicht ohne diese Zeile.

     android:inputType="text" 

    Dies löst nicht die allgemeine Frage der Begrenzung auf n Zeilen. Wenn du deinen EditText einschränken willst, um nur 1 Textzeile zu nehmen, kann das sehr einfach sein.
    Sie können dies in der XML-Datei festlegen.

     android:singleLine="true" 

    Oder programmgesteuert

     editText.setSingleLine(true); 

    @Cedekasem du hast recht, da ist kein eingebauter "Zeilenbegrenzer". Aber ich habe mich selbst gebaut, also wenn jemand interessiert ist, ist der Code unten. Prost.

     et.setOnKeyListener(new View.OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { // if enter is pressed start calculating if (keyCode == KeyEvent.KEYCODE_ENTER && event.getAction() == KeyEvent.ACTION_UP) { // get EditText text String text = ((EditText) v).getText().toString(); // find how many rows it cointains int editTextRowCount = text.split("\\n").length; // user has input more than limited - lets do something // about that if (editTextRowCount >= 7) { // find the last break int lastBreakIndex = text.lastIndexOf("\n"); // compose new text String newText = text.substring(0, lastBreakIndex); // add new text - delete old one and append new one // (append because I want the cursor to be at the end) ((EditText) v).setText(""); ((EditText) v).append(newText); } } return false; } }); 

    Ich habe so etwas getan, als hättest du gesucht. Hier ist meine LimitedEditText Klasse.

    Eigenschaften:

    • Sie können Zeilen in Ihrer LimitedEditText-Komponente zählen
    • Sie können Zeichen in Ihrer LimitedEditText-Komponente zählen
    • Wenn du die Grenze von Zeichen oder Zeilen irgendwo in der Mitte des Textes überschreitst, Cursor
      Werde dich nicht zum Ende bringen – es wird bleiben wo bist du gewesen

    setText() Hörer aus, denn jeder Aufruf von setText() -Methode würde diese 3 Callback-Methoden rekursiv anrufen, wenn der Benutzer Zeichen oder Zeilen überschritten hat.

    Code:

     import android.content.Context; import android.text.Editable; import android.text.TextWatcher; import android.util.AttributeSet; import android.util.Log; import android.widget.EditText; import android.widget.Toast; /** * EditText subclass created to enforce limit of the lines number in editable * text field */ public class LimitedEditText extends EditText { /** * Max lines to be present in editable text field */ private int maxLines = 1; /** * Max characters to be present in editable text field */ private int maxCharacters = 50; /** * application context; */ private Context context; public int getMaxCharacters() { return maxCharacters; } public void setMaxCharacters(int maxCharacters) { this.maxCharacters = maxCharacters; } @Override public int getMaxLines() { return maxLines; } @Override public void setMaxLines(int maxLines) { this.maxLines = maxLines; } public LimitedEditText(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); this.context = context; } public LimitedEditText(Context context, AttributeSet attrs) { super(context, attrs); this.context = context; } public LimitedEditText(Context context) { super(context); this.context = context; } @Override protected void onFinishInflate() { super.onFinishInflate(); TextWatcher watcher = new TextWatcher() { private String text; private int beforeCursorPosition = 0; @Override public void onTextChanged(CharSequence s, int start, int before, int count) { //TODO sth } @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { text = s.toString(); beforeCursorPosition = start; } @Override public void afterTextChanged(Editable s) { /* turning off listener */ removeTextChangedListener(this); /* handling lines limit exceed */ if (LimitedEditText.this.getLineCount() > maxLines) { LimitedEditText.this.setText(text); LimitedEditText.this.setSelection(beforeCursorPosition); } /* handling character limit exceed */ if (s.toString().length() > maxCharacters) { LimitedEditText.this.setText(text); LimitedEditText.this.setSelection(beforeCursorPosition); Toast.makeText(context, "text too long", Toast.LENGTH_SHORT) .show(); } /* turning on listener */ addTextChangedListener(this); } }; this.addTextChangedListener(watcher); } } 

    Hier habe ich eine einfachere Lösung gemacht: D

     // set listeners txtSpecialRequests.addTextChangedListener(new TextWatcher() { @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { lastSpecialRequestsCursorPosition = txtSpecialRequests.getSelectionStart(); } @Override public void onTextChanged(CharSequence s, int start, int before, int count) { } @Override public void afterTextChanged(Editable s) { txtSpecialRequests.removeTextChangedListener(this); if (txtSpecialRequests.getLineCount() > 3) { txtSpecialRequests.setText(specialRequests); txtSpecialRequests.setSelection(lastSpecialRequestsCursorPosition); } else specialRequests = txtSpecialRequests.getText().toString(); txtSpecialRequests.addTextChangedListener(this); } }); 

    Sie können den Wert von 3 in txtSpecialRequests.getLineCount() > 3 auf Ihre Bedürfnisse ändern.

    Hier ist ein InputFilter, der zulässige Zeilen in EditText beschränkt:

     /** * Filter for controlling maximum new lines in EditText. */ public class MaxLinesInputFilter implements InputFilter { private final int mMax; public MaxLinesInputFilter(int max) { mMax = max; } public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { int newLinesToBeAdded = countOccurrences(source.toString(), '\n'); int newLinesBefore = countOccurrences(dest.toString(), '\n'); if (newLinesBefore >= mMax - 1 && newLinesToBeAdded > 0) { // filter return ""; } // do nothing return null; } /** * @return the maximum lines enforced by this input filter */ public int getMax() { return mMax; } /** * Counts the number occurrences of the given char. * * @param string the string * @param charAppearance the char * @return number of occurrences of the char */ public static int countOccurrences(String string, char charAppearance) { int count = 0; for (int i = 0; i < string.length(); i++) { if (string.charAt(i) == charAppearance) { count++; } } return count; } } 

    Um es zu EditText hinzuzufügen:

     editText.setFilters(new InputFilter[]{new MaxLinesInputFilter(2)}); 

    Das habe ich in meinem Projekt benutzt:

     editText.addTextChangedListener(new TextWatcher() { private String text; public void onTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) { } public void beforeTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) { text = arg0.toString(); } public void afterTextChanged(Editable arg0) { int lineCount = editText.getLineCount(); if(lineCount > numberOfLines){ editText.setText(text); } } }); editText.setOnKeyListener(new View.OnKeyListener() { public boolean onKey(View v, int keyCode, KeyEvent event) { // if enter is pressed start calculating if (keyCode == KeyEvent.KEYCODE_ENTER && event.getAction() == KeyEvent.ACTION_DOWN){ int editTextLineCount = ((EditText)v).getLineCount(); if (editTextLineCount >= numberOfLines) return true; } return false; } }); 

    Und es hat in allen Szenarien gearbeitet

    GetLineCount () ist eine Option; Wenn Sie Werte ungleich Null wünschen, stellen Sie sicher, dass Ihre Ansicht gemessen wird. Für die Softtastatur onKeyListener funktioniert das nicht so, dass du addTextChangedListener () hinzufügen musst, das bei der Eingabe von Textänderungen verfolgt wird. Sobald du genügend Zeilen in seinem Rückruf hast, machst du was du einschränken möchtest: Lösche Zeichen mit getText (), setText () oder etwas mehr Lust. Sie können sogar die Anzahl der Zeichen mit einem Filter beschränken.

    Eine weitere Möglichkeit besteht darin, die Größe des Textes mit getLineBounds () zu überwachen. Dies wird mit Text Gravity / paddign interagieren, also seien Sie vorsichtig.

    Für die Grenze Anzahl der Zeichen können wir einfach die maxLength-Eigenschaft von EditText verwenden, da es dem Benutzer nicht erlaubt, mehr Zeichen einzugeben.

    Einfachste Lösung:

     android:maxLines="3" 

      @Override public void afterTextChanged(Editable editable) { // limit to 3 lines if (editText.getLayout().getLineCount() > 3) editText.getText().delete(editText.getText().length() - 1, editText.getText().length()); } 

    Versuchen Sie, die folgende Kombination von Attributen des EditText in der XML-Datei zu verwenden:

    android:singleLine="true"
    android:maxLenght="22"

    Eine weitere Möglichkeit, Ihren EditText auf eine Zeile zu beschränken, EditText wie folgt:

     editText2.setTransformationMethod(new SingleLineTransformationMethod()); 

    Beachten Sie, dass nach der Anwendung dieser Transformationsmethode die Enter-Taste Leerzeichen erzeugt, wenn sie gedrückt werden. Das befriedigt noch TS 'Frage.

    Das Android ist ein Google Android Fan-Website, Alles ├╝ber Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.