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


247

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>


Réponses:


339

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.


81
Pour développer cela, si vous ne voulez pas que la largeur des boutons soit 1/3 de l'écran, enveloppez chaque bouton dans un LinearLayout et définissez layout_width = "0dp" et layout_weight = "1" sur les 3 LinearLayouts. En outre, définissez la gravité sur les LinearLayouts sur "centre" afin que les boutons s'alignent au centre de chaque LinearLayout.
Andrew

c'est le cas pour linearlayout only.can n'importe qui peut donner une idée de l'équispacing dans relativelayout
user1859771

1
Dans mon cas, j'utilise layout_width = "wrap_content" et seulement avec layout_weight = "1" fonctionne bien!
StefanoM5

Ce n'est pas correct car l'OP veut être corrigé avec. Voir la réponse de stoefln.
Mitulát báti

228

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>

15
Il s'agit certainement de la méthode de frais généraux la plus simple et la plus basse qui fonctionne (dans le cas où vous voulez que l'espace entre les vues soit mis à l'échelle, pas les vues elles-mêmes). Je l'utilise verticalement, et j'ai donc juste échangé les valeurs de largeur et de hauteur. Merci.
samis

7
Ceci est une solution élégante. Vous pouvez préférer utiliser le Spacetype d'affichage. Rend les choses un peu plus lisibles.
Ryan R

2
Ryan, oui, c'est si vous utilisez l'API 14+ (comme nous le devrions).
Eduardo Naveda

Honnêtement, je pensais que cela ne fonctionnerait pas avec 4 boutons, mais cela a fonctionné brillamment sans tracas ni mesure d'exécution. Le respect!
Ashraf Alshahawy

C'est mieux que celui qui est accepté comme réponse actuellement.
DroidHeaven

25

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>

c'est bon !! Je n'ai jamais entendu parler de Spacetout à l'heure
Someone Somewhere

21

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>

13

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.


Pour clarifier, cela ne fonctionne pas si vous avez plus de trois boutons.
arlomedia

Exactement. Vous devez utiliser à la place un LinearLayout ou un RadioGroup (le cas échéant).
marsbear

11

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


1
J'ai cru comprendre que l'attribut layout_weight étirerait la taille du bouton pour remplir la disposition. Je veux garder la taille des boutons constante et simplement augmenter le rembourrage entre les boutons.
yamspog

Ah! Je ne connais pas vraiment la meilleure façon de le faire. Peut-être en enfermant chaque bouton dans la mise en page. La 3 disposition avec l'attribut layout_weight et le bouton centré dans la disposition. Mais je ne sais vraiment pas si c'est la meilleure façon de le faire.
fedj

9

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.

Différence entre space_around, space_between et space_evenly


1
merci de m'avoir (nous) rendu compte. Certainement utile. J'ai utilisé "space_around" et les boutons étaient bien centrés lorsque j'en avais 1 ou 3 visibles dans la FlexBox
Someone Somewhere

4

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.



4

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.


4

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:

entrez la description de l'image ici

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:

entrez la description de l'image ici


3

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


2

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,

entrez la description de l'image ici


2

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

2

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"...


Merci un compagnon de tonne! Gain de temps.
Xonshiz

1
Pas de problème camarade.
Gibran Castillo

0
<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.


0
<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" />


0

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.