Layout do Flet: Row e Column

Python com Flet
Menu Geral

Flet: Row

Row (linha) é um controle que serve de container para outros controles e os exibe horizontalmente. Ele possui propriedades, eventos e métodos relativos ao layout e gerenciamento de rolagem da página (scroll) para evitar overflow (quando o conteúdo ocupa áerea maior que a disponível na página).

Propriedades de Row

Propriedades	Descrição
alignment	alinhamento horizontal dos filhos. A propriedade MainAxisAlignment recebe um ENUM com os valores: START(default) alinha à esquerda da Linha END CENTER SPACE_BETWEEN SPACE_AROUND SPACE_EVENLY
auto_scroll	booleano, auto_scroll=True para mover a posição de scroll para o final quando ocorre atualização dos filhos. Para que o método scroll_to() funcione é necessário ajustar auto_scroll=False.
controls	uma lista de controles a serem exibidos na linha.
run_spacing	espaçamento entre as várias linhas (runs) quando wrap=True. Default: 10. Linhas adicionais aparecem quando os controles não cabem dentro de uma linha única.
scroll	permite rolagem horizontal da linha para evitar overflow. A propriedade pode receber o ENUM ScrollMode com os valores: None (default): não é rolagem e pode haver overflow. AUTO: rolagem habilitada e a barra de rolagem só aparece quando ocorre o scroll. ADAPTIVE: rolagem habilitada e a barra sempre visível quando aplicativo roda na web ou desktop. ALWAYS: rolagem habilitada e a barra sempre visível. HIDDEN: rolagem habilitada e a barra sempre oculta.
spacing	espaçamento entre controles na linha. Default: 10 pixeis. O espaçamento só é aplicado quando alignment é start, end ou center.
on_scroll_interval	limitação para o evento on_scroll em milisegundos. Default: 10.
tight	booleano, espaço a ser ocupado horizontalmente. Default: tight = False, usar todo o espaço os controles.
vertical_alignment	alinhamento vertical. A propriedade pode receber o ENUM CrossAxisAlignment os valores: START (default) CENTER END STRETCH BASELINE
wrap	booleano, se wrap=True os controles filhos serão colocados em linhas adicionais (chamadas runs), caso não caibam em uma única linha.

Métodos de Row

Eventos de Row

Uso das propriedades de row

