vertical - android studio linear layout tutorial




O que o android: layout_weight significa? (9)

Adicionar android:autoSizeTextType="uniform" redimensionará o texto automaticamente

Eu não entendo como usar esse atributo. Alguém pode me dizer mais sobre isso?


Combinando as duas respostas de

Flo & rptwsthi e roetzi,

Lembre-se de alterar seu layout_width=0dp/px , caso contrário, o comportamento layout_weight agirá de forma layout_weight , com o maior número ocupando o menor espaço e o menor número ocupando o maior espaço.

Além disso, algumas combinações de pesos causaram que algum layout não possa ser mostrado (já que ele ocupava o espaço).

Cuidado com isso.


Em poucas palavras, layout_weight especifica quanto do espaço extra no layout será alocado para a View.

O LinearLayout suporta a atribuição de um peso a crianças individuais. Esse atributo atribui um valor de "importância" a uma exibição e permite que ela se expanda para preencher qualquer espaço restante na exibição principal. O peso padrão das exibições é zero.

Cálculo para atribuir qualquer espaço restante entre filho

Em geral, a fórmula é:

espaço atribuído à criança = (peso individual da criança) / (soma do peso de cada criança no Layout Linear)

Exemplo 1

Se houver três caixas de texto e duas delas declararem um peso de 1, enquanto a terceira não tiver peso (0), o espaço restante será atribuído da seguinte maneira:

1ª caixa de texto = 1 / (1 + 1 + 0)

2ª caixa de texto = 1 / (1 + 1 + 0)

3ª caixa de texto = 0 / (1 + 1 + 0)

Exemplo 2

Digamos que temos um rótulo de texto e dois elementos de edição de texto em uma linha horizontal. O rótulo não tem layout_weight especificado, por isso ocupa o espaço mínimo necessário para renderizar. Se o layout_weight de cada um dos dois elementos de edição de texto estiver definido como 1, a largura restante no layout pai será dividida igualmente entre eles (porque afirmamos que eles são igualmente importantes).

Cálculo:

1º rótulo = 0 / (0 + 1 + 1)

2ª caixa de texto = 1 / (0 + 1 + 1)

3ª caixa de texto = 1 / (0 + 1 + 1)

Se, em vez disso, a primeira caixa de texto tiver um layout_weight de 1 e a segunda caixa de texto tiver um layout_weight de 2, um terço do espaço restante será fornecido para o primeiro e dois terços para o segundo (porque o segundo é mais importante).

Cálculo:

1º rótulo = 0 / (0 + 1 + 2)

2ª caixa de texto = 1 / (0 + 1 + 2)

3ª caixa de texto = 2 / (0 + 1 + 2)

Artigo de origem


Pense assim, será mais simples

Se você tem 3 botões e seus pesos são 1,3,1 respectivamente, funcionará como tabela em HTML

Forneça 5 porções para essa linha: 1 parte para o botão 1, 3 partes para o botão 2 e 1 parte para o botão 1

Que diz respeito,


Se houver várias visualizações abrangendo um LinearLayout , o layout_weight dará a cada um deles um tamanho proporcional. Uma vista com um maior valor de layout_weight "pesa" mais, por isso obtém um espaço maior.

Aqui está uma imagem para tornar as coisas mais claras.

Teoria

O termo peso de layout está relacionado ao conceito de média ponderada em matemática. É como em uma aula de faculdade, onde a lição de casa vale 30%, a frequência vale 10%, a metade vale 20% e a final vale 40%. Suas pontuações para essas partes, quando ponderadas juntas, dão a sua nota total.

É o mesmo para o peso do layout. As Views em um LinearLayout horizontal podem ocupar uma certa porcentagem da largura total. (Ou uma porcentagem da altura de um LinearLayout vertical.)

O layout

O LinearLayout que você usa será parecido com isto:

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <!-- list of subviews -->

</LinearLayout>

Note que você deve usar layout_width="match_parent" para o LinearLayout . Se você usar wrap_content , não funcionará. Observe também que layout_weight não funciona para as visualizações em RelativeLayouts (veja here e here respostas de SO que tratam desse problema).

As visualizações

Cada vista em um LinearLayout horizontal é algo como isto:

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

Note que você precisa usar layout_width="0dp" junto com layout_weight="1" . Esquecer isso causa muitos problemas para novos usuários. (Veja este artigo para resultados diferentes que você pode obter, não definindo a largura para 0.) Se suas vistas estão em um LinearLayout vertical, então você usaria layout_height="0dp" , é claro.

