zmiana czcionki dla wskazówki editText

Question

Czy można zmienić czcionkę wskazówki wyświetlanej w polu EditText? Chcę ustawić czcionkę w samym xml.

Answer 1

To jest zła odpowiedź na pytanie. Próbowałem usunąć, ale nie mogę pominąć moderatorów. Prosimy zignorować odpowiedź lub zachęcamy do aktualizacji odpowiedzi. Ta odpowiedź jest myląca. Przepraszam :).

editText.setTypeface(Typeface.SERIF); 

Można zmienić czcionkę EditText jak TextView. Ale nie można zmienić kroju czcionki hint.

Answer 2

Nie jest to możliwe w XML -

Tekst i podpowiedź może mieć tylko taką samą czcionkę w XML.

Answer 3

ja nie dowiedzieć się każdą użyteczną sposób na zmianę czcionki podpowiedzi w XML.But można osiągnąć tak:

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

Można go zmienić z SpannableString i niestandardowej TypefaceSpan.

Najpierw należy utworzyć klasę klienta TypefaceSpan:

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

Następnie wystarczy ustawić TypefaceSpan do SpannableString:

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

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

I wreszcie po prostu ustawić wskazówkę swojego EditText:

mEditText.setHint(spannableString); 

Answer 5

Istnieje prosty sposób na zrobienie tego. Właśnie zrobiłem w mojej aplikacji i zadziałało. Klucz jest ustawiony jako rodzaj czcionki twojego TextInputLayout razem z EditText.

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

Mogę zmienić czcionkę podpowiedzi za pomocą tego library.

Po kompilacji biblioteki należy utworzyć klasę aplikacji i definicja klasy następującą komendę:

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

po każdej aktywności chcesz nadpisać za pomocą następującego polecenia:

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

Answer 7

@ francisco_ssb-tych odpowiedź jest poprawna. Jednak dostarczę alternatywne rozwiązanie, które pomoże zmienić nie tylko czcionkę podpowiedzi, ale także jej rozmiar i styl. Mam nadzieję, że to rozwiązanie będzie pomocne.

1) Tworzenie niestandardowego Hint obiekt:

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) Tworzenie niestandardowych MetricAffectingSpan obiektów:

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) Zastosowanie:

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

użyć tego kodu:

edittext.setAccentTypeface(typeface);