एंड्रॉइड में, मैं डीपी प्रोग्रामेटिक रूप से मार्जिन कैसे सेट करूं?

Question

में इस , यह और यह धागा मैं कैसे एक ही दृश्य पर मार्जिन सेट करने के लिए पर एक जवाब खोजने के लिए कोशिश की। हालांकि, मैं सोच रहा था कि क्या कोई आसान तरीका नहीं है। मैं समझाता हूँ कि मैं इस दृष्टिकोण का उपयोग क्यों नहीं करना चाहता:

मेरे पास एक कस्टम बटन है जो बटन का विस्तार करता है। यदि बैकग्राउंड को डिफॉल्ट बैकग्राउंड ( setBackgroundResource(int id)या तो कॉल करके setBackgroundDrawable(Drawable d)) से कुछ और सेट किया जाता है , तो मैं चाहता हूं कि मार्जिन 0. हो। अगर मैं कॉल करता हूं:

public void setBackgroundToDefault() {
    backgroundIsDefault = true;
    super.setBackgroundResource(android.R.drawable.btn_default);
    // Set margins somehow
}

मैं चाहता हूं कि मार्जिन -3 डीपी पर रीसेट हो जाए (मैं पहले ही यहां पढ़ चुका हूं कि पिक्सल से डीपी में कैसे कन्वर्ट किया जा सकता है, इसलिए एक बार जब मुझे पता है कि पीएक्स में मार्जिन कैसे सेट करना है, तो मैं स्वयं रूपांतरण का प्रबंधन कर सकता हूं)। लेकिन चूंकि इसे CustomButtonकक्षा में कहा जाता है , इसलिए माता-पिता लिनियरलैट से लेकर टेबललैटआउट तक अलग-अलग हो सकते हैं, और मैं नहीं चाहता कि वह अपने माता-पिता से मिलें और उस माता-पिता का उदाहरण देखें। मुझे लगता है कि यह भी काफी बेहतर होगा।

इसके अलावा, जब कॉलिंग (LayoutParams का उपयोग करके) parentLayout.addView(myCustomButton, newParams), मुझे नहीं पता कि क्या यह इसे सही स्थिति में जोड़ता है (हालांकि कोशिश नहीं की गई है), पांच की पंक्ति के मध्य बटन को कहें।

प्रश्न: क्या लेआउटपार्म्स का उपयोग करने के अलावा प्रोग्राम बटन के मार्जिन को सेट करने का कोई आसान तरीका है ?

संपादित करें: मुझे लेआउटपार्म्स के तरीके के बारे में पता है, लेकिन मैं एक समाधान चाहूंगा जो प्रत्येक अलग कंटेनर प्रकार से निपटने से बचता है:

ViewGroup.LayoutParams p = this.getLayoutParams();
    if (p instanceof LinearLayout.LayoutParams) {
        LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)p;
        if (_default) lp.setMargins(mc.oml, mc.omt, mc.omr, mc.omb);
        else lp.setMargins(mc.ml, mc.mt, mc.mr, mc.mb);
        this.setLayoutParams(lp);
    }
    else if (p instanceof RelativeLayout.LayoutParams) {
        RelativeLayout.LayoutParams lp = (RelativeLayout.LayoutParams)p;
        if (_default) lp.setMargins(mc.oml, mc.omt, mc.omr, mc.omb);
        else lp.setMargins(mc.ml, mc.mt, mc.mr, mc.mb);
        this.setLayoutParams(lp);
    }
    else if (p instanceof TableRow.LayoutParams) {
        TableRow.LayoutParams lp = (TableRow.LayoutParams)p;
        if (_default) lp.setMargins(mc.oml, mc.omt, mc.omr, mc.omb);
        else lp.setMargins(mc.ml, mc.mt, mc.mr, mc.mb);
        this.setLayoutParams(lp);
    }
}

क्योंकि this.getLayoutParams();रिटर्न एक ViewGroup.LayoutParamsहै, जो गुण नहीं है topMargin, bottomMargin, leftMargin, rightMargin। आपके द्वारा देखा जाने वाला mc उदाहरण केवल एक MarginContainerऑफसेट (-3dp) मार्जिन और (oml, omr, omt, omb) और मूल मार्जिन (ml, mr, mt, mb) है।

