Controle NavigationDrawer

O controle NavigationDrawer é um componente no estilo Material Design que desenha um painel similar ao NavigationBar mas que desliza horizontalmente da borda, da esquerda para a direita ou o inverso. Ela serve para apresentar destinos primários em um aplicativo. Uma NavigationDrawer é adicionada e removida da página com as propriedades page.drawer e page.end_drawer. Um controle NavigationDrawer pode ser adicionado a uma View, usando as propriedades View.drawer ou View.end_drawer.

Nesse texto chamaremos a drawer (literalmente, gaveta) de aba. Portanto o controle de navegação contem diversos controles de destinos que são abas.

Propriedades do NavigationDrawer

Eventos do NavigationDrawer

Uma NavigationDrawer recebe outros controles em sua propriedade NavigationDrawer.controls, que é um array. Em particular vários controles NavigationDrawerDestination podem ser inseridos, contendo ícones e labels. A seleção dos destinos é realizada no evento NavigationDrawer.on_change e a captura do índice do controlel clicado. Um evento também é disparado no fechamento da aba, com NavigationDrawer.on_change.

Propriedades de NavigationDrawerDestination

† Nota: O manual do Flet sugere a escolha de um ícone com uma versão com traço e preenchida, como icons.CLOUD e icons.CLOUD_QUEUE, para tornar o NavigationDrawer mais acessível. O ícone deve ser definido para a versão com traço e selected_icon para a versão preenchida.

Exemplo de Uso do NavigationDrawer

import flet as ft

def main(page: ft.Page):
    page.bgcolor=ft.colors.BLUE_500

    def fechar_painel(e):
        mensagem.value+="\nAba dispensada"
        page.update()

    def clicar_destino(e):
        mensagem.value+=f"\nFoi selecionado o índice: {e.control.selected_index}"
        if e.control.selected_index==3:
            page.close(aba)
        page.update()

    aba=ft.NavigationDrawer(
        bgcolor=ft.colors.BLUE_600,
        on_dismiss=fechar_painel,
        on_change=clicar_destino,
        controls=[
            ft.Container(height=12),
            ft.NavigationDrawerDestination(
                label="Item 1",
                icon=ft.icons.AIRPLANEMODE_ON,
                selected_icon_content=ft.Icon(ft.icons.AIRPLANEMODE_INACTIVE),
            ),
            ft.NavigationDrawerDestination(
                icon_content=ft.Icon(ft.icons.AIRPLANE_TICKET),
                label="Item 2",
                selected_icon=ft.icons.AIRPLANE_TICKET_OUTLINED,
            ),
            ft.NavigationDrawerDestination(
                icon_content=ft.Icon(ft.icons.AIRPORT_SHUTTLE),
                label="Item 3",
                selected_icon=ft.icons.DEBLUR_SHARP,
            ),
            ft.Divider(thickness=2),
            ft.NavigationDrawerDestination(
                icon_content=ft.Icon(ft.icons.CHALET),
                label="Fechar Aba",
                selected_icon=ft.icons.PHONE,
            ),
            ft.NavigationDrawerDestination(
                label="Feche a aba clicando no ícone\n ou fora da aba"
            ),
        ],
    )
    mensagem=ft.Text("Suas ações serão vistas aqui:\n", color=ft.colors.BLACK)
    centro=ft.Container(
        content=mensagem,
        margin = ft.margin.only(left=300, top=0, right=0, bottom=0),
        padding=30,
        width=300,
        height=230,
        border_radius=10,
        bgcolor=ft.colors.AMBER_100,
    )
    page.add(
        ft.ElevatedButton("Exibir drawer", on_click=lambda e: page.open(aba)),
        centro
    )

ft.app(main)

A figura 1 mostra o estado do aplicativo em execução. 1 (A) é o estado inicial, antes de qualquer ação do usuário. 1 (B) exibe a aba após o clique sobre Exibir drawer. 1 (C) é o estado após um clique sobre os três itens, seguido do clique sobre Fechar Aba ou em qualquer ponto da página fora da aba.

Controle NavigationBar

NavigationBar é um componente da barra de navegação no estilo Material 3. Barras de navegação são dispostas ao fundo da página do aplicativo e podem conter diversos controles de seleção, chamados NavigationBarDestination que podem ser selecionados com um clique. Essa é uma forma conveniente de alternar entre destinos em um aplicativo.

Propriedades de NavigationBar

As seguintes propriedades estão definidas para o controle NavigationBar:

Nota † ControlState é um enum com os valores: DEFAULT, DISABLED, DRAGGED, ERROR, FOCUSED, HOVERED, PRESSED, SELECTED, SCROLLED_UNDER.

Eventos da NavigationBar