No exemplo do Button acima, eu defini o peso para 1, mas você pode usar qualquer número. É apenas o total que importa. Você pode ver nas três linhas de botões na primeira imagem que eu postei, os números são todos diferentes, mas desde que as proporções são as mesmas, as larguras ponderadas não mudam em cada linha. Algumas pessoas gostam de usar números decimais que tenham uma soma de 1, de modo que em um layout complexo fique claro qual é o peso de cada parte.

Uma nota final. Se você tiver muitos layouts aninhados que usam layout_weight , pode ser ruim para o desempenho.

Extra

Aqui está o layout xml da imagem principal:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="android:layout_weight="
        android:textSize="24sp" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="1" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="2"
            android:text="2" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="1" />

    </LinearLayout>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="android:layout_weight="
        android:textSize="24sp" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="10"
            android:text="10" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="20"
            android:text="20" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="10"
            android:text="10" />

    </LinearLayout>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="android:layout_weight="
        android:textSize="24sp" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight=".25"
            android:text=".25" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight=".50"
            android:text=".50" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight=".25"
            android:text=".25" />

    </LinearLayout>

</LinearLayout>

Uma das melhores explicações para mim foi essa (do tutorial do Android, procure a etapa 7) :

layout_weight é usado no LinearLayouts para atribuir "importância" a Visualizações dentro do layout. Todos os modos de exibição têm um layout_weight de zero padrão, o que significa que eles ocupam apenas a quantidade de espaço na tela que precisam ser exibidos. Atribuir um valor maior que zero dividirá o restante do espaço disponível na Visualização pai, de acordo com o valor de layout_weight de cada View e sua proporção com o total de layout_weight especificado no layout atual para este e outros elementos View.

Para dar um exemplo: digamos que temos um rótulo de texto e dois elementos de edição de texto em uma linha horizontal. O rótulo não tem layout_weight especificado, por isso ocupa o espaço mínimo necessário para renderizar. Se o layout_weight de cada um dos dois elementos de edição de texto estiver definido como 1, a largura restante no layout pai será dividida igualmente entre eles (porque afirmamos que eles são igualmente importantes). Se o primeiro tiver layout_weight de 1 e o segundo tiver layout_weight de 2, então um terço do espaço restante será dado ao primeiro e dois terços ao segundo (porque afirmamos que o segundo é mais importante).



layout_weight informa ao Android como distribuir seus View s em um LinearLayout . O Android calcula primeiro a proporção total necessária para todos os View s que têm um peso especificado e coloca cada View acordo com a fração da tela que especificou que precisa. No exemplo a seguir, o Android vê que os TextView s têm um layout_weight de 0 (esse é o padrão) e os EditText s têm um layout_weight de 2 cada, enquanto o Button tem um peso de 1 . Portanto, o Android aloca espaço "suficiente" para exibir tvUsername e tvPassword e, em seguida, divide o restante da largura da tela em 5 partes iguais, duas das quais são alocadas para etUsername , duas para etPassword e a última parte para bLogin :

<LinearLayout android:orientation="horizontal" ...>

    <TextView android:id="@+id/tvUsername" 
    android:text="Username" 
    android:layout_width="wrap_content" ... />

    <EditText android:id="@+id/etUsername"
    android:layout_width="0dp"
    android:layout_weight="2" ... />

    <TextView android:id="@+id/tvPassword"
    android:text="Password"
    android:layout_width="wrap_content" />

    <EditText android:id="@+id/etPassword"
    android:layout_width="0dp"
    android:layout_weight="2" ... />

    <Button android:id="@+id/bLogin"
    android:layout_width="0dp"
    android:layout_weight="1"
    android:text="Login"... />

</LinearLayout>

Parece que:
e


Com layout_weight você pode especificar uma proporção de tamanho entre várias visualizações. Por exemplo, você tem um MapView e uma table que deve mostrar algumas informações adicionais para o mapa. O mapa deve usar 3/4 da tela e a tabela deve usar 1/4 da tela. Em seguida, você definirá o layout_weight do map como 3 e o layout_weight da table como 1.

Para fazê-lo funcionar, você também precisa definir a altura ou a largura (dependendo da orientação) para 0 px.





android-widget