Answer 1

आपको LayoutParamsअपना बटन मार्जिन सेट करने के लिए उपयोग करना चाहिए :

LayoutParams params = new LayoutParams(
        LayoutParams.WRAP_CONTENT,      
        LayoutParams.WRAP_CONTENT
);
params.setMargins(left, top, right, bottom);
yourbutton.setLayoutParams(params);

आपके द्वारा उपयोग किए जा रहे लेआउट के आधार पर आपको उपयोग करना चाहिए RelativeLayout.LayoutParamsया LinearLayout.LayoutParams।

और अपने डीपी माप को पिक्सेल में बदलने के लिए, यह प्रयास करें:

Resources r = mContext.getResources();
int px = (int) TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_DIP,
        yourdpmeasure, 
        r.getDisplayMetrics()
);

Comments

मुझे उस विशेष लेआउटपार्म्स को किस पैकेज से आयात करना चाहिए?

— स्टील्थजोंग

setMargins ने px का उपयोग किया है और आप dp का उपयोग करेंगे, मेरा रूपांतरण सही है: dp -> px में सही मार्जिन मान सेट करें।

— थोरिन 19

@ChristiaandeJong RelativeLayout.LayoutParams

— stoefln

यह आपके वर्तमान लेआउट पर निर्भर करता है। यदि आप LinearLayout में हैं, तो LinearLayout.LayoutParams का उपयोग करें। RelativeLayout.LayoutParams अन्यथा

— Throrin19

आपको लेआउट आयात करना चाहिए जो कि आपके मूल लेआउट पूर्व है। <linearlayout> <सापेक्षता>> ग्रिडलेआउट> और आप ग्रिड लेआउट के साथ काम कर रहे हैं। उसके बाद, आपको

— रिलेटिवलीआउट.लेयआउटपराम

Answer 2

लेआउटपार्म्स - काम नहीं कर रहा है! ! !

इसके प्रकार का उपयोग करने की आवश्यकता है: MarginLayoutParams

MarginLayoutParams params = (MarginLayoutParams) vector8.getLayoutParams();
params.width = 200; params.leftMargin = 100; params.topMargin = 200;

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

http://www.codota.com/android/classes/android.view.ViewGroup.MarginLayoutParams

Comments

सही है, लेकिन इसे वापस सेट करने की कोई आवश्यकता नहीं है, बदले हुए परिमार्जन स्वचालित रूप से परिलक्षित होते हैं। इस प्रकार आप लाइन को हटा सकते हैं: वेक्टर8.सेटलेयूटपराम (परमेस);

— Wirsing

LayaoutParams आमतौर पर मार्जिन सेट करते समय भ्रम पैदा करता है ... इसलिए यह MarginLayoutParams बहुत उपयोगी है। साभार

— अतुल भारद्वाज

आप को परिवर्तन करने के बाद

— लैलाप्रेम (परम

मैंने MarginLayoutParams को आज #Thanks के नए वर्ग के रूप में पाया।

— तुषार पांडे

Buttonदेखने के लिए काम नहीं करता है : ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) button.getLayoutParams()रिटर्नnull

— कोनस्टेंटिन कोनपोको

Answer 3

सबसे अच्छा तरीका कभी:

private void setMargins (View view, int left, int top, int right, int bottom) {
    if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
        ViewGroup.MarginLayoutParams p = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
        p.setMargins(left, top, right, bottom);
        view.requestLayout();
    }
}

कैसे कॉल करें विधि:

setMargins(mImageView, 50, 50, 50, 50);

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

Comments

जब मैं सेटमर्गेन्स (धारक .vCenter, 0, 20, 0,0) सेट करता हूं तो मुझे समस्या का सामना करना पड़ रहा है ; इस तरह इसके दोनों पक्षों (ऊपर और नीचे) को छोड़ दें, तो ऊपर दिए गए पैरामस के साथ क्या गलत है?

— Arbaz.in

बहुत बढ़िया सही जवाब !! धन्यवाद!!

— Sjd

Answer 4

int sizeInDP = 16;