Os controles NavigationBarDestination não possuem nenhum evento associado. O único evento do conjunto está na troca de seleção entre as opções dispostas na NavigationBar.

Propriedades de NavigationBarDestination

Exemplo de Uso da NavigationBar e NavigationBarDestination

import flet as ft

def main(page: ft.Page):
    page.horizontal_alignment = "center"
    page.bgcolor=ft.colors.BLUE_100
    page.title = "Exemplo de NavigationBar"
    controle=["Explorar", "Carona", "Ônibus", "Apagar"]

    def mostrar_barra(e):
        nav_barra.visible=not nav_barra.visible
        bt.text=f"{'Ocultar' if nav_barra.visible else 'Exibir'} Barra de Navegação"
        mensagem.value += f"\nVocê {'exibiu' if nav_barra.visible else 'ocultou'} a Barra de Navegação"
        page.update()

    def mudou_destino(e):
        if e.control.selected_index==3:
            mensagem.value="Suas ações serão vistas aqui:\n"
        else:
            mensagem.value += f"\nVocê selecionou o botão {controle[e.control.selected_index]}"
        page.update()

    nav_barra=ft.NavigationBar(
        visible=False,
        destinations=[
            ft.NavigationBarDestination(icon=ft.icons.EXPLORE, label="Explorar"),
            ft.NavigationBarDestination(icon=ft.icons.PERSON, label="Carona"),
            ft.NavigationBarDestination(icon=ft.icons.DIRECTIONS_BUS, label="Ônibus"),
            ft.NavigationBarDestination(
                icon=ft.icons.HIDE_IMAGE,
                selected_icon=ft.icons.HIDE_SOURCE,
                label="Apagar"
            ),
        ],
        on_change=mudou_destino
    )
    page.navigation_bar = nav_barra
    mensagem=ft.Text("Suas ações serão vistas aqui:\n", color=ft.colors.BLACK)
    bt=ft.ElevatedButton("Exibir NavigationBar", on_click=mostrar_barra)
    page.add(bt, mensagem)

ft.app(target=main)

A figura 1 mostra o estado do aplicativo em execução. A primeira imagem é o estado após a exibição da barra de navegação e clique no botão Explorar. Ao lado o resultado do clique no botão Apagar.

Controle MenuBar

Um controle MenuBar é uma barra que normalmente é posta acima da página principal do aplicativo para abrigar um sistema de menus e outros controles usados para as ações principais do usuário. Ela pode conter um sistema de menus composto por submenus e, se desejado, pode ser colocado em qualquer parte do aplicativo.

Propriedades de MenuBar

O controle MenuBar possui poucas propriedades. Como ele pode conter diversos outros controles filhos as formatação e coleta de eventos se dá, em geral, nesses filhos. As seguintes propriedades estão definidas para o controle MenuBar:

Exemplo de Uso do MenuBar

import flet as ft

def main(page: ft.Page):
    page.horizontal_alignment = "center"

    def delete(e):
        mensagem.value=""
        page.open(ft.SnackBar(ft.Text("Você apagou as mensagens!")))
        page.update()

    def hover_submenu(e):
        page.open(ft.SnackBar(ft.Text(f"Hover em {e.control.content.value}!")))
        page.update()

    def clique_menu(e):
        mensagem.value+=f"\nClicou em {e.control.content.value}"
        page.update()

    def abre_submenu(e):
        mensagem.value+=f"\nAbrir {e.control.content.value}"
        page.update()

    def fecha_submenu(e):
        mensagem.value+=f"\nFechar {e.control.content.value}"
        page.update()

    icone=[ft.icons.HELP, ft.icons.SAVE, ft.icons.DOOR_BACK_DOOR,
           ft.icons.TEXT_INCREASE , ft.icons.TEXT_DECREASE]

    class MenuItem(ft.MenuItemButton):
        def __init__(self, texto, ico):
            super().__init__()
            self.content=ft.Text(texto)
            self.leading=ft.Icon(icone[ico])
            self.style=ft.ButtonStyle(bgcolor={ft.ControlState.HOVERED: ft.colors.BLUE_100})
            self.on_click=clique_menu

    class SubMenu(ft.SubmenuButton):
        def __init__(self, texto, controles):
            super().__init__()
            self.content=ft.Text(texto)
            self.on_open=abre_submenu
            self.on_close=fecha_submenu
            self.on_hover=hover_submenu
            self.controls=controles

    page.appbar = ft.AppBar(
        title=ft.Text("Demonstração do Controle MenuBar e SnackBar"),
        center_title=True,
        bgcolor=ft.colors.BLUE
    )

    mensagem=ft.Text("", size=20)
    estilo=ft.MenuStyle(alignment=ft.alignment.top_left, bgcolor=ft.colors.RED_300)
    bt_apagar=ft.IconButton(ft.icons.DELETE, icon_color="white", on_click=delete)
    subMenu1=SubMenu("Arquivo",[MenuItem("Sobre", 0), MenuItem("Gravar", 1), MenuItem("Terminar", 2)])
    subMenu2=SubMenu("Visualizar", [SubMenu("Zoom", [MenuItem("Ampliar", 3),MenuItem("Diminuir", 4)])])
    menu_bar=ft.MenuBar(expand=True, style=estilo, controls=[bt_apagar, subMenu1, subMenu2])
    coluna = ft.Column(
        controls=[mensagem],
        height=700,
        alignment=ft.MainAxisAlignment.CENTER
    )

    page.add(ft.Row([menu_bar]), coluna)

