Que signifie Android: layout_weight?
Je ne comprends pas comment utiliser cet attribut. Quelqu'un peut-il m'en dire plus?
Avec layout_weight, vous pouvez spécifier un rapport de taille entre plusieurs vues. Par exemple. vous avez une MapView et une table qui devraient afficher des informations supplémentaires sur la carte. La carte doit utiliser 3/4 de l’écran et le tableau, 1/4 de celui-ci. Ensuite, vous définissez le layout_weight du map sur 3 et le layout_weight du table sur 1.
Pour que cela fonctionne, vous devez également définir la hauteur ou la largeur (selon votre orientation) sur 0px.
En un mot, layout_weight spécifie la quantité d'espace supplémentaire de la présentation à allouer à la vue.
LinearLayout permet d'attribuer un poids à des enfants individuels. Cet attribut attribue une valeur "d'importance" à une vue et lui permet de se développer pour occuper tout l'espace restant dans la vue parent. Le poids par défaut des vues est zéro.
Calcul pour attribuer tout espace restant entre les enfants
En général, la formule est la suivante:
espace attribué à l'enfant = (poids individuel de l'enfant)/(somme du poids de chaque enfant dans la disposition linéaire)
Exemple 1
S'il y a trois zones de texte et que deux d'entre elles déclarent un poids de 1, alors que le troisième n'a aucun poids (0), l'espace restant est attribué comme suit:
1ère zone de texte = 1/(1 + 1 + 0)
2ème zone de texte = 1/(1 + 1 + 0)
3ème zone de texte = 0/(1 + 1 + 0)
Exemple 2
Disons que nous avons une étiquette de texte et deux éléments d'édition de texte dans une ligne horizontale. Le libellé n'a pas de layout_weight spécifié, il occupe donc l'espace minimum requis pour le rendu. Si le layout_weight de chacun des deux éléments d'édition de texte est défini sur 1, la largeur restante de la disposition parente sera divisée de manière égale entre eux (car nous affirmons qu'ils sont d'égale importance).
Calcul:
1ère étiquette = 0/(0 + 1 + 1)
2ème zone de texte = 1/(0 + 1 + 1)
3ème zone de texte = 1/(0 + 1 + 1)
Si, au lieu de cela, la première zone de texte a un layout_weight de 1 et que la deuxième zone de texte a un layout_weight de 2, un tiers de l'espace restant sera alors attribué à la première et deux des tiers à la seconde (car nous affirmons que la seconde est plus importante).
Calcul:
1ère étiquette = 0/(0 + 1 + 2)
2ème zone de texte = 1/(0 + 1 + 2)
3ème zone de texte = 2/(0 + 1 + 2)
en ajoutant aux autres réponses, la chose la plus importante à faire pour que cela fonctionne est de régler la largeur de la mise en page (ou la hauteur) sur 0px
Android:layout_width="0px"
sinon vous verrez des ordures
S'il existe plusieurs vues couvrant un LinearLayout, alors layout_weight leur donne chacune une taille proportionnelle. Une vue avec une plus grande valeur layout_weight _ "pèse" plus, ce qui lui donne un espace plus grand.
Voici une image pour rendre les choses plus claires.
Théorie
Le terme poids de la mise en page est lié au concept de moyenne pondérée en mathématiques. C'est comme dans une classe d'université où les devoirs valent 30%, l'assiduité 10%, le cours intermédiaire 20% et la finale 40%. Vos scores pour ces parties, quand pondérés ensemble, vous donnent votre note totale.
Il en va de même pour le poids de la mise en page. Le Views dans un horizontal LinearLayout peut prendre chacun un certain pourcentage de la largeur totale. (Ou un pourcentage de la hauteur pour une verticale LinearLayout.)
La disposition
La LinearLayout que vous utilisez ressemble à ceci:
<LinearLayout
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:orientation="horizontal">
<!-- list of subviews -->
</LinearLayout>
Notez que vous devez utiliser layout_width="match_parent" pour le LinearLayout. Si vous utilisez wrap_content, cela ne fonctionnera pas. Notez également que layout_weight ne fonctionne pas pour les vues dans RelativeLayouts (voir ici et ici pour les réponses SO traitant de ce problème).
Les vues
Chaque vue horizontale LinearLayout ressemble à ceci:
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight="1" />
Notez que vous devez utiliser layout_width="0dp" avec layout_weight="1". Oublier cela cause de nombreux problèmes aux nouveaux utilisateurs. (Voir cet article pour obtenir des résultats différents, vous pouvez obtenir en ne définissant pas la largeur à 0.) Si vos vues sont en position verticale LinearLayout alors vous utiliseriez layout_height="0dp", bien sûr.
Dans l'exemple Button ci-dessus, je règle le poids sur 1, mais vous pouvez utiliser n'importe quel nombre. C'est seulement le total qui compte. Vous pouvez voir dans les trois rangées de boutons de la première image que j'ai publiée, les chiffres sont tous différents, mais comme les proportions sont les mêmes, les largeurs pondérées ne changent pas dans chaque rangée. Certaines personnes préfèrent utiliser des nombres décimaux dont la somme est 1, de sorte que, dans une présentation complexe, le poids de chaque partie soit clairement défini.
Une dernière note. Si vous avez beaucoup de mises en page imbriquées qui utilisent layout_weight, cela peut nuire aux performances.
Supplémentaire
Voici la mise en page XML pour la première image:
<?xml version="1.0" encoding="utf-8"?>
<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:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text="Android:layout_weight="
Android:textSize="24sp" />
<LinearLayout
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:orientation="horizontal">
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight="1"
Android:text="1" />
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight="2"
Android:text="2" />
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight="1"
Android:text="1" />
</LinearLayout>
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text="Android:layout_weight="
Android:textSize="24sp" />
<LinearLayout
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:orientation="horizontal">
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight="10"
Android:text="10" />
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight="20"
Android:text="20" />
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight="10"
Android:text="10" />
</LinearLayout>
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text="Android:layout_weight="
Android:textSize="24sp" />
<LinearLayout
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:orientation="horizontal">
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight=".25"
Android:text=".25" />
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight=".50"
Android:text=".50" />
<Button
Android:layout_width="0dp"
Android:layout_height="wrap_content"
Android:layout_weight=".25"
Android:text=".25" />
</LinearLayout>
</LinearLayout>
layout_weight indique à Android comment distribuer votre Views dans un LinearLayout. Android calcule ensuite d'abord la proportion totale requise pour tous les Views pour lesquels un poids est spécifié et place chaque View en fonction de la fraction d'écran qu'il a spécifiée. Dans l'exemple suivant, Android voit que les TextViews ont un _layout_weight_ de _0_ (il s'agit de la valeur par défaut) et les EditTexts ont un _layout_weight_ de _2_ chacun, alors que Button a un poids de _1_. Ainsi, Android alloue un espace "juste suffisant" pour afficher tvUsername et tvPassword, puis divise le reste de la largeur de l'écran en 5 parties égales, dont deux sont attribuées à etUsername, deux à etPassword et la dernière partie à bLogin. :
_<LinearLayout Android:orientation="horizontal" ...>
<TextView Android:id="@+id/tvUsername"
Android:text="Username"
Android:layout_width="wrap_content" ... />
<EditText Android:id="@+id/etUsername"
Android:layout_width="0dp"
Android:layout_weight="2" ... />
<TextView Android:id="@+id/tvPassword"
Android:text="Password"
Android:layout_width="wrap_content" />
<EditText Android:id="@+id/etPassword"
Android:layout_width="0dp"
Android:layout_weight="2" ... />
<Button Android:id="@+id/bLogin"
Android:layout_width="0dp"
Android:layout_weight="1"
Android:text="Login"... />
</LinearLayout>
_On dirait:
et
Pensez-y de cette façon, ce sera plus simple
Si vous avez 3 boutons et que leur poids est 1,3,1 en conséquence, cela fonctionnera comme dans HTML
Fournissez 5 portions pour cette ligne: 1 portion pour le bouton 1, 3 portions pour le bouton 2 et 1 portion pour le bouton 1
Concerne,
une des meilleures explications pour moi était celle-ci (dans le tutoriel Android, recherchez l'étape 7) :
layout_weight est utilisé dans LinearLayouts pour attribuer une "importance" aux vues de la présentation. Le poids par défaut de layout_weight est égal à zéro dans toutes les vues, ce qui signifie qu'elles occupent uniquement l'espace nécessaire à l'écran. L'attribution d'une valeur supérieure à zéro divise le reste de l'espace disponible dans la vue parente, en fonction de la valeur de layout_weight de chaque vue et de son rapport à la mise en page globale spécifiée dans la présentation actuelle pour cet élément et les autres.
Pour donner un exemple: supposons que nous ayons une étiquette de texte et deux éléments d'édition de texte sur une ligne horizontale. Le libellé ne spécifiant pas layout_weight, il occupe donc l'espace minimum requis pour le rendu. Si la valeur pondérale de chacun des deux éléments d'édition de texte est définie sur 1, la largeur restante de la présentation parent sera divisée en parts égales entre eux (car nous affirmons qu'ils sont tout aussi importants). Si le premier a un layout_weight de 1 et que le second a un layout_weight de 2, un tiers de l'espace restant sera attribué au premier et deux tiers au second (car nous affirmons que le second est plus important).
http://developer.Android.com/guide/topics/ui/layout-objects.html#linearlayout
layout_weight définit combien d'espace le contrôle doit obtenir respectivement par rapport aux autres contrôles.
Veuillez regarder le weightSum de LinearLayout et le layout_weight de chaque vue. Android: weightSum = "4" Android: layout_weight = "2" Android: layout_weight = "2" Leur layout_height est à la fois 0px, mais je ne suis pas sûr qu'il soit pertinent
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
xmlns:tools="http://schemas.Android.com/tools"
Android:orientation="vertical"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:weightSum="4">
<fragment Android:name="com.example.SettingFragment"
Android:id="@+id/settingFragment"
Android:layout_width="match_parent"
Android:layout_height="0px"
Android:layout_weight="2"
/>
<Button
Android:id="@+id/dummy_button"
Android:layout_width="match_parent"
Android:layout_height="0px"
Android:layout_weight="2"
Android:text="DUMMY"
/>
</LinearLayout>
Pour additionnel ：
Pour l'orientation vertical, n'oubliez pas de définir height sur 0dp
Android:layout_height="0dp"
Pour l'orientation horizontal, n'oubliez pas de définir width sur 0dp
Android:layout_width="0dp"
Combinant les deux réponses de
Flo & rptwsthi et roetzi,
N'oubliez pas de changer votre layout_width=0dp/px, sinon le comportement de layout_weight agira de manière inverse avec le plus grand nombre occupé le plus petit espace et le plus petit nombre occupé le plus grand.
En outre, certaines combinaisons de pondérations ont pour conséquence que certaines dispositions ne peuvent pas être affichées (car elles occupent l’espace).
Attention à cela.
Ajouter Android:autoSizeTextType="uniform" redimensionnera automatiquement le texte