int marginInDp = (int) TypedValue.applyDimension(
            TypedValue.COMPLEX_UNIT_DIP, sizeInDP, getResources()
                    .getDisplayMetrics());

फिर

layoutParams = myView.getLayoutParams()
layoutParams.setMargins(marginInDp, marginInDp, marginInDp, marginInDp);
myView.setLayoutParams(layoutParams);

या

LayoutParams layoutParams = new LayoutParams...
layoutParams.setMargins(marginInDp, marginInDp, marginInDp, marginInDp);
myView.setLayoutParams(layoutParams);

Answer 5

यहाँ हाल ही में अद्यतन के साथ सभी में एक जवाब है:

चरण 1, मार्जिन को अद्यतन करने के लिए

मूल विचार है मार्जिन को बाहर निकालना और फिर उसे अपडेट करना। अपडेट स्वचालित रूप से लागू होगा और आपको इसे वापस सेट करने की आवश्यकता नहीं है। लेआउट पैरामीटर प्राप्त करने के लिए, बस इस विधि को कॉल करें:

LayoutParams layoutParams = (LayoutParams) yourView.findViewById(R.id.THE_ID).getLayoutParams();

LayoutParamsआपके विचार के लेआउट से आता है। यदि दृश्य रैखिक लेआउट से है, तो आपको आयात करने की आवश्यकता है LinearLayout.LayoutParams। यदि आप सापेक्ष लेआउट, आयात LinearLayout.LayoutParamsआदि का उपयोग करते हैं

अब, अगर आप का उपयोग कर मार्जिन सेट Layout_marginLeft, Rightआदि, आप अद्यतन मार्जिन को इस तरह से की जरूरत है

layoutParams.setMargins(left, top, right, bottom);

यदि आप नए का उपयोग करके मार्जिन सेट करते हैं layout_marginStart, तो आपको इस तरह से मार्जिन अपडेट करने की आवश्यकता है

layoutParams.setMarginStart(start);
layoutParams.setMarginEnd(end);

चरण 2, डीपी में मार्जिन अपडेट करने के लिए

ऊपर मार्जिन को अपडेट करने के सभी दो तरीके पिक्सेल में अपडेट हो रहे हैं। आपको पिक्सेल के लिए dp का अनुवाद करना होगा।

float dpRatio = context.getResources().getDisplayMetrics().density;
int pixelForDp = (int)dpValue * dpRatio;

अब परिकलित मान को उपरोक्त मार्जिन अपडेट फ़ंक्शंस में डालें और आपको सभी सेट होना चाहिए

Answer 6

layout_margin एक बाधा है जो एक दृश्य बच्चा अपने माता-पिता को बताता है। हालांकि यह मार्जिन की अनुमति देने के लिए चुनना माता-पिता की भूमिका है। मूल रूप से एंड्रॉइड सेट करके: layout_margin = "10dp", बच्चा अपने वास्तविक आकार से 10dp बड़ा होने वाले स्थान को आवंटित करने के लिए पैरेंट व्यू समूह से अनुरोध कर रहा है । (पैडिंग = "10dp", दूसरी ओर, इसका मतलब है कि बच्चे का दृश्य अपनी सामग्री 10dp को छोटा बना देगा ।)

नतीजतन, सभी व्यूग्रुप्स मार्जिन का सम्मान नहीं करते हैं । सबसे कुख्यात उदाहरण श्रवण होगा, जहां वस्तुओं के मार्जिन की अनदेखी की जाती है। setMargin()लेआउटपरम पर कॉल करने से पहले , आपको हमेशा यह सुनिश्चित करना चाहिए कि वर्तमान दृश्य एक व्यूग्रुप में रह रहा है जो मार्जिन का समर्थन करता है (जैसे लाइनरलाइयोट या getLayoutParams()रिलेटिवलैटआउट ), और जो आप चाहते हैं वह विशिष्ट लेआउटपार्म्स के परिणाम कास्ट करें । ( विधि ViewGroup.LayoutParamsभी नहीं है setMargins()!)

नीचे दिए गए फ़ंक्शन को ट्रिक करना चाहिए। हालाँकि, सुनिश्चित करें कि आप मूल दृश्य के प्रकार से RelativeLayout स्थानापन्न करें।

