Schriftart für EditText-Hinweis ändern

Question

Ist es möglich, die Schriftart für den im Feld EditText angezeigten Hinweis zu ändern? Ich möchte die Schriftart in der XML selbst setzen.

Answer 1

Dies ist eine falsche Antwort auf die Frage. Ich habe versucht zu löschen, aber ich kann nicht die Moderatoren. Bitte ignorieren Sie die Antwort oder zögern Sie nicht, die Antwort zu aktualisieren. Diese Antwort ist irreführend. Es tut uns leid :).

editText.setTypeface(Typeface.SERIF); 

Sie können die Schriftart von EditText wie TextView ändern. Aber Sie können die Schrift von hint nicht ändern.

Answer 2

Es ist nicht möglich, in XML -

Text und Hinweis kann nur die gleiche Schriftart in XML haben.

Answer 3

Ich habe keine nützliche Art und Weise herauszufinden Hinweis Schriftart in XML.But ändern Sie wie folgt erreichen:

mEt.addTextChangedListener(new TextWatcher() { 
    @Override 
    public void beforeTextChanged(CharSequence s, int start, int count, int after) { 

    } 

    @Override 
    public void onTextChanged(CharSequence s, int start, int before, int count) { 
     if(s.length()== 0) { 
      //mEt.setTypeFace(normalFont); 
     }else{ 
      // mEt.setTypeFace(hintFont); 
     } 
    } 

    @Override 
    public void afterTextChanged(Editable s) { 
    } 
}); 

Answer 4

Sie es mit einem SpannableString ändern und eine benutzerdefinierte TypefaceSpan.

Zuerst eine benutzerdefinierte TypefaceSpan Klasse erstellen:

public class CustomTypefaceSpan extends TypefaceSpan { 
    private final Typeface mNewType; 

    public CustomTypefaceSpan(Typeface type) { 
     super(""); 
     mNewType = type; 
    } 

    public CustomTypefaceSpan(String family, Typeface type) { 
     super(family); 
     mNewType = type; 
    } 

    @Override 
    public void updateDrawState(TextPaint ds) { 
     applyCustomTypeFace(ds, mNewType); 
    } 

    @Override 
    public void updateMeasureState(TextPaint paint) { 
     applyCustomTypeFace(paint, mNewType); 
    } 

    private static void applyCustomTypeFace(Paint paint, Typeface tf) { 
     int oldStyle; 
     Typeface old = paint.getTypeface(); 
     if (old == null) { 
      oldStyle = 0; 
     } else { 
      oldStyle = old.getStyle(); 
     } 

     int fake = oldStyle & ~tf.getStyle(); 
     if ((fake & Typeface.BOLD) != 0) { 
      paint.setFakeBoldText(true); 
     } 

     if ((fake & Typeface.ITALIC) != 0) { 
      paint.setTextSkewX(-0.25f); 
     } 

     paint.setTypeface(tf); 
    } 
} 

Dann setzen Sie einfach die TypefaceSpan zu einem SpannableString:

TypefaceSpan typefaceSpan = new CustomTypefaceSpan(typeface); 
SpannableString spannableString = new SpannableString(hintText); 

spannableString.setSpan(typefaceSpan, 0, spannableString.length(), Spanned.SPAN_INCLUSIVE_EXCLUSIVE); 

Und schließlich setzen nur die Andeutung Ihres EditText:

mEditText.setHint(spannableString); 

Answer 5

Es gibt eine sehr einfache Möglichkeit, es zu tun. Ich habe gerade in meiner App und es hat funktioniert. Der Key ist auch Facetype von Ihrem TextInputLayout zusammen mit EditText festgelegt.

mEmailView.setTypeface(Typeface.createFromAsset(getAssets(), getString(R.string.app_font))); 
((TextInputLayout) findViewById(R.id.tilEmail)).setTypeface(Typeface.createFromAsset(getAssets(), getString(R.string.app_font))); 

Answer 6

Ich kann die Tippschrift ändern, indem Sie diese library verwenden.

Nachdem die Bibliothek kompilieren müssen Sie eine Klasse von Anwendungen und die Klassendefinition folgenden Befehl erstellen:

