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

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.

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.

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

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:

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 à (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.

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 à

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>

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.

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

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.