ft.app(main)

O resultado desse código está mostrado na figura 1. A primeira imagem mostra o estado ao abrir o aplicativo e passar o cursor do mouse sobre o Menu Arquivo. A segundo mostra o estado após alguns cliques nos submenus de Arquivo. Um clique na lixeira apaga o texto no corpo da página.

Esse exemplo usa o controle SnackBar, que é uma barra de exibição de informações que se abre, temporariamente, no fundo da página do aplicativo.

Duas classes foram definidas:

• MenuItem, que herda de ft.MenuItemButton e recebe apenas o texto e o ícone a exibir,
• SubMenu, que herda de ft.SubmenuButton e recebe o texto e o array de controles que serão exibidos.

Esse é um recurso para evitar a declaração repetida de controles que possuem a maioria das propriedades comuns.

Estilo de formatação do código

Nota: adotei nesse bloco de código a prática de declarar os objetos antes de seu uso dentro das propriedades dos controles. Também é possível definir os blocos no ambiente em que são usados. A primeira opção foi usada buscando dar mais clareza ao código. Alguns programadores provavelmente preferem fazer do segundo modo. Esses estilos estão ilustrados abaixo:

# o estilo usado no texto:
    mensagem=ft.Text("", size=20)
    estilo=ft.MenuStyle(alignment=ft.alignment.top_left, bgcolor=ft.colors.RED_300)
    subMenu=SubMenu("Visualizar", [SubMenu("Zoom", [MenuItem("Ampliar"),MenuItem("Diminuir")])])
    menu_bar=ft.MenuBar(expand=True, style=estilo, controls=[subMenu])
    coluna=ft.Column(controls=[mensagem])
    linha=ft.Row([menu_bar])

    page.add(linha, coluna)
    
# alternativamente:

    mensagem=ft.Text("", size=20)
    page.add(
        ft.Row(
            ft.MenuBar(
                expand=True,
                style=ft.MenuStyle(
                    alignment=ft.alignment.top_left,
                    bgcolor=ft.colors.RED_300
                ),
                controls=[
                    SubMenu("Visualizar",
                        [SubMenu("Zoom", [MenuItem("Ampliar"), MenuItem("Diminuir")])]
                    )
                ]
            )
        ),
        ft.Column(controls=[mensagem])
    )

Se essa segunda forma de formatação for adotada é importante manter um sistema coerente de indentação (notando que não se trata da indentação obrigatória do Python para definir blocos).
Observe que a variávelmensagem (um flet.Text) continua sendo definida em separado para poder ser referenciada em uma função fora desse bloco.

DNF: Gerenciador de Pacotes de Software no Linux

O que é DNF

DNF é um gerenciador de pacotes de software, usado para instalar, atualizar e remover pacotes no Fedora e outras distribuições do Linux. DNF (Dandified Yum) foi proposto como substituto do YUM (Yellowdog Updater Modified), ambos usados em sistemas operacionais que utilizam pacotes RPM.

O DNF facilita a manutenção de pacotes, verificando automaticamente as dependências e determinando as ações necessárias para instalar os pacotes. Este método elimina a necessidade de instalar ou atualizar manualmente o pacote e suas dependências usando o comando rpm.

Uso do dnf

Nesse artigo usamos as seguintes convenções:
# linhas de comentários
$ linhas de código (input)
➡ linhas de saída (output)

O dnf pode ser usado para buscar, instalar, atualizar ou remover pacotes. Por exemplo:

# para pesquisar nos repositórios um tipo de pacote:
$ dnf search nome_do_pacote

# para instalar o pacote:
$ dnf install nome_do_pacote

# para remover um pacote:
$ dnf remove nome_do_pacote

# em muitos casos pode ser necessário rodar o comando como superuser
$ sudo dnf comando

Outros comandos do dnf de uso comum são:

Exemplos de Uso

