रिलेटिवलीआउट में प्रतिशत चौड़ाई

450

मैं Activityअपने एंड्रॉइड ऐप में लॉगिन के लिए एक फॉर्म लेआउट पर काम कर रहा हूं । नीचे दी गई छवि है कि मैं इसे कैसे दिखना चाहता हूं:

यहां छवि विवरण दर्ज करें

मैं निम्नलिखित XML के साथ इस लेआउट को प्राप्त करने में सक्षम था । समस्या यह है, यह थोड़ा हैकिश है। मुझे HostText होस्ट के लिए एक हार्ड-कोड की आवश्यकता थी। विशेष रूप से, मुझे निर्दिष्ट करना था:

android:layout_width="172dp"

मैं वास्तव में होस्ट और पोर्ट को संपादित करने के लिए प्रतिशत चौड़ाई देना चाहूंगा। (मेजबान के लिए 80%, पोर्ट के लिए 20% की तरह कुछ।) क्या यह संभव है? निम्न XML मेरे Droid पर काम करता है, लेकिन यह सभी स्क्रीन के लिए काम नहीं करता है। मैं वास्तव में अधिक मजबूत समाधान चाहूंगा।

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/main"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent" >

    <TextView
        android:id="@+id/host_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/home"
        android:paddingLeft="15dp"
        android:paddingTop="0dp"
        android:text="host"
        android:textColor="#a5d4e2"
        android:textSize="25sp"
        android:textStyle="normal" />

    <TextView
        android:id="@+id/port_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/home"
        android:layout_toRightOf="@+id/host_input"
        android:paddingTop="0dp"
        android:text="port"
        android:textColor="#a5d4e2"
        android:textSize="25sp"
        android:textStyle="normal" />

    <EditText
        android:id="@+id/host_input"
        android:layout_width="172dp"
        android:layout_height="wrap_content"
        android:layout_below="@id/host_label"
        android:layout_marginLeft="15dp"
        android:layout_marginRight="15dp"
        android:layout_marginTop="4dp"
        android:background="@android:drawable/editbox_background"
        android:inputType="textEmailAddress" />

    <EditText
        android:id="@+id/port_input"
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:layout_below="@id/host_label"
        android:layout_marginTop="4dp"
        android:layout_toRightOf="@id/host_input"
        android:background="@android:drawable/editbox_background"
        android:inputType="number" />

    <TextView
        android:id="@+id/username_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/host_input"
        android:paddingLeft="15dp"
        android:paddingTop="15dp"
        android:text="username"
        android:textColor="#a5d4e2"
        android:textSize="25sp"
        android:textStyle="normal" />

    <EditText
        android:id="@+id/username_input"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_below="@id/username_label"
        android:layout_marginLeft="15dp"
        android:layout_marginRight="15dp"
        android:layout_marginTop="4dp"
        android:background="@android:drawable/editbox_background"
        android:inputType="textEmailAddress" />

    <TextView
        android:id="@+id/password_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/username_input"
        android:paddingLeft="15dp"
        android:paddingTop="15dp"
        android:text="password"
        android:textColor="#a5d4e2"
        android:textSize="25sp"
        android:textStyle="normal" />

    <EditText
        android:id="@+id/password_input"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_below="@id/password_label"
        android:layout_marginLeft="15dp"
        android:layout_marginRight="15dp"
        android:layout_marginTop="4dp"
        android:background="@android:drawable/editbox_background"
        android:inputType="textPassword" />

    <ImageView
        android:id="@+id/home"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="false"
        android:paddingLeft="15dp"
        android:paddingRight="15dp"
        android:paddingTop="15dp"
        android:scaleType="fitStart"
        android:src="@drawable/home" />

    <Button
        android:id="@+id/login_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/password_input"
        android:layout_marginLeft="15dp"
        android:layout_marginTop="15dp"
        android:text="   login   "
        android:textSize="18sp" >
    </Button>