private void setMargin(int marginInPx) {
    RelativeLayout.LayoutParams lp = (RelativeLayout.LayoutParams) getLayoutParams();
    lp.setMargins(marginInPx,marginInPx, marginInPx, marginInPx);
    setLayoutParams(lp);
}

Answer 7

यह विधि आपको डीपी में मार्जिन सेट करने देगी

public void setMargin(Context con,ViewGroup.LayoutParams params,int dp) {

        final float scale = con.getResources().getDisplayMetrics().density;
        // convert the DP into pixel
        int pixel =  (int)(dp * scale + 0.5f); 

        ViewGroup.MarginLayoutParams s =(ViewGroup.MarginLayoutParams)params;
        s.setMargins(pixel,pixel,pixel,pixel);

        yourView.setLayoutParams(params);
}

अपडेट करें

आप अपनी जरूरत के हिसाब से पैरामीटर बदल सकते हैं।

Answer 8

कोटलिन में यह इस तरह दिखेगा:

val layoutParams = (yourView?.layoutParams as? MarginLayoutParams)
layoutParams?.setMargins(40, 40, 40, 40)
yourView?.layoutParams = layoutParams

Answer 9

जब आप कस्टम दृश्य में होते हैं, तो आप उपयोग कर सकते हैं getDimensionPixelSize(R.dimen.dimen_value), मेरे मामले में, मैंने initपद्धति पर बनाए गए लेआउटपार्म्स में मार्जिन जोड़ा ।

कोटलिन में

init {
    LayoutInflater.from(context).inflate(R.layout.my_layout, this, true)
    layoutParams = LayoutParams(MATCH_PARENT, WRAP_CONTENT).apply {
    val margin = resources.getDimensionPixelSize(R.dimen.dimen_value)
    setMargins(0, margin, 0, margin)
}

जावा में:

public class CustomView extends LinearLayout {

    //..other constructors

    public CustomView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        LayoutParams params = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
        int margin = getResources().getDimensionPixelSize(R.dimen.spacing_dime);
        params.setMargins(0, margin, 0, margin);
        setLayoutParams(params);
    }
}

Answer 10

Dp में मार्जिन सेट करने के लिए इस विधि का उपयोग करें

private void setMargins (View view, int left, int top, int right, int bottom) {
    if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
        ViewGroup.MarginLayoutParams p = (ViewGroup.MarginLayoutParams) view.getLayoutParams();

        final float scale = getBaseContext().getResources().getDisplayMetrics().density;
        // convert the DP into pixel
        int l =  (int)(left * scale + 0.5f);
        int r =  (int)(right * scale + 0.5f);
        int t =  (int)(top * scale + 0.5f);
        int b =  (int)(bottom * scale + 0.5f);

        p.setMargins(l, t, r, b);
        view.requestLayout();
    }
}

विधि को बुलाओ:

setMargins(linearLayout,5,0,5,0);

Answer 11

एक त्वरित एक-पंक्ति सेटअप उपयोग के लिए

((LayoutParams) cvHolder.getLayoutParams()).setMargins(0, 0, 0, 0);

लेकिन लेआउटप्रैम के किसी भी गलत उपयोग के लिए कैरिफ हो, क्योंकि इसमें कोई स्टेटमेंट ifउदाहरण नहीं होगा

Answer 12

आप में से उन लोगों के लिए एक कोटलिन एक्सटेंशन फ़ंक्शन बनाया गया है जो इसे काम में ला सकते हैं।

पिक्सल में गुजरने के लिए सुनिश्चित करें कि डीपी नहीं। मुबारक कोडिंग :)

fun View.addLayoutMargins(left: Int? = null, top: Int? = null,
                      right: Int? = null, bottom: Int? = null) {
    this.layoutParams = ViewGroup.MarginLayoutParams(this.layoutParams)
            .apply {
                left?.let { leftMargin = it }
                top?.let { topMargin = it }
                right?.let { rightMargin = it }
                bottom?.let { bottomMargin = it }
            }
}

Answer 13