Como exemplo, procuraremos pelo aplicativo focuswriter, um editor de texto distraction free. Ele é instalado e, em seguida, desinstalado. A pesquisa é feita nos repositórios cadastrados.

# pesquisando pelo aplicativo
$ dnf search focuswriter

➡ ========= Name Exactly Matched: focuswriter ========================
➡ focuswriter.x86_64 : A full screen, distraction-free writing program

# instalando o focuswriter (superuser é exigido)
$ sudo dnf install focuswriter
# aparece o aplicativo e uma lista de dependências (Is this ok? [y/n])

# desinstalando um aplicativo
$ sudo dnf remove focuswriter
# aparece o aplicativo e uma lista de dependências (Is this ok? [y/n])

Instalando Pacotes

O comando dnf [options] install <spec>... instala pacotes e verifica se todas as dependências estão satisfeitas (instaladas no sistema). <spec> pode se referir a pacotes, módulos ou grupos. Uma mensagem de erro será emitida se o pacote não estiver disponível nos repósitórios declarados. Se a versão do pacote for especificada ela será instalada, independentemente de qual versão já está instalada ou qual é a mais recente. A versão previamente instalada será removida.

Alguns exemplos podem ajudar a explicar o uso de install:

# instala o pacote vlc (vlc é o nome do pacote)
$ dnf install vlc

# instala o arquivo rpm tito-0.6.2-1.fc22.noarch.rpm na pasta ~/Downloads
$ dnf install ~/Downloads/tito-0.6.2-1.fc22.noarch.rpm

# instala o pacote do repositório, na versão especificada
# Se o pacote já instalado ele será atualizado ou downgraded (tentativamente)
$ dnf install tito-0.5.6-1.fc22

# instala a última versão do pacote. Se já instalado o pacote será atualizado ou downgraded (tentativamente)
# a instalação falhará se o pacote atualizado não puder ser instalado
$ dnf --best instala tito

# nesse caso vim não é o nome do pacote mas de um grupo
# dnf instalará o conjunto de pacote e dependências necessárias
$ dnf install vim

# instala o pacote diretamente da URL
$ dnf install https://fedoraproject.org//packages/nome_do_pacote.rpm

# instale todos os perfis do módulo 'docker' e seus RPMs
$ dnf install '@docker'

# instala o grupo 'Web Server'
$ dnf install '@Web Server'

# instala o pacote que fornece o arquivo /usr/bin/rpmsign.
$ dnf install /usr/bin/rpmsign

# instala o pacote tito sem dependências fracas (não exigidas para o
# funcionamento básico do pacote, como documentação, plugins, funções adicionais, etc).
$ dnf -y install tito --setopt=install_weak_deps=False

# instala todos os pacotes do "FEDORA-2018-b7b99fe852".
$ dnf install --advisory=FEDORA-2018-b7b99fe852 \*

Listando Pacotes

Podemos listar os pacotes instalados com dnf list installed:

$ dnf list installed
# uma lista de apps instalados pelo sistema ou pelo usuário,
# é exibida (com nome, versão e repositório de origem).

# dica: se você quer analisar a lista em um editor de texto faça:
$ dnf list installed > apps_instalados.txt
# um arquivo de nome apps_instalados.txt é gravado no diretório atual

# para contar quantos pacotes estão instalados
$ dnf list installed | wc -l

O “pipe” | envia a saida em lista para o comando seguinte. O comando wc do BASH faz uma contagem das linhas emitidas na saída de list.

Todos os pacotes instalados em sistemas que usam RPM deixam informações armazenadas em um banco de dados SQLite. Existem mais de uma forma de consultar esse banco de dados e encontrar detalhes sobre pacotes instalados, por exemplo usando o comando rpm. No Fedora esse banco de dados fica no diretório /var/lib/rpm/rpmdb.sqlite.

dnf list é uma das formas de acessar essa tabela. Outros comandos são possíveis:

Todos os comandos acima admitem a inclusão de opções e discriminação de tipos de pacote, na forma:
dnf [option] comando <especifica-pacote>. Confira as opções disponíveis na páginas do manual usando man dnf.

Gerenciando Repositórios

Repositórios são servidores onde estão armazenados os pacotes de software das distribuições do Linux. As grandes distribuições mantém os seus repositórios próprios, que são acessados por meio dos comandos de gerenciamento de pacotes como dnf (do Fedora), apt (do Ubuntu) ou pacman (do Arch).

No Fedora os repositórios cadastrados podem ser encontrados no diretório etc/yum.repos.d/. Esses repositórios podem ser gerenciados com dnf:

# para ver uma lista de repositórios disponíneis e habilitados
$ dnf repolist