</RelativeLayout>
android  android-layout  android-relativelayout 
— सरसों
स्रोत
मुझे इस तरह के सवाल का जवाब देने के लिए चीजों को साफ करने में कुछ समय लगा: stackoverflow.com/questions/7846614/…
— hcpl
1
Android का उपयोग करने पर विचार करें: TextView के बजाय EditText में संकेत दें। स्थान बचाता है
— एल्मिसॉफ्ट
— nitesh

जवाबों:

760

तुम android:layout_weightविशेषता खोज रहे हो । यह आपके लेआउट को परिभाषित करने के लिए प्रतिशत का उपयोग करने की अनुमति देगा।

निम्नलिखित उदाहरण में, बाएं बटन 70% स्थान का उपयोग करता है, और दायां बटन 30%।

<LinearLayout
    android:layout_width="match_parent" 
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <Button
        android:text="left" 
        android:layout_width="0dp" 
        android:layout_height="wrap_content" 
        android:layout_weight=".70" /> 

    <Button
        android:text="right" 
        android:layout_width="0dp" 
        android:layout_height="wrap_content" 
        android:layout_weight=".30" />

</LinearLayout>

यह किसी भी प्रकार के दृश्य के साथ समान कार्य करता है, आप अपनी आवश्यकताओं को पूरा करने के लिए कुछ EditText वाले बटन को बदल सकते हैं।

layout_widthपर 0dpया अपने विचारों को ठीक से स्केल नहीं किया जा सकता सेट करने के लिए सुनिश्चित करें ।

ध्यान दें कि वजन योग 1 के बराबर नहीं है, मुझे बस इस तरह पढ़ना आसान लगता है। आप पहला वजन 7 और दूसरा 3 पर सेट कर सकते हैं और यह एक ही परिणाम देगा।

— Dalmas
स्रोत
171
यह LinearLayout का उपयोग करने के लिए समझ में आता है, हालांकि वह एक RelativeLayout चाहता था। वहाँ किसी भी तरह से मैं एक सूची आइटम के लिए RelativeLayout का उपयोग करने की आवश्यकता है
— माइकल एलन
33
हां, अपने RelativeLayout के अंदर एक नेस्टर्ड लीनियरआउट बनाएं, जहां आप प्रतिशत का उपयोग करना चाहते हैं।
— दलमास 14
17
LadaRaider द्वारा ऊपर दिया गया उत्तर मेरे लिए तभी काम करता है जब मैं 0px की चौड़ाई निर्धारित करता हूँ। एंड्रॉइड:
— लेआउट_ एक्सपोज़र
6
या सिर्फ एक बटन के बजाय एक दृश्य। यह अधिक स्पष्ट है कि यह कुछ भी नहीं करता है।
— लांस नानक
13
यह उत्तर पूरी तरह से काम करता है, लेकिन यदि आप किसी RelativeLayout का उपयोग करते हुए मृत हो गए थे, तो अब आप समर्थन लाइब्रेरी संस्करण 23.0.0 से PercentRelativeLayout का उपयोग कर सकते हैं ।
— neits
290

यह मूल प्रश्न का पर्याप्त उत्तर नहीं देता है, जो 70/30 विभाजन के लिए था, लेकिन घटकों के बीच 50/50 विभाजन के विशेष मामले में एक तरीका है: केंद्र पर एक अदृश्य अकड़ रखें और इसे स्थिति में उपयोग करें ब्याज के दो घटक।

<RelativeLayout 
    android:layout_width="match_parent"
    android:layout_height="wrap_content">
    <View android:id="@+id/strut"
        android:layout_width="0dp"
        android:layout_height="0dp" 
        android:layout_centerHorizontal="true"/>
    <Button
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_alignRight="@id/strut"
        android:layout_alignParentLeft="true"
        android:text="Left"/> 
    <Button 
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@id/strut"
        android:layout_alignParentRight="true"
        android:text="Right"/>
</RelativeLayout>

