Qu’est-ce que Android: weightSum dans Android, et comment ça marche?

Je veux savoir: Qu’est-ce que Android: WeightSum et layout poids, et comment fonctionnent-ils?

Par documentation, android:weightSum définit la sum de poids maximale et est calculé comme la sum du layout_weight de tous les enfants s’il n’est pas spécifié explicitement.

Prenons un exemple avec un LinearLayout avec une orientation horizontale et 3 ImageViews intérieur. Maintenant, nous voulons que ces ImageViews prennent toujours la même place. Pour ce faire, vous pouvez définir le layout_weight de chaque ImageView à 1 et le weightSum sera calculé comme étant égal à 3, comme indiqué dans le commentaire.

  android:orientation="horizontal" android:layout_gravity="center">  ..... 

weightSum est utile pour que la présentation soit correctement rendue pour tout périphérique, ce qui ne se produira pas si vous définissez directement la largeur et la hauteur.

Ajouter à la réponse de superM et Jeff,

S’il y a 2 vues dans LinearLayout, la première avec un layout_weight de 1, la seconde avec un layout_weight de 2 et aucune weightSum n’est spécifiée, par défaut, la weightSum est calculée comme étant 3 (sum des poids des enfants) et la première vue prend 1/3 de l’espace tandis que la seconde prend 2/3.

Cependant, si nous spécifions le poids comme 5, le premier prend 1 / 5ème de l’espace tandis que le second prend 2 / 5ème. Ainsi, un total de 3 / 5ème de l’espace serait occupé par la mise en page en maintenant le rest vide.

La documentation le dit mieux et inclut un exemple (en soulignant le mien).

Android: poidsSum

Définit la sum de poids maximale. Si non spécifié, la sum est calculée en ajoutant le layout_weight de tous les enfants. Cela peut être utilisé par exemple pour donner à un seul enfant 50% de l’espace total disponible en lui donnant un poids de mise en page de 0,5 et en définissant le poids à 1,0.

Pour corriger l’exemple de superM, supposons que vous ayez un LinearLayout avec une orientation horizontale qui contient deux ImageViews et un TextView . Vous définissez le TextView pour avoir une taille fixe et vous souhaitez que les deux ImageViews occupent également l’espace restant.

Pour ce faire, vous devez appliquer layout_weight 1 à chaque ImageView , aucun sur TextView et un weightSum de 2,0 sur LinearLayout .

Après quelques expérimentations, je pense que l’algorithme de LinearLayout est le suivant:

Supposons que weightSum est défini sur une valeur. Le cas d’absence est discuté plus tard.

weightSum d’ weightSum le weightSum par le nombre d’éléments avec match_parent ou fill_parent dans la dimension de LinearLayout (par exemple, layout_width pour orientation="horizontal" ). Nous appellerons cette valeur le multiplicateur de poids w_m pour chaque élément. La valeur par défaut de weightSum est 1.0, donc le multiplicateur de pondération par défaut est 1/n , où n est le nombre d’éléments fill_parent ; wrap_content éléments wrap_content ne consortingbuent pas à n .

w_m = weightSum / #fill_parent

Par exemple, lorsque weightSum est weightSum 60 et qu’il existe 3 éléments fill_parent , le multiplicateur de poids est fill_parent 20. Le multiplicateur de poids est la valeur par défaut de par exemple layout_width si l’atsortingbut est absent.

Deuxièmement, l’expansion maximale possible de chaque élément est calculée. Tout d’abord, les éléments wrap_content sont calculés en fonction de leur contenu. Leur expansion est déduite de l’expansion du conteneur parent. Nous appellerons le rest expansion_remainer . Ce rest est dissortingbué entre les éléments fill_parent fonction de leur layout_weight .

Troisièmement, l’expansion de chaque élément fill_parent est calculée comme fill_parent :

w_m - (layout_weight / w_m) * maximum_possible_expansion

Exemple:

