est-il possible de répartir uniformément les boutons sur toute la largeur d'un linéaire android

J'ai une disposition linéaire (orientée horizontalement) qui contient 3 boutons. Je veux que les 3 boutons aient une largeur fixe et soient répartis uniformément sur toute la largeur de la disposition linéaire.

Je peux gérer cela en définissant la gravité de la disposition linéaire au centre, puis en ajustant le rembourrage des boutons, mais cela fonctionne pour une largeur fixe et ne fonctionnera pas pour changer les appareils ou les orientations.

<LinearLayout android:id="@+id/LinearLayout01" 
android:layout_height="wrap_content" 
android:orientation="horizontal" 
android:layout_width="fill_parent" 
android:gravity="center">

<Button 
android:id="@+id/btnOne"
android:layout_width="wrap_content" 
android:layout_height="wrap_content" 
android:width="120dip"></Button>

<Button 
android:id="@+id/btnTwo"
android:layout_width="wrap_content" 
android:layout_height="wrap_content" 
android:width="120dip"></Button>


<Button 
android:id="@+id/btnThree"
android:layout_width="wrap_content" 
android:layout_height="wrap_content" 
android:width="120dip"></Button>

</LinearLayout>

L' expansion sur la réponse de Fedj , si vous définissez layout_widthà 0dpet définir la layout_weightpour chacun des boutons à 1, la largeur disponible sera partagé à parts égales entre les boutons.

Si vous ne voulez pas que les boutons soient mis à l'échelle, mais ajustez l'espacement entre les boutons (espacement égal entre tous les boutons), vous pouvez utiliser des vues avec weight = "1" qui rempliront l'espace entre les boutons:

    <Space
        android:layout_width="0dp"
        android:layout_height="1dp"
        android:layout_weight="1" >
    </Space>

    <ImageButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:adjustViewBounds="true"
        android:background="@null"
        android:gravity="center_horizontal|center_vertical"
        android:src="@drawable/tars_active" />

    <Space
        android:layout_width="0dp"
        android:layout_height="1dp"
        android:layout_weight="1" >
    </Space>

    <ImageButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:adjustViewBounds="true"
        android:background="@null"
        android:gravity="center_horizontal|center_vertical"
        android:src="@drawable/videos_active" />

    <Space
        android:layout_width="0dp"
        android:layout_height="1dp"
        android:layout_weight="1" >
    </Space>

Vous pouvez l'utiliser avec comme suit.

<LinearLayout
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    android:layout_marginTop="15dp">
    <Space
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"/>
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Save"/>
    <Space
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"/>
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Reset"/>
    <Space
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"/>
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="cancel"/>
    <Space
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"/>
</LinearLayout>

Vous pouvez le faire en donnant à la fois Viewsa layout_widthde 0dpet un layout_weightde 1:

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

    <Button
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"/>

    <TextView
        android:layout_width="0dp"
        android:text="example text"
        android:layout_height="wrap_content"
        android:layout_weight="1"/>

</LinearLayout>

La façon dont android layout_weight fonctionne est la suivante:

• tout d'abord, il regarde la taille qu'une vue prend normalement et réserve cet espace.
• deuxièmement, si la disposition est match_parentalors elle divisera l' espace qui reste dans le rapport du layout_weights. Ainsi, si vous avez donné les vues layout_weight="2"et layout_weight="1", le rapport résultant sera de 2 à 1, c'est-à-dire: la première vue obtiendra 2/3 de l'espace qui reste et l'autre vue 1/3.

C'est pourquoi, si vous donnez layout_widthune taille à 0dpla première étape, cela n'a aucune signification supplémentaire, car aucun espace n'est attribué aux deux vues. Ensuite, seul le deuxième point décide de l'espace que chacun Viewobtient, ce qui donne au Views l'espace que vous avez spécifié en fonction du rapport!