जैसा कि यह एक बहुत ही सामान्य मामला है, यह समाधान एक जिज्ञासा से अधिक है। यह एक हैक का एक सा है लेकिन एक कुशल है क्योंकि खाली, शून्य आकार की अकड़ बहुत कम खर्च करनी चाहिए।

सामान्य तौर पर, हालांकि, स्टॉक एंड्रॉइड लेआउट से बहुत अधिक उम्मीद नहीं करना ...

— olefevre
स्रोत
8
मैं वास्तव में विचार प्यार करता हूँ! मुझे RelativeLayout बहुत पसंद है, और यह मेरे लिए एक TableLayout का उपयोग करने से बचने का एक और कारण है। धन्यवाद! :)
— मध्याचल
19
हम सभी को वर्कअराउंड की आवश्यकता क्यों है जो मैं जानना चाहता हूं। यह HTML की एक बुनियादी और दीर्घकालिक विशेषता है। निश्चित रूप से एंड्रॉइड डेवलपर्स एचटीएमएल पर देख सकते थे कि लोगों को क्या जरूरत है और उपयोग करने जा रहे हैं, कुछ समझ पाने के लिए!
— जॉन्क
2
@ जॉन पूरी तरह से सहमत हैं। html / css एंड्रॉइड लेआउट सिस्टम की तुलना में बहुत बेहतर और सरल है।
— निको ई।
1
यदि मैं 70/30 प्राप्त करना चाहता हूं तो क्या होगा RelativeLayout?
— आदिल मलिक
16
आप android:visibility="invisible"
— ऑनड्रॉल
134

अपडेट १

जैसा कि @EmJiHash PercentRelativeLayout ने बताया कि एपीआई स्तर 26.0.0 में पदावनत है

Google टिप्पणी के हवाले से:

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

Google ने android.support.percent नामक नया एपीआई पेश किया

तब आप केवल दृश्य द्वारा प्रतिशत लेने के लिए निर्दिष्ट कर सकते हैं

जैसे संकलन निर्भरता जोड़ें 

implementation 'com.android.support:percent:22.2.0

उस में, PercentRelativeLayout वह है जो हम प्रतिशत बुद्धिमान लेआउट कर सकते हैं

 <android.support.percent.PercentRelativeLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
     android:layout_height="match_parent">
     <ImageView
         app:layout_widthPercent="50%"
         app:layout_heightPercent="50%"
         app:layout_marginTopPercent="25%"
         app:layout_marginLeftPercent="25%"/>
 </android.support.percent.PercentRelativeLayout>
— न्यू जर्सी
स्रोत
4
यदि आप इसे सूची आइटम के लिए उपयोग करना चाहते हैं तो यह काम नहीं करेगा
— jemo mgebrishvili
1
यह स्तर एपीआई स्तर 26.0.0-beta1 में पदावनत किया गया था।
— कॉन्ट्राटाइनलआउट
1
संकलित पदावनत है, कार्यान्वयन का उपयोग करें।
— बे
81

आप किसी RelativeLayout के अंदर किसी दृश्य के आयामों को परिभाषित करने के लिए प्रतिशत का उपयोग नहीं कर सकते हैं। इसके लिए सबसे अच्छा तरीका है कि LinearLayout और वजन या एक कस्टम लेआउट का उपयोग करें।

— रोमेन गाइ
स्रोत
15
अपना उत्तर अपडेट करने का समय, आप यहाँ एक चुने हुए हैं :)
— Ultimo_m
31

आप नए प्रतिशत समर्थन पुस्तकालय पर एक नज़र डाल सकते हैं। 

compile 'com.android.support:percent:22.2.0'

डॉक्स

नमूना

— gbero
स्रोत
1
यह स्तर एपीआई स्तर 26.0.0-beta1 में पदावनत किया गया था। इसके बजाय ConstraintLayout और संबंधित लेआउट का उपयोग करने पर विचार करें।
— EmJiHash
19

