Android EditText संकेत आकार


86

EditTextसंकेत आकार कैसे कम करें ?


2
मुझे लगता है कि संकेत का आकार बदलने की कोई आवश्यकता नहीं है। तुम ऐसा क्यों करना चाहते हो?
— प्रवीण

4
संकेत फ़ॉन्ट का आकार बहुत बड़ा है .. तो मैं इसे से 2sp कम करने की जरूरत ..
— शशिकुमार

1
मुझे भी यही समस्या थी। हम एक डायलर एप्लिकेशन लागू कर रहे हैं ताकि डायल किए गए नंबर काफी बड़े हो सकें, जबकि संकेत पाठ को सब कुछ फिट करने के लिए छोटा होना चाहिए। समाधान के लिए @ जेका को धन्यवाद!
— ब्रैडफोर्ड

1
<string name = "name"> <font size = "20"> नाम </ font> <small> (प्रति डॉक्टर के रूप में) </ small> </ string>
— Sanket Parchande

जवाबों:


129

आप इसे स्ट्रिंग रिक्रूट में साइज़ सेट करके कर सकते हैं।

उदाहरण के लिए:

<string name="edittext_hint"><font size="15">Hint here!</font></string>

तो अपने XML में बस लिखें

android:hint="@string/edittext_hint"

यह संकेत के लिए एक छोटे से पाठ में परिणाम देगा लेकिन इनपुट पाठ के लिए मूल आकार।

उम्मीद है कि यह भविष्य के पाठकों के लिए मदद करता है


1
विशेषता के spलिए आयाम कैसे निर्दिष्ट करें size?
— f_ficarola

1
जैसा कि आप यहाँ सपा की तरह dimesion निर्दिष्ट नहीं कर रहे हैं, यह अलग स्क्रीन आकार में समस्या नहीं होगी? जब आयाम बदलते हैं तो मुझे बिना किसी समस्या के लेआउट xml के माध्यम से संकेत आकार निर्धारित करने का कोई तरीका नहीं मिलता है
— विश्वनाथ गौड़ा k

2
यह तब काम नहीं करता है जब संकेत प्रोग्रामेटिक रूप से सेट किया गया हो
— ashwin mahajan

60

आप फ़ॉन्ट आकार को कम कर सकते हैं EditText- जो कि आकार को कम करेगा hint। अर्थातandroid:textSize="16sp"


धन्यवाद, आपने मुझे कुछ सिरदर्द से बचाया! :)
— peterkodermac

मैं खुशी से मदद कर सकता है! :)
— inky

इस काम के सभी के बजाय महान जवाब: डी
— एंटवान

33
क्या होगा अगर मुझे दो अलग-अलग आकार चाहिए, एक असली पाठ के लिए और दूसरा संकेत के लिए?
— f_ficarola

कूल जो बहुत स्मार्ट जवाब था, लेकिन उपरोक्त टिप्पणी सही है अगर मुझे दो अलग-अलग आकार चाहिए, एक असली पाठ के लिए और दूसरा संकेत के लिए?
— अर्सलान अली अवन

36

मुझे यह भी करना पड़ा क्योंकि मेरे संकेत मानक आकार में EditText में फिट नहीं थे। तो मैंने ऐसा किया (xml सेट टेक्स्ट में mHintTextSize पर):

MYEditText.addTextChangedListener(new TextWatcher(){

                @Override
                public void afterTextChanged(Editable arg0) {
                    // TODO Auto-generated method stub

                }

                @Override
                public void beforeTextChanged(CharSequence arg0, int arg1,
                        int arg2, int arg3) {
                    // TODO Auto-generated method stub

                }

                @Override
                public void onTextChanged(CharSequence arg0, int start, int before,
                        int count) {
                    if (arg0.length() == 0) { 
                        // No entered text so will show hint
                        editText.setTextSize(TypedValue.COMPLEX_UNIT_SP, mHintTextSize);
                    } else {
                        editText.setTextSize(TypedValue.COMPLEX_UNIT_SP, mRealTextSize);
                    }
                }
        });

2
@EVSearchTerm उनका संपादन संदर्भ है। नामकरण सम्मेलन त्याग दिया।
— रोहित शर्मा

1
यह दृष्टिकोण काम करता है। एंड्रॉइड एसडीके की समस्या यह है कि टेक्स्ट के आकार को प्रोग्रामेटिक रूप से सेट करना हिंट टेक्स्ट साइज के लिए पूरी तरह से नजरअंदाज कर दिया गया है। दूसरी तरफ, यह लोंगहेर्डसी के दृष्टिकोण को सरल बनाने की अनुमति देता है। जोड़ने के बजाय TextWatcherआप बस editText.setTextSize(TypedValue.COMPLEX_UNIT_SP, mRealTextSize);तुरंत कॉल कर सकते हैं । हालांकि, लोंगहेर्देसी का समाधान भविष्य में अधिक सुरक्षित हो सकता है। मुझे उत्सुकता है अगर यह मुद्दा नए एसडीके संस्करणों में तय किया जाएगा।
— पीटर एफ

धन्यवाद। प्रारंभिक पाठ आकार सेट करना न भूलें (अन्यथा जब पाठ शुरू होने के बाद खाली होता है, तो संकेत का आकार संभवतः पाठ आकार के बराबर होता है)।
— CoolMind

31