CalligraphyConfig.initDefault(new CalligraphyConfig.Builder() 
        .setDefaultFontPath("font.ttf") 
        .setFontAttrId(R.attr.fontPath) 
        .build() 
     ); 

Nach jeder Aktivität, die Sie es außer Kraft setzen mit dem folgenden Befehl werden sollen:

@Override 
     protected void attachBaseContext(Context newBase) { 
      super.attachBaseContext(CalligraphyContextWrapper.wrap(newBase)); 
     } 

Answer 7

@ francisco_ssb die Antwort ist richtig. Ich werde jedoch eine alternative Lösung anbieten, die hilft, nicht nur die Schriftart eines Hinweises, sondern auch seine Größe und seinen Stil zu ändern. Ich hoffe, dass diese Lösung hilfreich sein wird.

1) Erstellen eines benutzerdefinierten Hint Objekt:

import android.graphics.Typeface; 
import android.text.SpannableString; 
import android.text.Spanned; 
import android.text.style.MetricAffectingSpan; 

public class CustomHint extends SpannableString 
{ 
    public CustomHint(final CharSequence source, final int style) 
    { 
     this(null, source, style, null); 
    } 

    public CustomHint(final CharSequence source, final Float size) 
    { 
     this(null, source, size); 
    } 

    public CustomHint(final CharSequence source, final int style, final Float size) 
    { 
     this(null, source, style, size); 
    } 

    public CustomHint(final Typeface typeface, final CharSequence source, final int style) 
    { 
     this(typeface, source, style, null); 
    } 

    public CustomHint(final Typeface typeface, final CharSequence source, final Float size) 
    { 
     this(typeface, source, null, size); 
    } 

    public CustomHint(final Typeface typeface, final CharSequence source, final Integer style, final Float size) 
    { 
     super(source); 

     MetricAffectingSpan typefaceSpan = new CustomMetricAffectingSpan(typeface, style, size); 
     setSpan(typefaceSpan, 0, source.length(), Spanned.SPAN_INCLUSIVE_EXCLUSIVE); 
    } 
} 

2) Erstellen von benutzerdefinierten MetricAffectingSpan Objekt:

import android.graphics.Typeface; 
import android.text.TextPaint; 
import android.text.style.MetricAffectingSpan; 

public class CustomMetricAffectingSpan extends MetricAffectingSpan 
{ 
    private final Typeface _typeface; 
    private final Float _newSize; 
    private final Integer _newStyle; 

    public CustomMetricAffectingSpan(Float size) 
    { 
     this(null, null, size); 
    } 

    public CustomMetricAffectingSpan(Float size, Integer style) 
    { 
     this(null, style, size); 
    } 

    public CustomMetricAffectingSpan(Typeface type, Integer style, Float size) 
    { 
     this._typeface = type; 
     this._newStyle = style; 
     this._newSize = size; 
    } 

    @Override 
    public void updateDrawState(TextPaint ds) 
    { 
     applyNewSize(ds); 
    } 

    @Override 
    public void updateMeasureState(TextPaint paint) 
    { 
     applyNewSize(paint); 
    } 

    private void applyNewSize(TextPaint paint) 
    { 
     if (this._newStyle != null) 
      paint.setTypeface(Typeface.create(this._typeface, this._newStyle)); 
     else 
      paint.setTypeface(this._typeface); 

     if (this._newSize != null) 
      paint.setTextSize(this._newSize); 
    } 
} 

3) Verwendung:

Typeface newTypeface = Typeface.createFromAsset(getAssets(), "AguafinaScript-Regular.ttf"); 
CustomHint customHint = new CustomHint(newTypeface, "Enter some text", Typeface.BOLD_ITALIC, 60f); 
     //  CustomHint customHint = new CustomHint(newTypeface, "Enter some text", Typeface.BOLD_ITALIC); 
     //  CustomHint customHint = new CustomHint(newTypeface, "Enter some text", 60f); 
     //  CustomHint customHint = new CustomHint("Enter some text", Typeface.BOLD_ITALIC, 60f); 
     //  CustomHint customHint = new CustomHint("Enter some text", Typeface.BOLD_ITALIC); 
     //  CustomHint customHint = new CustomHint("Enter some text", 60f); 

customEditText.setHint(customHint); 

Answer 8

Verwendung dieser Code:

edittext.setAccentTypeface(typeface);