Voglio sapere: cos'è Android: weightSum e layout layout e come funzionano?
Voglio sapere: cos'è Android: weightSum e layout layout e come funzionano?
Risposte:
Per documentazione, android:weightSum
definisce la somma del peso massimo e viene calcolata come la somma layout_weight
di tutti i bambini se non specificata in modo esplicito.
Consideriamo un esempio con a LinearLayout
con orientamento orizzontale e 3 ImageViews
al suo interno. Ora vogliamo che abbiano ImageViews
sempre lo stesso spazio. Per raggiungere questo obiettivo, puoi impostare layout_weight
ciascuno di ImageView
su 1 e il valore 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 visualizzare correttamente il layout per qualsiasi dispositivo, cosa che non accadrà se imposti direttamente larghezza e altezza.
Aggiungendo alla risposta di superM e Jeff,
Se ci sono 2 viste in LinearLayout, la prima con un layout_weight di 1, la seconda con un layout_weight di 2 e nessun peso è specificato, per impostazione predefinita, il peso è calcolato come 3 (somma dei pesi dei bambini) e la prima vista occupa 1/3 dello spazio mentre la seconda occupa 2/3.
Tuttavia, se dovessimo specificare weightSum come 5, il primo richiederebbe 1/5 dello spazio mentre il secondo richiederebbe 2/5. Quindi un totale di 3/5 dello spazio sarebbe occupato dal layout mantenendo il resto vuoto.
La somma dei pesi funziona esattamente come vuoi (come altre risposte, non devi sommare tutti i pesi sul layout principale). Nella vista figlio specificare il peso che si desidera assumere. Non dimenticare di specificare
android:layout_width="0dp"
Di seguito è riportato 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>
Questo sembrerà
La documentazione lo dice meglio e include un esempio (evidenziando il mio).
Android: weightSum
Definisce la somma del peso massimo. Se non specificato, la somma viene calcolata aggiungendo il layout_weight di tutti i figli. Questo può essere usato ad esempio per dare a un singolo figlio il 50% dello spazio disponibile totale assegnandogli un layout_weight di 0,5 e impostando weightSum su 1.0.
Quindi, per correggere l'esempio di superM, supponiamo di avere un LinearLayout
orientamento orizzontale che contiene due ImageViews
e un TextView
con. Definisci TextView
di avere una dimensione fissa e desideri che i due ImageViews
occupino lo spazio rimanente allo stesso modo.
Per fare ciò, dovresti applicare layout_weight
1 a ciascuno ImageView
, nessuno sul TextView
, e un weightSum
di 2.0 sul LinearLayout
.
Dopo alcuni esperimenti, penso che l'algoritmo per LinearLayout sia questo:
Supponiamo che weightSum
sia impostato su un valore. Il caso di assenza verrà discusso più avanti.
Innanzitutto, dividi il weightSum
numero 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 fill_parent
elementi; wrap_content
gli elementi non contribuiscono a n
.
Ad esempio, quando weightSum
è 60 e vi sono 3 fill_parent
elementi, il moltiplicatore di peso è 20. Il moltiplicatore di peso è il valore predefinito, ad esempio layout_width
se l'attributo è assente.
In secondo luogo, viene calcolata la massima espansione possibile di ogni elemento. Innanzitutto, gli wrap_content
elementi vengono calcolati in base al loro contenuto. La loro espansione viene dedotta dall'espansione del contenitore padre. Chiameremo il resto expansion_remainer
. Questo resto è distribuito tra gli fill_parent
elementi in base al loro layout_weight
.
In terzo luogo, l'espansione di ogni fill_parent
elemento viene 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 principale.
weight | expansion
0 | 3/3
10 | 2/3
20 | 1/3
30 | 0/3
40 | 0/3
L'espansione minima è limitata a 0. L'espansione massima è limitata alla dimensione padre, ovvero i pesi sono limitati a 0.
Se un elemento è impostato su wrap_content
, la sua espansione viene calcolata per prima e la restante espansione è soggetta alla distribuzione tra gli fill_parent
elementi. Se weightSum
impostato, questo porta a layout_weight
non avere alcun effetto sugli wrap_content
elementi. Tuttavia, gli wrap_content
elementi 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 sopra).
Se no weightSum
viene specificato, viene calcolato come la somma di tutti i layout_weight
valori, inclusi gli elementi con wrap_content
set! Quindi, avendo layout_weight
impostato su wrap_content
elementi, può influenzare la loro espansione. Ad esempio un peso negativo ridurrà gli altri fill_parent
elementi. Prima che gli fill_parent
elementi siano disposti, la formula sopra sarà applicata agli wrap_content
elementi, con la massima espansione possibile la loro espansione in base al contenuto avvolto. Gli wrap_content
elementi verranno ridotti e successivamente fill_parent
viene calcolata e distribuita la massima espansione possibile per gli elementi rimanenti .
Ciò può portare a risultati non intuitivi.
Se non specificato, la somma viene calcolata aggiungendo il layout_weight di tutti i figli. Questo può essere usato ad esempio per dare a un singolo figlio il 50% dello spazio disponibile totale assegnandogli un layout_weight 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>
Una cosa che sembra che nessun altro abbia menzionato: diciamo che hai una verticale LinearLayout
, quindi affinché i pesi nel layout / elemento / vista al suo interno funzionino correttamente al 100% - tutti devono avere layout_height
proprietà (che deve esistere nel tuo XML file) impostato su 0dp
. Sembra che qualsiasi altro valore rovinerebbe le cose in alcuni casi.
Il peso del layout funziona come un rapporto. Ad esempio, se esiste un layout verticale e ci sono due elementi (come pulsanti o visualizzazioni 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'altra 3 parti su 5. Qui 5 è la somma dei pesi. cioè la somma dei pesi divide l'intero layout in porzioni definite. E il peso del layout definisce la parte occupata dall'elemento specifico rispetto alla somma totale del peso predefinita. Anche la somma dei pesi può essere dichiarata manualmente. Pulsanti, visualizzazioni di testo, edizioni, ecc. Sono tutti organizzati utilizzando pesi e peso del layout quando si utilizzano layout lineari per la progettazione dell'interfaccia utente.
Dalla documentazione per gli sviluppatori
Questo può essere usato ad esempio per dare a un singolo figlio 50%
lo spazio disponibile totale assegnandogli un layout_weight di 0.5
e impostando weightSum su 1.0
.
Aggiunta alla risposta @Shubhayu
il resto 3/5
può essere usato per altri layout secondari che in realtà non richiedono alcuna porzione specifica di layout di contenimento.
questo è un potenziale utilizzo di android:weightSum
proprietà.
weightSum
. Il comportamento nel tuo esempio sarebbe identico aweightSum
omesso, e in effetti weightSum non dovrebbe essere specificato in quello scenario. La documentazione dice:weightSum Defines the maximum weight sum. If unspecified, the sum is computed by adding the layout_weight of all of the children.