आप साधारण HTML विशेषताओं को संकेत स्ट्रिंग में ही सेट कर सकते हैं।

यहां स्वीकृत उत्तर देखें: Android EditText संकेत

संपादित करें: बस इसके साथ खुद खेला, यह मेरे लिए काम किया:

view.setHint(Html.fromHtml("<small><small><small>" + 
             getString(R.string.hint) + "</small></small></small>"));

यहHtml द्वारा स्वीकृत टैग की एक सूची है: http://commonsware.com/blog/Android/2010/05/26/html-tags-supported-by-textview.html (हालांकि मेरे लिए काम नहीं किया)


12

यदि आप इसे प्रोग्रामेटिक रूप से करना चाहते हैं,

SpannableString span = new SpannableString(strHint);
span.setSpan(new RelativeSizeSpan(0.5f), 0, strHint.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
editText.setHint(span);

आपके समाधान को पसंद किया लेकिन दुर्भाग्य से काम नहीं किया, संसाधनों से लोड करना और TextInputLayout को गतिशील रूप से सेट करना
— जिमीफ्लैश

9

एडिटेक्स के संकेत आकार को कम करना आसान है

editText.setHint(Html.fromHtml(
    "<font size=\"5\">" + "hinttext1" + "</font>" + 
    "<small>" + "hinttext2" + "</small>" )); 

2

@ मरमोर का दृष्टिकोण सबसे अच्छा है। <small> --- </small>आकार को समायोजित करने के लिए आप टैग की संख्या को बदल सकते हैं ।

आप सीधे हिंट के पाठ को भी परिभाषित कर सकते हैं जैसा मैंने किया

view.setHint(Html.fromHtml("<small><small><small>" + "This is Hint" + "</small></small></small>"));

आशा है कि यह मदद करेगा।


1

@ user2982553 का समाधान मेरे लिए बहुत अच्छा काम करता है। आप यह भी उपयोग AbsoluteSizeSpanकर सकते हैं , जिसके साथ आप संकेत के सटीक फ़ॉन्ट आकार को सेट कर सकते हैं। <font size=\"5\">टैग का उपयोग न करें , क्योंकि sizeविशेषता को अनदेखा किया गया है।


1

इसे अपने स्ट्रिंग्स में परिभाषित करें। वैल्यू फ़ोल्डर में xml:

<string name="enter_otp"><font size="16">your text</font></string>

0

मुझे संकेत से वास्तविक पाठ के लिए एक बड़ा आकार निर्धारित करने की आवश्यकता है।

public static class LargeSizeTextWatcher implements TextWatcher {

    private final EditText mEditText;
    private final int mOriginalSize;
    private final int mLargeSize;

    private int mLastLength;

    TrackingNumberTextWatcher(EditText editText) {
        mEditText = editText;
        mOriginalSize = (int) editText.getTextSize();
        mLargeSize = editText.getResources().getDimensionPixelSize(R.dimen.text_size_large);

        mLastLength = editText.length();
        if (mLastLength != 0) {
            mEditText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mLargeSize);
        }
    }

    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
    }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
    }

    @Override
    public void afterTextChanged(Editable s) {
        int length = s.length();
        if (length == 0) {
            mEditText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mOriginalSize);
        } else if (mLastLength == 0) {
            mEditText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mLargeSize);
        }
        mLastLength = length;
    }
}

0

आप न केवल एक संकेत के आकार को बदल सकते हैं, बल्कि इसके फ़ॉन्ट और शैली को भी बदल सकते हैं। मैंने इसका उपयोग करके हल करने के लिए हासिल किया SpannableStringऔरMetricAffectingSpan

1) एक कस्टम 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) कस्टम MetricAffectingSpanऑब्जेक्ट बनाएँ :

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) का उपयोग करें:

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

0

संकेत फ़ॉन्ट आकार बदलने के लिए onFocusChanged () श्रोता का उपयोग करना भी एक विकल्प है, क्योंकि जब उपयोगकर्ता टेक्स्ट फ़ील्ड पर क्लिक करता है, तो addTextChangeListener () ट्रिगर नहीं होगा, और ब्लिंकिंग कर्सर संकेत फ़ॉन्ट का आकार बदल देगा।

इसके अलावा, TextChangeListener के साथ, प्रारंभिक संकेत फ़ॉन्ट आकार अलग से सेट करने की आवश्यकता नहीं है।

class EditTextWithHintSize {
 init {
        val typedArray = context.obtainStyledAttributes(attrs,
                R.styleable.EditTextWithHintSize, 0, defStyle)
        try {
            hintFontSize = typedArray.getDimension(R.styleable.EditTextWithHintSize_hint_font_size, textSize)
            fontSize = textSize

            if (length() == 0) {
                setTextSize(TypedValue.COMPLEX_UNIT_PX, hintFontSize)
            }
        } catch (e: Exception) {
            hintFontSize = textSize
            fontSize = textSize
        } finally {
            typedArray.recycle()
        }
    }

    override fun onFocusChanged(focused: Boolean, direction: Int, previouslyFocusedRect: Rect?) {
        super.onFocusChanged(focused, direction, previouslyFocusedRect)

        if (focused) {
            setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSize)
        } else {
            if (length() == 0) {
                setTextSize(TypedValue.COMPLEX_UNIT_PX, hintFontSize)
            } else {
                setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSize)
            }
        }
    }
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.