# para ver uma lista de todos os repositórios, habilitados ou não
$ dnf repolist all

Novos repositórios podem ser inseridos e habilitados simplesmente acrescentando-se um arquivo .repo na pasta /etc/yum.repos.d. A mesma operação pode ser feita com o comando dnf config-manager. Por exemplo, podemos inserir o repositório que contém o Sublime Text (um editor de código). Em seguido usamos cat para listar o conteúdo do arquivo inserido:

# inserindo o repositório para Sublime Text (stable, no Fedora)
$ sudo dnf config-manager --add-repo https://download.sublimetext.com/rpm/stable/x86_64/sublime-text.repo
➡ Adding repo from: https://download.sublimetext.com/rpm/stable/x86_64/sublime-text.repo

# o seguinte arquivo é inserido na pasta /etc/yum.repos.d/
$ cat /etc/yum.repos.d/sublime-text.repo
➡ [sublime-text]
➡ name=Sublime Text - x86_64 - Stable
➡ baseurl=https://download.sublimetext.com/rpm/stable/x86_64
➡ enabled=1
➡ gpgcheck=1
➡ gpgkey=https://download.sublimetext.com/sublimehq-rpm-pub.gpg

O arquivo *.repo tem a seguinte estrutura:

• [ID do pacote]: id do repositório,
• name: nome do repositório,
• baseurl: URL do repositório,
• enabled=1: 1 para habilitado, 0 para desabilitado,
• gpgcheck=1: 1 para permitir verificação da assinatura gpg, 0 para impedir,
• gpgkey: URL da chave GPG, usada para assinar os pacotes.

Feito isso o pacote para o Sublime Text pode ser instalado com sudo dnf install sublime-text.

Repositórios podem ser habilitados ou desabilitados com dnf --enablerepo. Essa operação pode ser útil, por exemplo quando um pacote está disponível em mais de um repositório mas desejamos instalar de um específico.

# para desabilitar um repositório
$ sudo dnf config-manager --set-disabled id_do_repositorio

# para habilitar um repositório
sudo dnf config-manager --set-enabled id_do_repositorio

Por exemplo, podemos encontrar o id do repositório Sublime Text (supondo que esteja instalado e habilitado) com dnf repolist --all, que é, como se vê abaixo, sublime-text. Em seguida vamos desabilitá-lo, e reabilitá-lo em seguida.

$ dnf repolist --all
➡ repo id repo name status
➡ docker-ce-nightly Docker CE Nightly - x86_64 disabled
➡ fedora Fedora 40 - x86_64 enabled
➡ google-chrome google-chrome enabled
➡ sublime-text Sublime Text - x86_64 enabled

# para desabilitar o repositório
$ sudo dnf config-manager --set-disabled sublime-text

# para habilitar o repositório
$ sudo dnf config-manager --set-enabled sublime-text

# para remover o repositório do sistema basta apagar o arquivo em /etc/yum.repos.d
$ sudo rm /etc/yum.repos.d/sublime-text.repo

Uma vez que o repositório tenha sido excluído o dnf não tentará instalar ou atualizar seus pacotes.

Opções

O comando dnf [options] install <spec>... pode receber parâmetros em [options]. Alguns opções são listadas abaixo. Veja a lista completa na documentação do dnf.

Histórico

O dnf armazena um histórico de transações realizadas, que permite a verificação de tudo o que foi feito. Isso é útil para identificar problemas e desfazer operações.

# para listar o histórico de transações usamos
$ dnf history

# ou
$ dnf history list

Esses comandos exibem uma tabela com quatro colunas: ID da transação, a linha de comando executada, data e hora, a ação executada e o número de pacotes alterados. Por default as transações mais recentes aparecem primeiro.

➡ ID  | Command line             | Date and time       | Action(s) | Altered
➡ --------------------------------------------------------------------------------
➡ 157 | upgrade                  | 2024-07-23 17:31    | Upgrade   | 16
➡ 156 | remove focuswriter       | 2024-07-23 11:58    | Removed   | 5
➡ 155 | install focuswriter      | 2024-07-23 11:55    | Install   | 5
➡ 154 | update                   | 2024-07-23 11:20    | Upgrade   | 1
➡ 153 | autoremove               | 2024-07-23 09:37    | Removed   | 1
➡ 152 | remove mpv*              | 2024-07-23 09:35    | Removed   | 75
➡ 151 | remove sublime-text      | 2024-07-23 09:33    | Removed   | 1

A coluna Actions pode listar as ações listadas (às vezes indicada por uma letra):

