Qu'est-ce que android: weightSum dans android, et comment ça marche?

Je veux savoir: qu'est-ce que android: weightSum et layout weight, et comment fonctionnent-ils?

137
demandé sur Jai Aggarwal 2011-09-17 09:48:21

9 réponses

Par documentation, android:weightSum définit la somme de poids maximale, et est calculée comme la somme des layout_weight de tous les enfants s'ils ne sont pas spécifiés explicitement.

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

<LinearLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    <!-- android:weightSum="3" -->
    android:orientation="horizontal"
    android:layout_gravity="center">

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

weightSum est utile pour avoir le mise en page rendue correctement pour tout périphérique, ce qui ne se produira pas si vous définissez la largeur et la hauteur directement.

109
répondu superM 2017-03-16 12:39:20

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 aucun weightSum n'est spécifié, par défaut, le weightSum est calculé à 3 (somme 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 devions spécifier le weightSum comme 5, le premier prendrait 1 / 5ème de l'espace tandis que le second prendrait 2/5ème. Ainsi, un total de 3/5 de l'espace serait occupé par la mise en page en gardant le reste vide.

157
répondu Shubhayu 2012-10-08 06:59:12

La documentation le dit le mieux et inclut un exemple, (mettant en évidence le mien).

Android: weightSum

Définit la somme de poids maximale. Si non spécifié, la somme est calculée par ajout du layout_weight de tous les enfants. Ceci peut être utilisé pour exemple pour donner un célibataire enfant 50% de l'espace total disponible par en lui donnant un layout_weight de 0.5 et en définissant le weightSum à 1.0.

Donc pour corriger les superM exemple, supposons que vous ayez un LinearLayout avec une orientation horizontale qui contient deux ImageViews et un TextView avec. 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 appliquez layout_weight 1 pour chaque ImageView, aucune sur la TextView, et weightSum de 2.0 sur la LinearLayout.

23
répondu Jeff Axelrod 2012-10-04 03:35:21

Après quelques expériences, je pense que L'algorithme de LinearLayout est le suivant:

Supposons que weightSum est défini sur une valeur. Le cas de l'absence est discuté plus loin.

Tout d'abord, divisez le weightSum par le nombre d'éléments avec match_parent ou fill_parent dans la dimension du 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 pour weightSum est 1.0, donc le multiplicateur de poids par défaut est 1/n, où n est le nombre de fill_parent éléments; wrap_content éléments ne contribuent pas à n.

w_m = weightSum / # fill_parent

Par exemple, lorsque weightSum est 60, et qu'il y a 3 fill_parent éléments, le multiplicateur de poids est 20. Le multiplicateur de poids est la valeur par défaut pour par exemple layout_width si l'attribut 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 reste expansion_remainer. Ce reste est réparti entre fill_parent éléments en fonction de leur layout_weight.

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

w_m - (layout_weight / w_m) * maximum_possible_expansion

Exemple:

Si weightSum est 60, et qu'il y a 3 fill_parent éléments avec les poids 10, 20 et 30, leur expansion sur 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'extension maximale est limitée à la taille du parent, c'est à dire les poids sont plafonnés à 0.