Si weightSum est weightSum 60 et qu’il y a 3 éléments fill_parent avec les valeurs 10, 20 et 30, leur expansion à l’écran est 2/3, 1/3 et 0/3 du conteneur parent.

 weight | expansion 0 | 3/3 10 | 2/3 20 | 1/3 30 | 0/3 40 | 0/3 

L’expansion minimale est plafonnée à 0. L’expansion maximale est plafonnée à la taille parente, c’est-à-dire que les pondérations sont plafonnées à 0.

Si un élément est défini sur wrap_content , son expansion est calculée en premier et le rest de l’extension est sujet à dissortingbution parmi les éléments fill_parent . Si weightSum est défini, cela layout_weight que layout_weight n’a aucun effet sur les éléments wrap_content . Cependant, les éléments wrap_content peuvent toujours être expulsés de la zone visible par des éléments dont le poids est inférieur à multiplicateur de poids (par exemple entre 0-1 pour weightSum = 1 ou entre 0-20 pour l’exemple ci-dessus).

Si aucun weightSum n’est spécifié, il est calculé comme la sum de toutes les valeurs du layout_weight , y compris les éléments avec l’ensemble wrap_content ! Donc, avoir layout_weight sur les éléments wrap_content peut influencer leur expansion. Par exemple, un poids négatif réduira les autres éléments fill_parent . Avant que les éléments fill_parent soient disposés, la formule ci-dessus sera-t-elle appliquée aux éléments wrap_content , l’expansion maximale possible étant leur extension en fonction du contenu wrap_content . Les éléments wrap_content seront réduits et, par la suite, l’extension maximale possible des éléments fill_parent restants fill_parent calculée et dissortingbuée.

Cela peut conduire à des résultats peu intuitifs.

La sum de poids fonctionne exactement comme vous le souhaitez (comme pour les autres réponses, vous n’avez pas à additionner tous les poids sur la mise en page parente). Sur la vue enfant, spécifiez le poids que vous souhaitez prendre. N’oubliez pas de préciser

 android:layout_width="0dp" 

Voici un exemple

          

Cela ressemblera à

entrer la description de l'image ici

Si non spécifié, la sum est calculée en ajoutant le layout_weight de tous les enfants. Cela peut être utilisé par exemple pour donner à un seul enfant 50% de l’espace total disponible en lui donnant un poids de mise en page de 0,5 et en définissant le poids à 1,0. Doit être une valeur à virgule flottante, telle que “1.2”

        

Une chose qui ne semble pas avoir été mentionnée par d’autres: disons que vous avez un LinearLayout vertical , donc, pour que les poids dans layout / element / view fonctionnent correctement à 100%, tous doivent avoir la propriété layout_height (qui doit exister dans votre fichier XML) défini sur 0dp . Semble que toute autre valeur serait gâcher dans certains cas.

De la documentation du développeur

Cela peut être utilisé par exemple pour donner à un seul enfant 50% de l’espace total disponible en lui donnant un poids de mise en page de 0.5 et en définissant le poids à 1.0 .

Ajout à la réponse de @Shubhayu

rest 3/5 peut être utilisé pour d’autres mises en page enfant qui ne nécessitent pas de partie spécifique de la disposition contenant.

c’est l’utilisation potentielle de la propriété android:weightSum .

Le poids de mise en page fonctionne comme un ratio. Par exemple, s’il y a une disposition verticale et qu’il y a deux éléments (tels que des boutons ou des vues de texte), l’un a un poids de mise en page 2 et l’autre un poids de mise en page 3 respectivement. Ensuite, le 1er article occupera 2 portions sur 5 de l’écran / mise en page et l’autre 3 sur 5. Ici 5 est la sum de poids. c’est-à-dire que la sum de poids divise la mise en page entière en portions définies. Et Poids de la mise en page définit la quantité de partie occupée par l’élément particulier par rapport à la sum de poids totale prédéfinie. La sum de poids peut également être déclarée manuellement. Les boutons, vues de texte, edittexts, etc. sont tous organisés en utilisant le poids et le poids de la mise en page lors de l’utilisation de dispositions linéaires pour la conception d’interface utilisateur.