मेरे उदाहरण में मैं प्रोग्रामर के लिए एक इमेज व्यू को रैखिक रूप से जोड़ रहा हूं। मैंने ImagerView को शीर्ष और निचला मार्जिन निर्धारित किया है। फिर LinearLayout में ImageView जोड़ रहा है।

        ImageView imageView = new ImageView(mContext);
        imageView.setImageBitmap(bitmap);
        LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
                LinearLayout.LayoutParams.MATCH_PARENT,
                LinearLayout.LayoutParams.WRAP_CONTENT
        );
        params.setMargins(0, 20, 0, 40);
        imageView.setLayoutParams(params);
        linearLayout.addView(imageView);

Answer 14

आप इस विधि का उपयोग कर सकते हैं और 20 की तरह स्थिर डिमेन डाल सकते हैं जो आपके डिवाइस के अनुसार परिवर्तित हो जाता है

 public static int dpToPx(int dp) 
      {
          float scale = context.getResources().getDisplayMetrics().density;
       return (int) (dp * scale + 0.5f);
  }

Answer 15

आज के रूप में, सबसे अच्छा शायद AirBnB द्वारा उपलब्ध कराई गई एक लाइब्रेरी पेरिस का उपयोग करना है ।

शैलियों को इस तरह लागू किया जा सकता है:

Paris.style(myView).apply(R.style.MyStyle);

यह एनोटेशन का उपयोग करके कस्टम दृश्य (यदि आप कोई दृश्य बढ़ाते हैं) का भी समर्थन करते हैं:

@Styleable and @Style

Answer 16

आपको बुलाना पड़ेगा

setPadding(int left, int top, int right, int bottom)

इस तरह: your_view.setPadding(0,16,0,0)

आप जो उपयोग करने का प्रयास कर रहे हैं वह केवल पाने वाला है।

Android स्टूडियो दिखाता है कि padding...()वास्तव में जावा में क्या मतलब है:

पैडिंग उदाहरण छवि केवल कॉल को दिखाती हैgetPadding...()

यदि आप अपने TextView में एक मार्जिन जोड़ना चाहते हैं, तो आपको LayoutParams करना होगा:

val params =  LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT,LinearLayout.LayoutParams.WRAP_CONTENT)
params.setMargins(int left, int top, int right, int bottom)
your_view.layoutParams = params

Answer 17

((FrameLayout.LayoutParams) linearLayout.getLayoutParams()).setMargins(450, 20, 0, 250);
        linearLayout.setBackgroundResource(R.drawable.smartlight_background);

मुझे FrameLayoutएक रेखीय लयआउट के लिए मुझे कास्ट करना था क्योंकि यह उससे विरासत में मिला था और वहाँ मार्जिन सेट किया था, इसलिए गतिविधि केवल स्क्रीन के एक हिस्से पर एक अलग पृष्ठभूमि के साथ दिखाई देती है, जिसमें मूल लेआउट पैरा शामिल हैं setContentView।

LinearLayout linearLayout = (LinearLayout) findViewById(R.id.activity);
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(WindowManager.LayoutParams.FILL_PARENT, WindowManager.LayoutParams.MATCH_PARENT);
linearLayout.setBackgroundColor(getResources().getColor(R.color.full_white));
setContentView(linearLayout,layoutParams);

किसी अन्य ने एक ही गतिविधि का उपयोग करने और एक अलग मेनू से गतिविधि को खोलने के आधार पर मार्जिन को बदलने के लिए काम नहीं किया! setLayoutParams ने मेरे लिए कभी काम नहीं किया - डिवाइस हर बार दुर्घटनाग्रस्त हो जाता है। भले ही ये हार्डकोड नंबर हों - यह केवल प्रदर्शन उद्देश्यों के लिए कोड का एक उदाहरण है।

Answer 18

आप ViewGroup.MarginLayoutParamsचौड़ाई, ऊंचाई और मार्जिन सेट करने के लिए उपयोग कर सकते हैं

ViewGroup.MarginLayoutParams marginLayoutParams = new ViewGroup.MarginLayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
marginLayoutParams.setMargins(0,16,0,16);
linearLayout.setLayoutParams(marginLayoutParams);

जहां विधि setMargins();क्रमशः बाएं, ऊपर, दाएं, नीचे के लिए मान लेती है। दक्षिणावर्त!, बाएं से शुरू।