Si un élément est défini sur wrap_content, son expansion est calculée en premier, et l'expansion restante est sujette à la distribution parmi les éléments fill_parent. Si weightSum est défini, cela conduit à layout_weight n'ayant aucun effet sur les éléments wrap_content. Cependant, les éléments wrap_content peuvent encore être poussés hors de la zone visible par des éléments dont le poids est inférieur à poids multiplicateur (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 somme de toutes les valeurs layout_weight, y compris les éléments avec wrap_content set! Afin d'avoir layout_weight définie sur wrap_content éléments, 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 ne soient disposés, la formule ci-dessus sera-t-elle appliquée aux éléments wrap_content, l'expansion maximale possible étant leur expansion en fonction du contenu enveloppé. Les éléments wrap_content seront rétrécis, et ensuite l'expansion maximale possible pour les éléments fill_parent restants est calculé et distribué.

Cela peut conduire à des résultats non intuitifs.

19
répondu Jens Jensen 2014-04-08 16:16:20

La somme de poids fonctionne exactement comme vous le souhaitez (comme les autres réponses, vous n'avez pas à additionner tous les poids sur la mise en page parente). Sur la vue enfant spécifier le poids que vous voulez prendre. N'oubliez pas de spécifier

android:layout_width="0dp" 

Voici un exemple

    <LinearLayout
                android:layout_width="500dp"
                android:layout_height="20dp" >

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="match_parent"
                    android:layout_weight="3"
                    android:background="@android:color/holo_green_light"
                    android:gravity="center"
                    android:text="30%"
                    android:textColor="@android:color/white" >
                </TextView>

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="match_parent"
                    android:layout_weight="2"
                    android:background="@android:color/holo_blue_bright"
                    android:gravity="center"
                    android:text="20%"
                    android:textColor="@android:color/white" >
                </TextView>

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="match_parent"
                    android:layout_weight="5"
                    android:background="@android:color/holo_orange_dark"
                    android:gravity="center"
                    android:text="50%"
                    android:textColor="@android:color/white" >
                </TextView>
 </LinearLayout>

Cela ressemblera à

entrez la description de l'image ici

19
répondu asok Buzz 2017-01-17 12:26:52

Si non spécifié, la somme 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 layout_weight de 0.5 et en définissant le weightSum à 1.0. Doit être une valeur à virgule flottante, telle que " 1.2 "

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/main_rel"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal"
        android:weightSum="2.0" >

        <RelativeLayout
            android:id="@+id/child_one"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1.0"
            android:background="#0000FF" >
        </RelativeLayout>

        <RelativeLayout
            android:id="@+id/child_two"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1.0"
            android:background="#00FF00" >
        </RelativeLayout>

    </LinearLayout>
9
répondu Faakhir 2013-04-16 11:49:24

Une chose qui semble comme personne d'autre mentionné: disons que vous avez un vertical LinearLayout, donc, pour que les poids dans layout/element/view à l'intérieur fonctionnent correctement à 100% - tous doivent avoir layout_height propriété (qui doit exister dans votre fichier xml) définie sur 0dp. On dirait que toute autre valeur gâcherait les choses dans certains cas.

6
répondu Yoav Feuerstein 2014-08-06 16:03:07

À partir du développeur documentation

Cela peut être utilisé par exemple pour donner à un seul enfant 50% de l'espace total disponible en lui donnant un layout_weight de 0.5 et en définissant le weightSum sur 1.0.

Ajout à la réponse @Shubhayu

Rest 3/5 peut être utilisé pour d'autres mises en page enfants qui n'ont vraiment pas besoin d'une partie spécifique de la mise en page contenant.

Il s'agit d'une utilisation potentielle de la propriété android:weightSum.

1
répondu Dhananjay 2016-03-29 06:35:37

Le poids de mise en page fonctionne comme un ratio. par exemple, s'il y a une mise en page verticale et qu'il y a deux éléments(tels que des boutons ou des vues de texte), l'un ayant un poids de mise en page 2 et l'autre ayant un poids de mise en page 3 respectivement. Puis le 1er élément occupera 2 de 5 la partie de l'écran/mise en page et l'autre 3 / 5 partie. Ici 5 est la somme de poids. c'est-à-dire Weight sum divise la mise en page entière en portions définies. et le poids de la mise en page définit la quantité de l'article particulier occupe hors de la somme totale de poids prédéfinie. la somme de poids peut également être déclarée manuellement. Boutons, textviews, edittexts etc Tous sont organisés en utilisant weightsum et layout weight lors de l'utilisation des mises en page linéaires pour la conception de L'interface utilisateur.

1
répondu Sami Al-Jabar 2016-05-11 15:52:08