आप PercentRelativeLayout का उपयोग कर सकते हैं , यह डिज़ाइन सपोर्ट लाइब्रेरी के लिए एक हाल ही में बनाया गया अनपेक्षित है , जो न केवल तत्वों को एक दूसरे के सापेक्ष निर्दिष्ट करने की क्षमता प्रदान करता है, बल्कि उपलब्ध स्थान का कुल प्रतिशत भी है।

प्रतिशत आधारित आयाम और मार्जिन का समर्थन करने वाले RelativeLayout का उपवर्ग। आप "प्रतिशत" प्रत्यय के साथ विशेषताओं का उपयोग करके आयाम या बच्चे के एक अंश को निर्दिष्ट कर सकते हैं।

<android.support.percent.PercentRelativeLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
     android:layout_height="match_parent">
  <ImageView
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      app:layout_widthPercent="50%"
      app:layout_heightPercent="50%"
      app:layout_marginTopPercent="25%"
      app:layout_marginLeftPercent="25%"/>
</android.support.percent.PercentFrameLayout>

प्रतिशत पैकेज जोड़ने और प्रबंधन प्रतिशत का समर्थन करने के लिए एपीआई प्रदान करता है आपके ऐप में आधारित आयामों को ।

उपयोग करने के लिए, आपको इस लाइब्रेरी को अपनी ग्रेडल निर्भरता सूची में जोड़ना होगा :

dependencies {
    compile 'com.android.support:percent:22.2.0'//23.1.1
}
— इंटेलीज अमिया
स्रोत
1
अभी भी परिभाषित करने की आवश्यकता हैandroid:layout_width="match_parent"
— ली 2
मेरे पास एक टेक्स्टव्यू के साथ एक मुद्दा था जो फ़ॉन्ट पैडिंग पाठ फसल का कारण बन रहा था, और इसने इसे पूरी तरह से हल किया। आपका बहुत बहुत धन्यवाद!
— दिनकरनम्स २१'१en
1
यह स्तर एपीआई स्तर 26.0.0-beta1 में पदावनत किया गया था।
— कॉन्सट्रैटिनलाईट
12

मैंने इसे एक कस्टम दृश्य बनाते हुए हल किया है:

public class FractionalSizeView extends View {
  public FractionalSizeView(Context context, AttributeSet attrs) {
    super(context, attrs);
  }

  public FractionalSizeView(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
  }

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int width = MeasureSpec.getSize(widthMeasureSpec);
    setMeasuredDimension(width * 70 / 100, 0);
  }
}

यह अदृश्य अकड़ है जिसका उपयोग मैं RelativeLayout के भीतर अन्य विचारों को संरेखित करने के लिए कर सकता हूं।

— इवान वोलोसुक
स्रोत
11

अपडेट करें

जैसा कि @EmJiHash PercentRelativeLayout और PercentFrameLayout ने बताया कि एपीआई स्तर 26.0.0 में पदावनत है

कांस्ट्रेन्थलाईट का उपयोग करने पर विचार करें

Google ने नई एपीआई नाम की शुरुआत की android.support.percent

1) PercentRelativeLayout

2) PercentFrameLayout

जैसे संकलन निर्भरता जोड़ें

compile 'com.android.support:percent:23.1.1'

आप प्रतिशत में आयाम निर्दिष्ट कर सकते हैं ताकि लाभ RelativeLayoutऔर प्रतिशत दोनों प्राप्त कर सकें

 <android.support.percent.PercentRelativeLayout
         xmlns:android="http://schemas.android.com/apk/res/android"
         xmlns:app="http://schemas.android.com/apk/res-auto"
         android:layout_width="match_parent"
         android:layout_height="match_parent"/>
     <TextView
         app:layout_widthPercent="40%"
         app:layout_heightPercent="40%"
         app:layout_marginTopPercent="15%"
         app:layout_marginLeftPercent="15%"/>
 </android.support.percent.PercentRelativeLayout/>
— ठंडा गलन
स्रोत
यदि आप इसे सूची आइटम के लिए उपयोग करना चाहते हैं तो यह काम नहीं करेगा
— jemo mgebrishvili
1
यह स्तर एपीआई स्तर 26.0.0-beta1 में पदावनत किया गया था। इसके बजाय ConstraintLayout और संबंधित लेआउट का उपयोग करने पर विचार करें।
— EmJiHash
11

