Na primeira parte de nosso Tutorial: Criando meu app step-by-step cujo o foco foi o desenvolvimento completo de um aplicativo para iOS e Android, nós mostramos uma técnica para navegação entre vários formulários, ao invés, por exemplo, de se cirar um único form com várias abas. O esquema mostrado consistia em criar um método chamado ShowForm (MostrarForm) recebendo como parâmetro um TFmxObject. No exemplo nós criamos um formulário principal com um TLayout ao fundo. Nos demais forms, nós incluímos também um TLayout ao fundo e sempre ao abrir uma nova janela, inserimos o TLayout do form alvo dentro do TLayout do formulário principal.

Para relembrar, foi assim que codificamos no nosso aplicativo:

procedure TfrmMain.ShowForm(AObject: TFmxObject);
var
  I : Integer;
begin
  HideBackground;

  for I := 0 to Pred(Self.lytMain.Children.Count) do
    TControl(Self.lytMain.Children[I]).Visible :=
      TControl(Self.lytMain.Children[I]) = TControl(AObject);
end;

Além disso ainda precisamos criar uma variável da mesma classe de cada novo formulário para podermos controlar a abertura e fechamento, tal como FPedidos : TfrmPedidos, FCliente : TfrmCliente, e assim sucessivamente. No código acima, o que fazemos é localizar TODOS os TLayout visíveis dentro do TLayout principal e deixa-los invisível tornando visível somente o layout do formulário alvo. Essa abordagem funciona, mas sempre que houver um novo formulário, temos que criar a nova variável e fazer uma alteração do código ShowForm incluindo a janela na lista de variáveis a serem liberadas de memória. Em outras palavras, muito (re)trabalho.

Tutorial: Navegação entre formulários – Nova Técnica

Segundo as boas práticas, é altamente recomendável trabalhar para que possamos fazer a reutilização de código, assim ganhamos em velocidade de desenvolvimento e em clareza do fonte. Por isso nesse tutorial, especificamente nesse tópico, veremos como modificar nossa função anterior usando uma nova técnica.

A técnica consiste em unificar a forma de navegação entre os formulários, identificando qual o formulário que está atualmente em memória e então liberamos sua instância para o formulário alvo e mostrar em tela. Para isso, vamos criar um exemplo novo, simples.

Clique no menu File > New > Multi-Device Application – Delphi no Delphi 10 Seattle. Salve o formulário principal como UntPrincipal.pas e dê o Name de frmPrincipal. Insira um novo componente MuiltView e aumente a propriedade Width para 250 ou deixe-a no tamanho que desejar. Adicione e 3 (três) botões dentro do Multiview para simular nosso menu principal. Na Figura 1 você poderá ver um exemplo de menu. Nós apenas colocamos todos os botões com alinhamento ao Topo e com Styleloockup = buttonstyle.

Insira também um componente TLayout e dê o nome a ele de layPrincipal e mude sua propriedade Align para Client.

Figura 1. Exemplo de tela

Crie também 3 (três) novos formulários usando a opção File > New > Multi-Device Form – Delphi e escolha o template HD Form. Salve os formulário como UntClientes.pas, UntFornecedores.pas e UntProdutos.pas, respectivamente. Não esqueça de modificar a propriedade Name para frmClientes, frmFornecedores e frmProdutos. Adicione um TLayout nesse formulário, alinhe-o como Client e dê o nome de layBase. Por fim adicione alguns componentes dentro do layBase de cada form para simular que são telas diferentes do nosso sistema. Repita esses passos para todos os formulários. Insira uma ToolBar e nela um SpeedButton com o nome btnMenu. Nós vamos manter como padrão o nome do TLayout sempre como layBase. Para que possamos alternar entre um formulário e outro, assim podemos identificar ele em runtime e adicionar no form principal.

Feito isso, vamos a codificação.

Codificando

A ideia é semelhante a usada na primeira técnica, com a grande vantagem de programar apenas uma vez o método ShowForm (MostrarForm). Suba até a seção Private e crie uma variável chamada FActiveForm do tipo TForm e uma procedure como abaixo:

    FActiveForm: TForm;
    procedure AbreForm(aFormClass: TComponentClass);  

Se preferir, modifique o nome do método para MostrarForm ou qualquer outro nome que desejar. Pressione CTRL + SHIFT + C para criar o escopo do método na área Implementation. Codifique-o método como na Listagem 1.

procedure TfrmPrincipal.AbreForm(AFormClass: TComponentClass);
var
  LayoutBase, BotaoMenu: TComponent;
begin
  if Assigned(FActiveForm) then
  begin
    if FActiveForm.ClassType = AFormClass then
      exit
    else
    begin
      FActiveForm.DisposeOf;
      FActiveForm := nil;
    end;
  end;

  Application.CreateForm(AFormClass, FActiveForm);

  //Encontra o Layout Base no form a ser exibido para adicionar ao frmPrincipal
  LayoutBase := FActiveForm.FindComponent('layBase');
  if Assigned(LayoutBase) then
    layPrincipal.AddObject(TLayout(LayoutBase));

  //encontra o Botão de controle de Menu no form a ser exibido para
  //associá-lo ao MultiView do frmPrincipal
  BotaoMenu := FActiveForm.FindComponent('btnMenu');
  if Assigned(BotaoMenu) then
    MultiView1.MasterButton := TControl(BotaoMenu);
end;

Listagem 1. Código do método

A metodologia aqui empregada é bem diferente da anterior, nem por isso mais complexa. O que fazemos aqui é ainda mais simples. Primeiro verificamos se a variável FActiveForm está inicializada, ou seja, se há uma instância dela na memória, pois pode ser a primeira vez que abrimos uma janela. Se houver a instância, nós verificamos se o tipo da classe (ClassType) é igual a classe passada por parâmetro, ou seja, o formulário desejado pelo usuário para ser aberto. Se for ele mesmo, então saimos do método, pois não há necessidade de fazer nada. Se for diferente, então nós liberamos de memória para que possamos abrir novo formulário.

Nesse caso nós chamamos o método CreateForm para criar o formulário alvo em memória. Então nós localizamos em o Layout base (layBase) dentro do formulário alvo para que possamos incluir ele no layout principal. Para finalizarmos, nós localizamos o botão btnMenu no form alvo e usamos ele para alterar a propriedade MasterButton do MultiView.

Não esqueça que acessar o menu File > Use Unit e adicionar todos os formulários ao form principal, senão não conseguiremos abri-los. Agora para abrir cada formulário, basta ir ao evento OnClick do botão correspondente ao form que queremos abrir e digitar o código:

  AbreForm(TfrmClientes);

Repita isso para cada form. Perceba que nós inserimos como parâmetro, o classe do formulário TfrmClientes, TfrmFornecedores e TfrmProdutos. Desse modo, sempre que criarmos novas janelas em nosso aplicativo, não precisaremos mais nos preocupar com o método AbreForm. Salve o projeto e teste-o.

Conclusão

Esse tutorial renova nossa técnica para navegação entre formulários empregada anteriormente em outros tutoriais, o que nos ajuda a manter o nosso código sempre atualizado e performático. Essa técnica utilizada aqui foi empregada no RAD Studio 10 Seattle, mas pode facilmente ser utilizada em versões anteriores, ou seja, não está atrelada a versão do delphi. Esperamos que tenha sido válido esse tutorial e pedimos que Curta nosso link clicando nas redes sociais abaixo ou no início desse tutorial.

#GoToDelphi

A pedido de todos, segue link para download do código-fonte

https://bitbucket.org/tdevrocks/tutorial-navega-o-entre-formul-rios-nova-t-cnica