No código abaixo são criados 30 controles container numerados que são dispostos em uma linha. Dois controle de deslizar (slide) ajustam as propriedades row.width (o número de colunas em cada linha) e row.spacing (o espaçamento entre cada objeto. Quando o número de objetos em uma linha é maior que o espaço permite, novas linhas são inseridas (runs).

import flet as ft # era 52

def main(page: ft.Page):
    def items(count):
        items = []
        for i in range(1, count + 1):
            items.append(ft.Container(ft.Text(value=str(i), color="white", size=20), alignment=ft.alignment.center,
            width=40, height=40, bgcolor="#40A4D2", border_radius=ft.border_radius.all(10)))
        return items

    def muda_largura(e):
        linha.width = float(e.control.value)
        linha.update()

    def muda_separa(e):
        linha.spacing = int(e.control.value)
        linha.update()

    slid_separa = ft.Slider(min=0, max=50, divisions=50, value=0, label="{value}", on_change=muda_separa,)

    slid_largura = ft.Slider(min=0, max=page.window_width, divisions=20, value=page.window_width,
                             label="{value}", on_change=muda_largura,)

    linha = ft.Row(wrap=True, spacing=10, run_spacing=10, controls=items(30), width=page.window_width,)

    txt1 = ft.Text("O primeiro controle seleciona o número de colunas:")
    txt2 = ft.Text("O segundo controle seleciona espaçamento entre colunas:")
    page.add(ft.Column([txt1, slid_largura,]),ft.Column([txt2, slid_separa,]), linha,)

ft.app(target=main)

O código gera, em algum ajuste dos controles de deslizar, a janela abaixo.

Expandindo controles na linha

A expansão de controles na linha e na coluna são análogas. Veja Expandindo controles na linha e na coluna.

Flet: Column

Column é um controle que serve de container para outros controles e os exibe verticalmente. Ele possui propriedades eventos e métodos relativos ao layout e gerenciamento do rolamento da página (scroll) para evitar overflow (quando o conteúdo ocupa áerea maior que a disponível na página.

Propriedades de Column

Propriedades	Descrição
alignment	define como os controles filhos devem ser colocados verticalmente. A propriedade MainAxisAlignment recebe um ENUM com os valores: START(default) alinha à esquerda da Linha END CENTER SPACE_BETWEEN SPACE_AROUND SPACE_EVENLY
auto_scroll	auto_scroll=True para mover a posição de scroll o final quando ocorre atualização dos filhos. Para que o método scroll_to() funcione devemos fazer auto_scroll=False.
controls	lista de controles a serem exibidos na coluna.
horizontal_alignment	posicionamento horizontal dos controles filhos. A propriedade recebe o ENUM CrossAxisAlignment com os valores: START(default) alinha à esquerda da Linha END CENTER STRETCH BASELINE
on_scroll_interval	limita o evento on_scroll (em milisegundos). Default: 10.
scroll	habilita a rolagem vertical na coluna para evitar overflow de conteúdo. A propriedade recebe um ENUM opcional ScrollMode com valores: None (default): coluna não é rolável e pode haver overflow. AUTO: rolagem habilitada e a barra de rolagem só aparece quando a rolagem é necessária. ADAPTIVE: rolagem habilitada e a barra sempre visível em aplicativos na web ou desktop. ALWAYS: rolagem habilitada e a barra sempre vivível. HIDDEN: rolagem habilitada, a barra de rolagem está sempre oculta.
spacing	espaçamento entre os controles da coluna. Default: 10 pixeis. O espaçamento só é aplicado quando alignment = start, end, center.
run_spacing	espaçamento entre “runs” quando wrap=True. Default: 10.
tight	espaçamento vertical. Default: False (alocar todo o espaço para filhos).
wrap	se wrap=True a coluna distribuirá os controles filho em colunas adicionais (runs) se não couberem em uma coluna.

Métodos de Column

(1) products.scroll_to(offset=100, duration=1000)
(2) products.scroll_to(offset=-1, duration=1000)
(3) products.scroll_to(delta=50)
(4) products.scroll_to(key="20", duration=1000)

Eventos de Column

Expandindo controles na linha e na coluna

Todos os controles possuem a propriedade expand que serve para expandi-lo para preencher os espaços disponíveis dentro de uma linha. Ela pode receber um booleano ou um inteiro. expand=True significa expandir o controle para preencher todo o espaço. expand=int introduz um “fator de expansão” especificando como dividir um espaço com outros controles expandidos na mesma linha, ou coluna. O código:

ft.Row([
    ft.TextField(hint_text="Esse será expandido", expand=True),
    ft.ElevatedButton(text="Esse não...")
])

cria uma linha contendo um TextField que ocupa o espaço disponível, e um ElevatedButton, sem expansão. A expansão é calculada em termos do tamanho de todos os controle na linha. É possível fornecer fatores que definem a proporção de expansão de cada controle. Por exemplo:

linha = ft.Row([
        ft.Container(expand=1, content=ft.Text("A")),
        ft.Container(expand=3, content=ft.Text("B")),
        ft.Container(expand=1, content=ft.Text("C"))
])

cria uma linha com 3 controles ocupando 1, 3, 1 partes em 5, como exibido na figura,

Percentualmente a largura resultante de um filho é calculada como largura = expand / soma( todas as expands) * 100%.

Da mesma forma um controle filho em uma coluna pode ser expandido para preencher o espaço vertical disponível. Por exemplo, o código abaixo cria uma coluna com um Container que ocupando todo o espaço disponível e um controle Text na parte inferior servindo como uma barra de status:

coluna = ft.Column([
         ft.Container(expand=True, content=ft.Text("Esse será expandido")),
         ft.Text("Um texto usado como label")
])

Assim como no controle das linhas, podemos usar fatores numéricos em expand=n.

col = ft.Column([
      ft.Container(expand=1, content=ft.Text("Acima")),
      ft.Container(expand=3, content=ft.Text("No centro")),
      ft.Container(expand=1, content=ft.Text("Abaixo"))
])

Isso cria uma coluna com 3 containeres com alturas de 20% (1/5), 60% (3/5)e 20% (1/5) respectivamente.

Percentualmente a altura resultante de um filho é calculada como altura = expand / soma( todas as expands) * 100%.

Bibiografia

• Python com Flet: Bibiografia Geral
• Flet Controls Galery: Galeria de Controles: Buttons
• Flet Controls: Row
• Flet Controls: Column