cambia carattere per editText hint

Question

È possibile modificare il carattere per il suggerimento visualizzato nel campo EditText? Voglio impostare il carattere nel xml stesso.

Answer 1

Questa è una risposta sbagliata alla domanda. Ho provato a cancellare ma non posso escludere i moderatori. Ignora gentilmente la risposta o sentiti libero di aggiornare la risposta. Questa risposta è fuorviante. Scusate :).

editText.setTypeface(Typeface.SERIF); 

È possibile modificare il carattere di EditText proprio come TextView. Ma non è possibile modificare il carattere tipografico di hint.

Answer 2

La sua non è possibile in XML -

Testo e suggerimento può avere solo lo stesso tipo di carattere in XML.

Answer 3

non ho scoprire un modo utile per cambiare il font suggerimento nel XML.But è possibile ottenere in questo modo:

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

si può cambiare con uno SpannableString e TypefaceSpan personalizzato.

In primo luogo, creare una classe personalizzata 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); 
    } 
} 

Poi basta impostare la TypefaceSpan ad uno SpannableString:

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

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

E infine è sufficiente impostare il suggerimento del vostro EditText:

mEditText.setHint(spannableString); 

Answer 5

C'è un modo molto semplice per farlo. Ho appena fatto nella mia app e ha funzionato. La chiave è impostata come Facetype di TextInputLayout insieme a 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

Posso cambiare il tipo di suggerimento utilizzando questo library.

Dopo la compilazione della biblioteca è necessario creare una classe di applicazioni e la definizione della classe seguente comando:

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

Dopo ogni attività che si desidera ignorarlo con il seguente comando:

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

Answer 7

@ francisco_ssb di la risposta è corretta Tuttavia, fornirò una soluzione alternativa che aiuta a cambiare non solo il carattere di un suggerimento, ma anche le sue dimensioni e il suo stile. Spero che questa soluzione ti sia d'aiuto.

1) Creazione di un oggetto personalizzato Hint:

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) Creare personalizzato MetricAffectingSpan oggetto:

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

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

uso di questo codice:

edittext.setAccentTypeface(typeface);