• Install (I): pelo menos um pacote foi instalado,
• Update (U): pelo menos um pacote foi atualizado,
• Reinstall (R): pelo menos um pacote foi reinstalado,
• Downgrade (D): pelo menos um pacote foi rebaixado para uma versão anterior,
• Erase (E): pelo menos um pacote foi desinstalado ou removido do sistema,
• Obsoleting (O): pelo menos um pacote foi marcado como obsoleto.

A coluna “Altered” lista quantas ações foram executadas na transação, e pode usar os seguintes símbolos:

• >: O banco de dados RPM foi alterado após a transação,
• <: O banco de dados RPM foi alterado antes da transação,
• *: A transação foi abortada antes do término,
• #: A transação foi completada mas com status não zero,
• E: A transação foi completada com sucesso, mas emitiu mensagem de erro.

Alguns argumentos adicionais podem ser usados para se encontrar uma transação específica.

# listar a última transação
$ dnf history list last
➡ ID | Command line | Date and time | Action(s) | Altered
--------------------------------------------------------------------------------
➡ 157 | upgrade | 2024-07-23 17:31 | Upgrade | 16

# listar a n-ésima transação, sendo n=0 a última
$ dnf history list last-5
➡ ID | Command line | Date and time | Action(s) | Altered
➡ --------------------------------------------------------------------------------
➡ 152 | remove mpv* | 2024-07-23 09:35 | Removed | 75

# listar a transação por ID
$ dnf history list 155
➡ ID | Command line | Date and time | Action(s) | Altered
➡ --------------------------------------------------------------------------------
➡ 155 | install focuswriter | 2024-07-23 11:55 | Install | 5

# listar a transações dentro de uma faixa de IDs
$ dnf history list 101..104
➡ ID | Command line | Date and time | Action(s) | Altered
➡ --------------------------------------------------------------------------------
➡ 104 | install docker-ce | 2024-06-18 12:56 | Install | 9 <
➡ 103 | remove cosmic* | 2024-06-18 12:05 | Removed | 35 >>
➡ 102 | remove xournal* | 2024-06-18 11:30 | Removed | 5
➡ 101 | update | 2024-06-18 11:06 | Upgrade | 2

# listar a transações em ordem invertida:
$ dnf history list --reverse
# A saida é uma lista de transações iniciando pela mais antiga

# listar as transações de instalações executadas pelo usuário:
$ dnf history userinstalled

A saída do comando pode ser filtrada de alguns modos:

# dnf history list | grep nome_do_pacote
# por exemplo
$ dnf history list | grep sublime
➡ ID | Command line | Date and time | Action(s) | Altered
➡ --------------------------------------------------------------------------------
➡ 151 | remove sublime-text | 2024-07-23 09:33 | Removed | 1
➡ 120 | install sublime-text | 2024-07-02 14:58 | Install | 1 <

Obtendo informações mais detalhadas: para obter detalhes sobre uma transação específica passe a opção info.A saída inclui:

1. duração (em tempo) da transação
2. qual usuário executou a transação
3. código de retorno
4. versão
5. qual comando foi executado
6. pacotes alterados

Por exemplo:

# para ver detalhes da transação com ID=120
$ dnf history info 120
➡ Transaction ID : 120
➡ Begin time : Tue 02 Jul 2024 02:58:05 PM -03
➡ Begin rpmdb : 562f2fb16f16bf6744987e7ab94ef265d7e988c68995eb4ca7bf3ea9e1705337
➡ End time : Tue 02 Jul 2024 02:58:07 PM -03 (2 seconds)
➡ End rpmdb : d4583d3d187fc29fd02eb6e36847eda474f1e6097e60885543adfdb936446035
➡ User : Nome Completo do Usuário <usuario>
➡ Return-Code : Success
➡ Releasever : 40
➡ Command Line : install sublime-text
➡ Comment :
➡ Packages Altered:
➡ Install sublime-text-4169-1.x86_64 @sublime-text

Para desfazer uma transação listada no histórico usamos undo ID. No exemplo, a transação com ID=156 consistiu na remoção do Focus Writer. Além disso é possível fazer uma operação de rollback, desfazendo todas as transações realizadas após a transação de ID=n, fazendo sudo dnf history rollback 12. Todas as transações ocorridas depois da transação com ID=n, portanto as que aparecem primeiro na lista, são desfeitas.

$ sudo dnf history undo 156
# após essa operação o Focus Writer volta a estar instalado no sistema.

# para desfazer todas as transações até a de ID=12
$ sudo dnf history rollback 12

# para desfazer um rollback, as mesmas transações podem ser reexecutadas,
$ sudo dnf history redo 12

Mesmo após a execução da operação de reverter uma transação e de rollback (que reverte várias transações) as entradas no histórico não são removidas, mas uma nova entrada é acrescentada para armazenar a operação de desfazer.

Plugins