Pour expliquer pourquoi 0dpl'espace se divise également en fournissant un exemple qui montre le contraire: Le code ci-dessous entraînerait quelque chose de différent car a example textmaintenant une largeur qui est plus grande que 0dpparce qu'il a wrap_contentà la place de laisser l'espace libre restant à diviser inférieur à 100% parce que le texte prend de la place. Le résultat sera qu'ils obtiennent 50% de l'espace libre restant mais le texte a déjà pris un peu d'espace donc TextViewil aura bien plus de 50% de l'espace total.

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

    <Button
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"/>

    <TextView
        android:layout_width="wrap_content"
        android:text="example text"
        android:layout_height="wrap_content"
        android:layout_weight="1"/>

</LinearLayout>

Eh bien, si vous avez exactement 3 boutons et s'il est correct (ou même prévu) que les boutons extérieurs soient alignés sur le côté gauche et droit, vous voudrez peut-être essayer un RelativeLayout qui est moins frais généraux (dans de nombreuses situations).

Vous pouvez utiliser layout_alignParentBottompour aligner tous les boutons avec le bas de la mise en page. Utilisez layout_alignParentLeft and Rightpour les boutons extérieurs et layout_centerHorizontalpour le bouton du milieu.

Cela fonctionnera bien sur différentes orientations et tailles d'écran.

Vous devriez jeter un œil à l'attribut android: layout_weight

La solution moderne pour cela est Flexbox .

<com.google.android.flexbox.FlexboxLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:justifyContent="space_around"> <!-- or "space_between", "space_evenly" -->

    <Button 
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content" 
        android:width="120dp" />

    <Button 
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content" 
        android:width="120dp" />

    <Button 
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content" 
        android:width="120dp" />
</com.google.android.flexbox.FlexboxLayout>

Assurez-vous d'importer implementation 'com.google.android:flexbox:2.0.0'

Flexboxest beaucoup plus puissant; c'est un bon complément àConstraintLayout . Ceci est une excellente ressource pour en savoir plus.

Pour espacer uniformément deux boutons dans une disposition linéaire horizontale, j'ai utilisé 3 objets LinearLayout pour agir comme des espaces qui seront automatiquement redimensionnés. J'ai positionné ces objets LinearLayout comme suit:

[] Bouton1 [] Bouton2 []

([] représente un objet LinearLayout utilisé pour l'espacement)

puis je règle chacun des poids de ces objets [] LinearLayout à 1, et j'obtiens des boutons régulièrement espacés.

J'espère que cela t'aides.

j'ai créé un View DistributeLayout personnalisé pour ce faire.

Je vous suggère d'utiliser l'attribut weightSum de LinearLayout.

L'ajout de la balise android:weightSum="3"à la déclaration xml de votre LinearLayout, puis android:layout_weight="1"à vos boutons entraînera une répartition uniforme des 3 boutons.

Ceci peut être réalisé en attribuant weightà chaque bouton ajouté à l'intérieur du conteneur, très important pour définir l'orientation horizontale:

    int buttons = 5;

    RadioGroup rgp = (RadioGroup) findViewById(R.id.radio_group);

    rgp.setOrientation(LinearLayout.HORIZONTAL);

    for (int i = 1; i <= buttons; i++) {
        RadioButton rbn = new RadioButton(this);         
        rbn.setId(1 + 1000);
        rbn.setText("RadioButton" + i);
        //Adding weight
        LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT, 1f);
        rbn.setLayoutParams(params);
        rgp.addView(rbn);
    }

afin que nous puissions obtenir cela dans notre appareil:

même si nous faisons tourner notre appareil, le weightdéfini dans chaque bouton peut répartir uniformément les éléments le long du conteneur:

La meilleure approche consiste à utiliser TableLayout avec android: layout_width = "match_parent" et dans les colonnes, utilisez android: layout_weight = "1" pour toutes les colonnes

Les réponses ci-dessus utilisant layout_did ne fonctionnaient pas pour moi, mais les suivantes ont fonctionné.

<LinearLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    android:layout_weight="0.1"
    android:layout_gravity="center_horizontal"
    >

    <android.support.design.widget.FloatingActionButton
        android:layout_width="50dp"
        android:layout_height="50dp"
        android:layout_gravity="center"
       />

    <android.support.design.widget.FloatingActionButton
        android:layout_width="50dp"
        android:layout_height="50dp"
        android:layout_gravity="center"
        android:layout_marginLeft="40dp"
        android:layout_marginStart="40dp"/>

    <android.support.design.widget.FloatingActionButton
        android:layout_width="50dp"
        android:layout_height="50dp"
        android:layout_gravity="center"
        android:layout_marginLeft="40dp"
        android:layout_marginStart="40dp"
        />

    <android.support.design.widget.FloatingActionButton
        android:layout_width="50dp"
        android:layout_height="50dp"
        android:layout_gravity="center"
        android:layout_marginLeft="40dp"
        android:layout_marginStart="40dp"/>

</LinearLayout>

Voilà à quoi ça ressemble à l'écran,

Avant tout, les réponses sont bonnes, mais dans le cas où vous avez besoin de fonctionnalités visibles et disparues, cette méthode pragmatique fonctionnera bien

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

        <Button
            android:id="@+id/btnOne"
            android:layout_width="120dp"
            android:layout_height="match_parent"></Button>

        <Button
            android:id="@+id/btnTwo"
            android:layout_width="120dp"
            android:layout_height="match_parent"></Button>


        <Button
            android:id="@+id/btnThree"
            android:layout_width="120dp"
            android:layout_height="match_parent"></Button>
    </LinearLayout>



 float width=CommonUtills.getScreenWidth(activity);
            int cardWidth=(int)CommonUtills.convertDpToPixel (((width)/3),activity);

LinearLayout.LayoutParams params =
                new LinearLayout.LayoutParams(width,
                        LinearLayout.LayoutParams.MATCH_PARENT);

btnOne.setLayoutParams(params);
btnTwo.setLayoutParams(params);
btnThree.setLayoutParams(params);

public class CommonUtills {
public static float getScreenWidth(Context context) {
        float width = (float) 360.0;
        DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
        width = displayMetrics.widthPixels / displayMetrics.density;
        return width;
    }
}

Enfants de poids égal

Pour créer une disposition linéaire dans laquelle chaque enfant utilise la même quantité d'espace à l'écran, définissez l'android: layout_height de chaque vue sur "0dp" (pour une disposition verticale) ou l'android: layout_width de chaque vue sur "0dp" ( pour une disposition horizontale). Réglez ensuite l'androïde: layout_weight de chaque vue sur "1".

Pour que cela fonctionne dans le LinearLayoutgroupe de vues, les valeurs d'attribut android:layout_widthet android:layout_heightdoivent être égales à "match_parent"...

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:text="Tom"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:textSize="24sp" 
        android:layout_weight="3"/>

    <TextView
        android:text="Tim"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:textSize="24sp"
        android:layout_weight="3"/>

    <TextView
        android:text="Todd"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:textSize="24sp" 
        android:layout_weight="3"/>

</LinearLayout>

En cercle, Tom, Tim et Todd sont supposés mesurer 3 centimètres. Si vous voulez que ce soit un écran tactile, mettez-le comme Tom et Tim supposés être de 1 centimètre, ce qui signifie qu'ils combinent virtuel mais son plan 2D est en bas. Ceci est affiché à l'écran.

<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="wrap_content"
android:layout_height="wrap_content">

<TextView
    android:text="Tom"
    android:layout_width="wrap_content"
    android:layout_height="200dp"
    android:textSize="24sp" />

<TextView
    android:text="Tim"
    android:layout_width="wrap_content"
    android:layout_height="200dp"
    android:textSize="24sp" />

<TextView
    android:text="Todd"
    android:layout_width="wrap_content"
    android:layout_height="200dp"
    android:textSize="24sp" />

Le moyen le plus simple et le plus rapide (mais pas le meilleur) consiste à ajouter un TextView avec un attribut de texte vide, comme celui-ci

android:text=""

la couleur d'arrière-plan doit être la même au LinearLayout, alors vous pouvez utiliser la propriété padding, comme ceci

android:paddingBottom="250dp"

ou tout ce dont vous avez besoin. Voici un exemple.