चूंकि PercentRelativeLayout 26.0.0 में पदावनत कर दिया गया था और RelativeLayout के अंदर LinearLayout जैसे नेस्टेड प्रदर्शन पर एक नकारात्मक प्रभाव पड़ता है ( के प्रदर्शन लाभ को समझना ) प्रतिशत चौड़ाई प्राप्त करने के लिए आपके लिए सबसे अच्छा विकल्प यह है कि आप अपने RelativeLayout को ConstraintLayout से बदल दें।

इसे दो तरीकों से हल किया जा सकता है।

समाधान # 1 प्रतिशत ऑफसेट के साथ दिशानिर्देशों का उपयोग करना

लेआउट संपादक

<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/host_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Host"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="@+id/host_input" />

    <TextView
        android:id="@+id/port_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Port"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="@+id/port_input" />

    <EditText
        android:id="@+id/host_input"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="8dp"
        android:inputType="textEmailAddress"
        app:layout_constraintTop_toBottomOf="@+id/host_label"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toLeftOf="@+id/guideline" />

    <EditText
        android:id="@+id/port_input"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="8dp"
        android:inputType="number"
        app:layout_constraintTop_toBottomOf="@+id/port_label"
        app:layout_constraintLeft_toLeftOf="@+id/guideline"
        app:layout_constraintRight_toRightOf="parent" />

    <android.support.constraint.Guideline
        android:id="@+id/guideline"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        app:layout_constraintGuide_percent="0.8" />

</android.support.constraint.ConstraintLayout>

समाधान # 2 EditText के लिए भारित चौड़ाई के साथ श्रृंखला का उपयोग करना

लेआउट संपादक

<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/host_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Host"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="@+id/host_input" />

    <TextView
        android:id="@+id/port_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Port"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="@+id/port_input" />

    <EditText
        android:id="@+id/host_input"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="8dp"
        android:inputType="textEmailAddress"
        app:layout_constraintHorizontal_weight="0.8"
        app:layout_constraintTop_toBottomOf="@+id/host_label"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toLeftOf="@+id/port_input" />

    <EditText
        android:id="@+id/port_input"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="8dp"
        android:inputType="number"
        app:layout_constraintHorizontal_weight="0.2"
        app:layout_constraintTop_toBottomOf="@+id/port_label"
        app:layout_constraintLeft_toRightOf="@+id/host_input"
        app:layout_constraintRight_toRightOf="parent" />

</android.support.constraint.ConstraintLayout>

दोनों ही मामलों में, आपको ऐसा कुछ मिलता है

परिणाम देखें

— यूजीन ब्रूसोव
स्रोत
बाधा लेआउट बहुत धीमी और बगियरियर है
— ड्रैगोस राचियेरू
7

PercentRelativeLayout समर्थन लाइब्रेरी के संशोधन 26.0.0 से निकाला गया है।

Google ने ConstraintLayout नाम से नया लेआउट पेश किया ।

लायब्रेरी को अपने मॉड्यूल-स्तर build.gradle फ़ाइल में निर्भरता के रूप में जोड़ें:

     dependencies {
        compile 'com.android.support.constraint:constraint-layout:1.0.1'
      }

बस एक लेआउट फ़ाइल में जोड़ें:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
</android.support.constraint.ConstraintLayout>

प्रतिबन्ध