A funcionalidade do dnf pode ser ampliada por meio de plugins. Existem plugins oficiais e plugins de outros desenvolvedores. A instalação é feita com o próprio dnf.

# para instalar os plugins core
$ dnf install dnf-plugins-core-NOME_PLUGIN

# para instalar os plugins extras
$ dnf install dnf-plugins-core-NOME_PLUGIN

São exemplos de plugins nos repositórios oficiais:

$ dnf install dnf-plugin-kickstart
$ dnf install dnf-plugin-rpmconf
$ dnf install dnf-plugin-showvars
$ dnf install dnf-plugin-snapper
$ dnf install dnf-plugin-torproxy
$ dnf install dnf-plugin-tracer

Mais informações em Core DNF plugins e Extras DNF plugins.

Atualizações de Sistema

O comando dnf pode ser usado para a atualização do sistema, diretamente ou com o plugin de atualização dnf-plugin-system-upgrade. A atualização pode ser feita diretamente com DNF puro (sem plugins) ou com o plugin de atualização do sistema DNF. Consulte o documento de atualização do sistema DNF para obter mais detalhes, em Upgrading Fedora.

Para fazer uma atualização (upgrade) de sistema, fazemos primeiro a atualização da tabela do dnf com refresh.

# atualiza tabela dnf
$ sudo dnf upgrade --refresh
# em seguida reinicialie o sistema

# instala systema: substitua n pelo número da versão
$ sudo dnf system-upgrade download --releasever=n

# para disparar o processo (o computador reiniciará imediatamente)
$ sudo dnf system-upgrade reboot

Algumas tarefas são possíveis após uma atualização. A maioria dos arquivos de configuração são armazenados na pasta /etc. Se algum desses arquivos poi alterado o RPM cria novos arquivos com extensão .rpmnew (os novos arquivos) ou .rpmsave (os arquivos antigos). Você pode examinar manualmente esses arquivos ou usar a ferramenta rpmconf para simplificar esse processo.

# instala a ferramenta
$ sudo dnf install rpmconf

# use a ferramenta
$ sudo rpmconf -a

Mais informações nos manuais em man rpmconf.

Bibliografia

• Fedora Docs: Using the DNF software package manager
• Fedora Docs: DNF
• Fedora People: Using the RPM Database
• LinuxIAC: DNF Command-Line Package Manager
• Red Hat Docs: Managing software with the DNF tool
• Root Users: 25 Useful DNF Command Examples

Layout

Controle Pagelet

O controle Pagelet permite a inserção de uma área no aplicativo usando o layout do Material Design. Com ele podemos criar uma barra de cabeçalho, uma área de conteúdo, uma barra inferior e um menu que surge quando requerido.

Um exemplo simples de uso mostra essas áreas e seus respectivos nomes.

import flet as ft

def main(page: ft.Page):
    page.bgcolor=ft.colors.LIGHT_BLUE_ACCENT_700

    titulo=ft.Text("Barra superior da Pagelet", color="BLACK")
    conteudo=ft.Text("Conteúdo do corpo da Pagelet", color="BLACK")
    icone_inferior=ft.IconButton(icon=ft.icons.SEARCH, icon_color=ft.colors.BLUE)
    txt_inferior=ft.Text("Texto na barra inferior da Pagelet", color="BLACK")
    barra_inferior=ft.Row([icone_inferior, txt_inferior])

    menu_direita=[
        ft.NavigationDrawerDestination(icon=ft.icons.HOME, label="Em casa"),
        ft.NavigationDrawerDestination(icon=ft.icons.HOME_WORK, label="No trabalho")
    ]

    pagelet = ft.Pagelet(
        appbar=ft.AppBar(title=titulo, bgcolor=ft.colors.DEEP_ORANGE_200),
        content=conteudo,
        bgcolor=ft.colors.AMBER_50,
        bottom_app_bar=ft.BottomAppBar(
            bgcolor=ft.colors.CYAN_ACCENT_700,
            content=barra_inferior,
        ),
        end_drawer=ft.NavigationDrawer(controls=menu_direita, bgcolor=ft.colors.BLUE_ACCENT),
        width=400,
        height=300
    )

    page.add(pagelet)

ft.app(target=main)

O resultado da execução do código está mostrado na figura 1.

Respectivamente as propriedades de Pagelet correspondem: appbar, a barra superior, cabeçalho do aplicativo;
content, o conteúdo central; bottom_app_bar, a barra inferior; end_drawer uma barra ocultável, normalmente usada para inserir um menu de opções.

Propriedades de Pagelet

Métodos de Pagelet

† NotaTraduzi drawer por gaveta.

Uso de Pagelet

import flet as ft

