Che cos'è Android: weightSum in Android e come funziona?

Question

Voglio sapere: cos'è Android: peso, peso del layout e come funzionano?

Answer 1

Per documentazione, android:weightSum definisce la somma di peso massima ed è calcolata come la somma dello layout_weight di tutti i bambini se non specificato esplicitamente.

Consideriamo un esempio con un LinearLayout con orientamento orizzontale e 3 ImageViews al suo interno. Ora vogliamo che questi ImageViews occupino sempre lo stesso spazio. Per ottenere ciò, è possibile impostare layout_weight su ogni ImageView su 1 e lo weightSum sarà calcolato per essere uguale a 3 come mostrato nel commento.

<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 è utile per avere il layout rendering correttamente per qualsiasi dispositivo, che non accadrà se si imposta la larghezza e l'altezza direttamente.

Answer 2

Il documentation dice che è meglio e include un esempio, (evidenziando il mio).

Android: weightSum

Definisce la somma di peso massimo. Se non specificato, la somma viene calcolata da aggiungendo il peso di layout di tutti i bambini. Questo può essere usato per l'istanza per dare un singolo bambino al 50% dello spazio totale disponibile per assegnando un peso di layout di 0,5 e impostando weightSum su 1.0.

Quindi, per correggere l'esempio di SuperM, supponiamo di avere un LinearLayout con orientamento orizzontale che contiene due ImageViews e un TextView con. Si definisce il TextView per avere una dimensione fissa e si desidera che i due ImageViews occupino lo spazio rimanente in modo uguale.

per raggiungere questo obiettivo, si dovrebbe applicare layout_weight 1 a ciascuna ImageView, nessuno sul TextView, e un weightSum di 2,0 sul LinearLayout.

Answer 3

Aggiungendo alla risposta di SuperM e Jeff,

Se ci sono 2 visite nel LinearLayout, il primo con un layout_weight di 1, la seconda con un layout_weight di 2 e non weightSum è specificato, per impostazione predefinita, la weightSum è calcolato come 3 (somma dei pesi dei bambini) e la prima vista occupa 1/3 dello spazio mentre la seconda prende 2/3.

Tuttavia, se dovessimo specificare il peso come 5, il primo impiegherebbe 1/5 dello spazio mentre il secondo impiegherebbe 2/5. Quindi un totale di 3/5 dello spazio sarebbe occupato dal layout mantenendo il resto vuoto.

Answer 4

Se non specificato, la somma viene calcolata aggiungendo il peso di layout di tutti i bambini. Questo può essere usato ad esempio per dare a un singolo figlio il 50% dello spazio totale disponibile dandogli un peso di layout di 0,5 e impostando weightSum su 1.0. Deve essere un valore in virgola mobile, ad esempio "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> 

Answer 5

Dopo alcuni esperimenti, ritengo l'algoritmo per LinearLayout è questo:

supponga che weightSum è impostata su un valore Il caso di assenza è discusso più avanti

Primo, dividere.. weightSum per il numero di elementi con match_parent o fill_parent nella dimensione del LinearLayout (ad esempio layout_width per orientation="horizontal"). Chiameremo questo valore il moltiplicatore di peso per ciascun elemento. Il valore predefinito per weightSum è 1.0, quindi il moltiplicatore di peso predefinito è 1/n, dove n è il numero di elementi fill_parent; Gli elementi wrap_content non contribuiscono a n.

Ad es quando weightSum è 60 e ci sono 3 elementi fill_parent, il moltiplicatore di peso è 20. Il moltiplicatore di peso è il valore predefinito per es. layout_width se l'attributo è assente.

In secondo luogo, viene calcolata la massima espansione possibile di ogni elemento. Innanzitutto, gli elementi wrap_content vengono calcolati in base al loro contenuto. La loro espansione viene dedotta dall'espansione del contenitore principale. Chiameremo il remainer expansion_remainer. Questo resto è distribuito tra gli elementi fill_parent in base al loro layout_weight.

terzo luogo, l'espansione di ogni elemento fill_parent è calcolata come:

Esempio:

Se weightSum è 60, e ci sono 3 fill_parent elementi con i PESI 10, 20 e 30 , la loro espansione sullo schermo è 2/3, 1/3 e 0/3 del contenitore genitore.

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

L'espansione minimo è limitato a 0. L'espansione massima è limitato a dimensioni genitore, ossia, i pesi sono tagliate in 0.

Se un elemento è impostato wrap_content, la sua espansione viene calcolato prima, e l'espansione rimanente è soggetta a distribuzione tra gli elementi fill_parent. Se è impostato weightSum, questo porta a layout_weight senza alcun effetto sugli elementi wrap_content. Tuttavia, gli elementi wrap_content possono ancora essere spinti fuori dall'area visibile da elementi il ​​cui peso è inferiore a (ad esempio tra 0-1 per weightSum = 1 o tra 0-20 per l'esempio precedente).

Se non viene specificato weightSum, viene calcolato come la somma di tutti i valori layout_weight, compreso elementi con wrap_content set! Quindi avere layout_weight impostato su wrap_content elementi, può influenzare la loro espansione. Per esempio. un peso negativo si riduce gli altri elementi fill_parent. Prima che gli elementi fill_parent siano disposti, la formula sopra riportata sarà applicata agli elementi wrap_content, con la massima espansione possibile essendo la loro espansione in base al contenuto avvolto. Gli elementi wrap_content verranno ridotti e in seguito verrà calcolata e distribuita la massima espansione possibile per gli elementi rimanenti fill_parent.

Ciò può portare a risultati non intuitivi.

Answer 6

Una cosa che sembra come nessun altro ha menzionato: Diciamo che avere un verticaleLinearLayout, quindi in modo che i pesi nel layout/elemento/vista al suo interno per funzionare al 100% correttamente - tutti devono avere layout_height proprietà (che deve esistere nel file xml) impostata su 0dp. Sembra che qualsiasi altro valore potrebbe rovinare le cose in alcuni casi.

Answer 7

Da sviluppatore documentation

questo può essere usato ad esempio per dare un solo bambino 50% dello spazio totale disponibile dandogli una layout_weight di 0.5 e impostando la weightSum a 1.0.

aggiunta alla @Shubhayu rispondere

resto 3/5 può essere utilizzato per altri layout bambini che in realtà non hanno bisogno di alcuna specifica porzione di contenere il layout.

questo è un potenziale utilizzo della proprietà android:weightSum.

Answer 8

Il peso del layout funziona come un rapporto. Ad esempio, se è presente un layout verticale e vi sono due elementi (come pulsanti o visioni di testo), uno con peso di layout 2 e l'altro con peso di layout 3 rispettivamente. Quindi il primo elemento occuperà 2 parti su 5 dello schermo/layout e l'altro 3 parti su 5. Qui 5 è la somma del peso. Ad esempio, La somma di peso divide l'intero layout in parti definite. E Peso del layout definisce la parte che occupa l'elemento particolare rispetto alla Somma del peso predefinita. La somma di peso può essere dichiarata manualmente. Pulsanti, visualizzazioni testuali, edittexts ecc. Sono tutti organizzati usando pesi e peso del layout quando si utilizzano layout lineari per la progettazione dell'interfaccia utente.

Answer 9

La somma di peso funziona esattamente come si desidera (come altre risposte non è necessario sommare tutti i pesi sul layout principale). Nella vista secondaria specificare il peso che si desidera che prenda. Non dimenticate di specificare

android:layout_width="0dp" 

seguente è un esempio

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

Questa sarà simile