Gerenciando o estado do aplicativo

No egui, o estado do seu aplicativo é formado por dados comuns de Rust que vivem na estrutura que implementa eframe::App. Não há um armazenamento especial nem um modelo pertencente ao framework.

Os campos contêm tudo: entradas de formulários, seleções, dados carregados e sinalizadores. A cada quadro, update lê e modifica esses campos diretamente por meio de &mut self.

O eframe cria seu aplicativo em uma closure passada para run_native. O padrão mais simples é #[derive(Default)] e a construção com App::default().

Para valores iniciais que não sejam padrão, implemente Default manualmente ou adicione um construtor que receba o CreationContext para configurações como fontes ou persistência.

Como os widgets usam empréstimo &mut dos campos que os respaldam, a estrutura é sempre a fonte única da verdade. Não há um estado de visualização separado para manter sincronizado.

Uma caixa de seleção vinculada a &mut self.enabled reflete e atualiza esse booleano diretamente — leia-o em qualquer outro lugar do mesmo quadro e você verá o valor atual.

Um problema sutil de empréstimo: muitas vezes você percorre um Vec enquanto deseja remover itens dele. Não é possível modificar o vetor enquanto houver um empréstimo compartilhado ativo.

A solução é registrar a ação pretendida em uma variável local durante o laço e aplicá-la depois que o laço terminar.

Para aplicativos com várias telas, modele a visualização atual como um campo enum. O método update usa uma correspondência sobre ele para decidir o que desenhar.

Isso mantém a navegação explícita e exaustiva — o compilador obriga você a tratar cada tela, eliminando classes inteiras de erros de roteamento.

Parte do estado diz respeito apenas à interface, não ao seu domínio — seções recolhidas, posições de rolagem e estado de arrasto. O egui armazena isso em ctx.memory, indexado pelo Id do widget.

Você raramente o acessa diretamente, mas ctx.data_mut permite guardar pequenos valores por ID que persistem entre os quadros sem sobrecarregar a estrutura do seu App.

Nunca bloqueie update com operações lentas de E/S — isso congela o laço de 60 quadros por segundo. Crie uma thread e comunique-se por meio de um canal std::sync::mpsc.

O trabalhador envia os resultados de volta; update esvazia o receptor sem bloqueá-lo, usando try_recv a cada quadro. Chame ctx.request_repaint() no trabalhador para que a interface seja redesenhada quando os dados chegarem.

Clone o Context e o remetente para dentro da thread. O clone é barato — internamente, ele é um Arc — e permite que o trabalhador solicite redesenhos.

Mova a propriedade das entradas de trabalho para dentro da closure para satisfazer o verificador de empréstimos e evitar problemas de tempo de vida.

O eframe pode serializar seu aplicativo entre as execuções. Ative o recurso persistence, derive serde::Serialize / Deserialize e implemente App::save.

Na inicialização, leia o estado salvo de cc.storage no seu construtor, usando os valores padrão como alternativa quando nada estiver armazenado.

Como update é executado a cada quadro, evite recalcular dados derivados caros nele. Armazene os resultados em cache nos campos e recalcule-os apenas quando as entradas mudarem.

Um padrão comum é acompanhar um sinalizador dirty definido por Response::changed() e reconstruir os caches no início de update somente quando ele estiver ativo.

O tema recorrente é o seguinte: o egui depende da propriedade de Rust, em vez de frameworks, para gerenciar o estado. Sua estrutura é proprietária dos dados, &mut self concede acesso exclusivo a cada quadro e as threads se comunicam por canais.

Não há assinaturas ocultas nem grafos de callbacks, portanto entender quando e como o estado muda continua sendo algo local e explícito.

O estado do App consiste em campos comuns na estrutura eframe::App, modificados por meio de &mut self a cada quadro, tornando a estrutura a fonte única da verdade.

Adie modificações durante a iteração, modele as telas com enums, transfira o trabalho lento para threads usando canais e persista os dados com o armazenamento do eframe. Mantenha update eficiente armazenando dados derivados em cache por trás de sinalizadores de alteração. A seguir: empacotamento do seu aplicativo para distribuição.