def main(page: ft.Page):
    page.bgcolor=ft.colors.BLUE_50

    citacao=[(
        'Há três métodos para ganhar sabedoria: primeiro, por reflexão, '
        'que é o mais nobre; segundo, por imitação, que é o mais fácil; '
        'e terceiro, por experiência, que é o mais amargo. Confúcio'
    ),
    (
        'Todos os seres vivos temem a violência. Todos temem a morte,'
        'todos amam a vida. Projete você mesmo em todas as criaturas.'
        'Quem você poderia ferir? Que mal você poderia fazer? Buda'
    )]

    def clicou_algo(e):
        mensagem.content.value=e.control.tooltip
        page.update()

    def selecionar_sabedoria(e):
        conteudo.content.value=citacao[e.control.selected_index]
        pagelet.end_drawer.open = False
        page.update()

    def abrir_drawer(e):
        pagelet.end_drawer.open = True
        pagelet.end_drawer.update()

    def fecha_barra_direita(e):
        mensagem.content.value="Menu da direita fechado"
        page.update()

    class Botao(ft.IconButton):
        def __init__(self, icon, tip):
            super().__init__()
            self.icon=icon
            self.icon_color=ft.colors.WHITE
            self.tooltip=tip
            self.on_click=clicou_algo

    conteudo = ft.Container(
        content=ft.Text(citacao[0], size=19, color="BLACK"),
        padding=ft.padding.all(20),
        bgcolor=ft.colors.BLUE_300,
        border=ft.border.all(3, ft.colors.BLUE_400),
        border_radius=ft.border_radius.all(10),
        expand=True,
    )
    barra_inferior = ft.BottomAppBar(
        bgcolor=ft.colors.BLUE,
        shape=ft.NotchShape.CIRCULAR,
        content=ft.Row(
            controls=[
                Botao(ft.icons.SUNNY, "Escolha seu destino"),
                Botao(ft.icons.AIRPLANEMODE_ACTIVE, "Compre sua passagem"),
                ft.Container(expand=True),
                Botao(ft.icons.HOTEL, "Reserve o seu hotel"),
                Botao(ft.icons.ROCKET, "Viaje para mais longe"),
            ]
        )
    )
    barra_direita=ft.NavigationDrawer(
        controls=[
            ft.NavigationDrawerDestination(icon=ft.icons.SELECT_ALL, label="Confúcio"),
            ft.NavigationDrawerDestination(icon=ft.icons.ADD_COMMENT, label="Buda"),
        ],
        bgcolor=ft.colors.LIGHT_BLUE_ACCENT_700,
        on_change=selecionar_sabedoria,
        on_dismiss=fecha_barra_direita,
    )

    pagelet = ft.Pagelet(
        appbar=ft.AppBar(
            title=ft.Text("Clique no menu para selecionar", color=ft.colors.BROWN),
            bgcolor=ft.colors.LIGHT_BLUE_ACCENT_100,
            toolbar_height=60,
        ),
        content=conteudo,
        bottom_app_bar=barra_inferior,
        end_drawer=barra_direita,
        floating_action_button=ft.FloatingActionButton("Menu", on_click=abrir_drawer),
        floating_action_button_location=ft.FloatingActionButtonLocation.CENTER_DOCKED,
        bgcolor=ft.colors.BLUE_600,
        width=400,
        height=300,
    )
    mensagem=ft.Container(
        ft.Text("Eventos aparecem aqui...", size=17, color=ft.colors.BLACK),
        padding=ft.padding.all(20),
        bgcolor=ft.colors.BROWN_200,
        border=ft.border.all(3, ft.colors.BROWN_300),
        border_radius=ft.border_radius.all(10),
        width=400,
        height=70,
    )
    page.add(
        ft.Container(
            content=ft.Column([pagelet,mensagem]),
            padding=ft.padding.all(20),
            bgcolor=ft.colors.BLUE_300,
            border=ft.border.all(3, ft.colors.BLUE_400),
            border_radius=ft.border_radius.all(10),
        ),
    )

ft.app(target=main)

O resultado da execução do código está mostrado na figura 2.

Nesse código alguns componentes da Pagelet foram definidos separadamente e inseridas depois no controle. Isso foi feito para tornar o código mais fácil de ser entendido. A definição da classe Botao tem apenas o objetivo de diminuir as repetições de código na montagem da barra_inferior.

Os cliques nos ícones na barra inferior transfere o conteúdo dos tooltips para o container inferior no aplicativo. Cliques no menu deslizante, nos itens Confúcio e Buda alteram o conteúdo de texto do controle central através da função selecionar_sabedoria. A mensagem é selecionada usando e.control.selected_index, que é o índice do controle NavigationDrawerDestination clicado.