बाधाएं आपको विजेट्स को संरेखित रखने में मदद करती हैं। विभिन्न विगेट्स के बीच संरेखण नियमों को निर्धारित करने के लिए, आप नीचे दिखाए गए अवरोध जैसे एंकर का उपयोग कर सकते हैं।

  1. Wrap Content: इसकी सामग्री को फिट करने के लिए आवश्यकतानुसार दृश्य विस्तृत होता है।
  2. Match Constraints: मार्जिन के लिए लेखांकन के बाद अपने बाधाओं की परिभाषा को पूरा करने के लिए दृश्य विस्तार की आवश्यकता है। हालांकि, यदि दिए गए आयाम में केवल एक बाधा है, तो दृश्य इसकी सामग्री को फिट करने के लिए फैलता है। या तो ऊँचाई या चौड़ाई पर इस मोड का उपयोग करने से आप एक आकार अनुपात सेट कर सकते हैं।
  3. Fixed: आप नीचे दिए गए टेक्स्ट बॉक्स में एक विशिष्ट आयाम निर्दिष्ट करते हैं या संपादक में दृश्य का आकार बदलकर।
  4. Spread: विचार समान रूप से वितरित किए जाते हैं (मार्जिन के लिए जिम्मेदार हैं)। यह डिफ़ॉल्ट है।
  5. Spread inside: श्रृंखला के प्रत्येक छोर पर बाधाओं को पहले और अंतिम दृश्य को चिपका दिया जाता है और बाकी समान रूप से वितरित किया जाता है।
  6. Weighted: जब श्रृंखला को या तो फैलाने या अंदर फैलाने के लिए सेट किया जाता है, तो आप "मैच बाधाओं" (0dp) के लिए एक या अधिक दृश्य सेट करके शेष स्थान को भर सकते हैं। डिफ़ॉल्ट रूप से, अंतरिक्ष को समान रूप से प्रत्येक दृश्य के बीच वितरित किया जाता है जो "मैच बाधाओं" पर सेट होता है, लेकिन आप लेआउट_constraintHor क्षैतिज_weight और Layout_constraintVertical -weight विशेषताओं का उपयोग करके प्रत्येक दृश्य को महत्व का एक वजन प्रदान कर सकते हैं। यदि आप एक रेखीय लेआउट में लेआउट_वेट से परिचित हैं, तो यह उसी तरह काम करता है। तो उच्चतम वजन मूल्य के साथ दृश्य को सबसे अधिक स्थान मिलता है; एक ही भार वाले दृश्यों को समान मात्रा में स्थान मिलता है।
  7. Packed: विचार एक साथ भरे हुए हैं (हाशिये के हिसाब के बाद)। फिर आप श्रृंखला के प्रमुख दृश्य पूर्वाग्रह को बदलकर पूरी श्रृंखला के पूर्वाग्रह (बाएं / दाएं या ऊपर / नीचे) को समायोजित कर सकते हैं।
  8. Center Horizontally or Center Vertically: जल्दी से विचारों की एक श्रृंखला बनाने के लिए, उन सभी का चयन करें, किसी एक विचार पर राइट-क्लिक करें, और फिर क्षैतिज या ऊर्ध्वाधर श्रृंखला बनाने के लिए या तो केंद्र क्षैतिज या केंद्र का चयन करें।
  9. Baseline alignment: किसी दृश्य के टेक्स्ट बेसलाइन को किसी अन्य दृश्य के टेक्स्ट बेसलाइन में संरेखित करें।
  10. Constrain to a guideline: आप एक ऊर्ध्वाधर या क्षैतिज दिशानिर्देश जोड़ सकते हैं जिससे आप विचारों को बाधित कर सकते हैं, और दिशानिर्देश उपयोगकर्ताओं को एप्लिकेशन के लिए अदृश्य हो जाएगा। आप लेआउट इकाइयों के आधार पर दिशानिर्देशों को या तो डीपी इकाइयों या प्रतिशत के आधार पर लेआउट के भीतर रख सकते हैं।
  11. Adjust the constraint bias: जब आप किसी दृश्य के दोनों किनारों पर एक बाधा डालते हैं (और समान आयाम के लिए दृश्य आकार या तो "निश्चित" या "रैप सामग्री") है, तो दृश्य दो बाधाओं के बीच डिफ़ॉल्ट रूप से 50% के पूर्वाग्रह के साथ केंद्रित हो जाता है। आप गुण विंडो में पूर्वाग्रह स्लाइडर को खींचकर पूर्वाग्रह को समायोजित कर सकते हैं
  12. Set size as a ratio: आप दृश्य आकार को 16: 9 के अनुपात में सेट कर सकते हैं यदि कम से कम एक दृश्य आयाम "मैच बाधाओं" (0dp) पर सेट है।

