Co to jest android: weightSum w Androidzie i jak to działa?

Dodawanie do odpowiedzi Supermana i Jeffa,

Jeśli w LinearLayout są 2 widoki, pierwszy z wagą layout_waga równą 1, drugi z wagą layout_waga równą 2 i nie jest określona waga, domyślnie waga jest obliczana na 3 (suma wag dzieci) i pierwszy widok zajmuje 1/3 przestrzeni, podczas gdy drugi zajmuje 2/3.

Jednakże, gdybyśmy określili wagę jako 5, Pierwsza zajęłaby 1/5 miejsca, podczas gdy druga zajęłaby 2/5. Tak więc w sumie 3/5 miejsca byłoby zajęte przez układ, pozostawiając resztę pustą.

Dokumentacja mówi najlepiej i zawiera przykład (podkreślając mój).

Android: weightSum

Określa maksymalną sumę wagową. Jeśli nie jest określona, suma jest obliczana przez dodanie layout_weight wszystkich dzieci. Można go wykorzystać do instancja dająca pojedynczy potomek 50% całkowitej dostępnej przestrzeni przez nadając mu wartość layout_weight równą 0.5 i ustawiając wartość weightSum na 1.0.

Więc do poprawienia supermocy Załóżmy, że masz {[0] } o orientacji poziomej, która zawiera dwa ImageViews i TextView z. Definiujesz TextView, aby mieć stały rozmiar i chcesz, aby dwa ImageViews zajmowały równo pozostałą przestrzeń.

Po kilku eksperymentach myślę, że algorytm LinearLayout jest następujący:]}

Załóżmy, że {[1] } jest ustawione na wartość. Sprawa nieobecności zostanie omówiona później.

Najpierw podziel weightSum przez liczbę elementów match_parent lub fill_parent w wymiarze liniowym (np. layout_width dla orientation="horizontal"). Wartość tę nazywamy mnożnikiem wagowym dla każdego elementu. Domyślną wartością dla weightSum jest 1.0, więc domyślnym mnożnikiem wagi jest 1/n, gdzie n jest liczbą fill_parent elementy; wrap_content elementy nie przyczyniają się do n.

Np. gdy weightSum jest 60, a są 3 fill_parent elementy, mnożnik wagi wynosi 20. Mnożnik wagi jest wartością domyślną dla np. layout_width, jeśli atrybut jest nieobecny.

Po Drugie, obliczana jest maksymalna możliwa ekspansja każdego elementu. Po pierwsze, wrap_content elementy są obliczane zgodnie z ich zawartością. Ich ekspansja jest odejmowana od ekspansji kontenera macierzystego. Zadzwonimy the remainer expansion_remainer. Ta pozostała część jest rozdzielona pomiędzy fill_parent elementy zgodnie z ich layout_weight.

Po trzecie, rozszerzenie każdego fill_parent elementu jest obliczane jako:

Przykład:

Jeśli weightSum jest 60 i są 3 fill_parent elementy z weigthami 10, 20 i 30, ich rozszerzenie na ekranie wynosi 2/3, 1/3 i 0/3 kontenera nadrzędnego.

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

Minimalna ekspansja jest ograniczona do 0. Maksymalna ekspansja jest ograniczona do rozmiaru nadrzędnego, tj. wagi są ograniczone do 0.

Jeśli element jest ustawiony na wrap_content, jego rozszerzenie jest obliczane jako pierwsze, a pozostałe rozszerzenie podlega rozkładowi między elementami fill_parent. Jeśli weightSum jest ustawione, oznacza to, że layout_weight nie ma wpływu na elementy wrap_content. Jednak elementy wrap_content mogą być nadal wypchnięte z widocznego obszaru przez elementy, których waga jest niższa niż (np. między 0-1 dla weightSum= 1 lub między 0-20 dla powyższego przykładu).

Jeśli nie podano weightSum, to obliczana jako suma wszystkich layout_weight wartości, w tym elementów z wrap_content zestawem! Tak więc mając layout_weight ustawione na wrap_content elementach, może wpływać na ich ekspansję. Np. ujemna waga zmniejszy pozostałe fill_parent elementy. Zanim Elementy fill_parent zostaną ułożone, czy powyższy wzór zostanie zastosowany do elementów wrap_content, przy czym maksymalna możliwa ekspansja będzie ich ekspansją zgodnie z zawartością zawiniętą. wrap_content elementy zostaną zmniejszone, a następnie maksymalne możliwe rozszerzenie dla pozostałych fill_parent elementów jest obliczany i dystrybuowany.

Może to prowadzić do nieintuicyjnych wyników.

Waga sum działa dokładnie tak, jak chcesz (podobnie jak inne odpowiedzi nie musisz sumować wszystkich wag w układzie nadrzędnym). W widoku potomnym określ wagę, jaką ma przyjąć. nie zapomnij podać

android:layout_width="0dp" 

Poniżej znajduje się przykład

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

To będzie wyglądać

Jeśli nie jest określona, suma jest obliczana przez dodanie layout_weight wszystkich potomków. Można tego użyć na przykład, aby dać pojedynczemu dziecku 50% całkowitej dostępnej przestrzeni, nadając mu wartość layout_weight równą 0.5 i ustawiając wartość weightSum na 1.0. Musi być wartością zmiennoprzecinkową, np. "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>

Jedna rzecz, o której nikt nie wspomniał: powiedzmy, że masz pionową LinearLayout, Aby więc wagi w układzie / elemencie / widoku wewnątrz niego działały w 100% poprawnie-wszystkie muszą mieć layout_height właściwość (która musi istnieć w pliku xml) ustawiona na 0dp. Wygląda na to, że każda inna wartość może coś zepsuć w niektórych przypadkach.

From developer documentation

Można tego użyć na przykład, aby dać pojedynczemu potomkowi 50% całkowitą dostępną przestrzeń, nadając mu layout_weight 0.5 i ustawiając weightSum na 1.0.

Dodatek do @Shubhayu odpowiedz

Rest 3/5 może być używany dla innych układów potomnych, które naprawdę nie wymagają żadnej konkretnej części układu zawierającego.

Jest to potencjalne wykorzystanie właściwości android:weightSum.

Waga układu działa jak stosunek. na przykład, jeśli istnieje układ pionowy i istnieją dwa elementy (takie jak przyciski lub widoki tekstu), jeden o wadze układu 2, a drugi o wadze układu 3 odpowiednio. Następnie pierwszy element zajmie 2 z 5 części ekranu / układu,a drugi 3 z 5 części. Tutaj 5 jest sumą wagi. tj. suma wagowa dzieli cały układ na określone części. i waga układu określa, ile porcji konkretna pozycja zajmuje z predefiniowanej całkowitej sumy wagowej. suma wagowa może być również zadeklarowana ręcznie. Przyciski, textviews, EditText itp. wszystkie są zorganizowane za pomocą wagi i wagi układu podczas korzystania z układów liniowych do projektowania interfejsu użytkownika.