आप आधिकारिक डॉक्टर से अधिक जान सकते हैं ।

— Darish
स्रोत
3

आप इसे लेआउट वेट के माध्यम से पूरा कर सकते हैं। एक भार यह तय करता है कि स्क्रीन के लावारिस हिस्सों को कैसे विभाजित किया जाता है। प्रत्येक EditText को 0 का एक लेआउट_ एक्सपोज़र और कुछ आनुपातिक वजन दें। यानी, एक का वजन 2 है, और दूसरे का 1 का वजन है, अगर आप चाहते हैं कि पहले दो बार ज्यादा से ज्यादा जगह लें।

— चेरिल साइमन
स्रोत
3

दिलचस्प रूप से पर्याप्त है, @olefevre से जवाब पर निर्माण, एक "अदृश्य स्ट्रट्स" के साथ न केवल 50/50 लेआउट कर सकता है, बल्कि सभी प्रकार के लेआउट जिसमें दो की शक्तियां शामिल हैं।

उदाहरण के लिए, यहां एक लेआउट है जो चौड़ाई को चार बराबर भागों में काटता है (वास्तव में तीन, 1, 1, 2 के वजन के साथ):

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" >

    <View
        android:id="@+id/strut"
        android:layout_width="1dp"
        android:layout_height="match_parent"
        android:layout_centerHorizontal="true"
        android:background="#000000" />

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_toLeftOf="@+id/strut" >

        <View
            android:id="@+id/left_strut"
            android:layout_width="1dp"
            android:layout_height="match_parent"
            android:layout_toLeftOf="@+id/strut"
            android:layout_centerHorizontal="true"
            android:background="#000000" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_alignParentLeft="true"
            android:layout_alignRight="@+id/left_strut"
            android:text="Far Left" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_alignParentRight="true"
            android:layout_toRightOf="@+id/left_strut"
            android:text="Near Left" />
    </RelativeLayout>

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@id/strut"
            android:layout_alignParentRight="true"
            android:text="Right" />

</RelativeLayout>
— कोको
स्रोत
1
अच्छा प्रयास करें, लेकिन आप कुछ ऐसी चीजों को समाप्त कर देते हैं, जो लिनियरलाइट समाधान से अधिक जटिल हैं, जिनसे हम बचने की कोशिश करते हैं। जरूरत एक अद्वितीय सापेक्ष लेआउट में सभी विचारों को रखने की है (यह उन दोनों के बीच सापेक्ष बाधाओं को अनुमति देने के लिए है)
— Orab'g
1
प्रदर्शन के लिए नेस्टेड लेआउट से बचा जाना चाहिए। 50/50 विभाजन के लिए केंद्रित दृश्य के साथ समाधान यह सादगी के लिए धन्यवाद एक महान समाधान था। यह समाधान अब बिल्कुल भी सरल नहीं है। मैं इसकी सिफारिश नहीं करूंगा।
— hcpl
3

बस अपने दो टेक्स्ट होस्ट्स और पोर्ट को एक स्वतंत्र लीनियरआउटआउट क्षैतिज में रखें और प्रतिशत बनाने के लिए एंड्रॉइड: लेआउट_वेट का उपयोग करें

— Cyatophilum
स्रोत
1

Https://github.com/mmin18/FlexLayout की जाँच करें, जिसे आप सीधे लेआउट xml में प्रतिशत या जावा अभिव्यक्ति का उपयोग कर सकते हैं।

<EditText
    app:layout_left="0%"
    app:layout_right="60%"
    app:layout_height="wrap_content"/>
<EditText
    app:layout_left="prev.right+10dp"
    app:layout_right="100%"
    app:layout_height="wrap_content"/>
— mmin
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.