Aplicativo com várias telas [SWING]

Programação Java
#1

Tudo bem pessoal ?!

Gostaria que vocês me tirassem uma dúvida.

Sou iniciante na linguagem Java, tenho uma boa noção de orientação a objetos e agora estou querendo praticar um pouco do conhecimento que adquiri lendo livros, tutoriais e etc.
Quando tentei desenvolver um pequeno projeto (apenas para praticar) cai em um problema que até agora não vejo solução, colocarei um exemplo para ilustar:

Considere um aplicativo no qual a primeira janela é um JFrame pedindo um login e senha, quando o usuário digita o login e senha corretamente, o sistema redireciona ele para uma outra tela, na qual existem vários botões, cada um levando para uma janela diferente.

O negócio é: Como eu posso estruturar essas janelas ?
Dei uma pesquisada e a principio eu achei que o que eu queria/precisava fazer era um MDI com um JFrame principal, que tem dentro dele um JDesktopPane e dentro do JDesktopPane eu poderia ficar jogando um JInternalFrame que tivesse a tela que precisasse ser exibida, removendo-a quando necessário.

Com isso em mente eu comecei a desenvolver, só que percebi que a estética não estava indo muito bem, os internalframes criam uma barra de ferramenta padrão com as opções de maximizar, fechar, minimizar e etc. Ele basicamente cria uma janela dentro da janela principal, e o que eu quero fazer é manter uma janela principal com os componentes dentro dela sendo “atualizados”, só que eu não sei uma boa forma de fazer isso, ou se quer se isso é aconselhável.

A “melhor” forma que eu encontrei até agora foi a de manter uma tela (JFrame) principal e toda vez que eu chamasse outra tela eu usasse códigos como esse para fazer o serviço:

setContentPane(new TelaPrincipal().getContentPane()); javax.swing.SwingUtilities.updateComponentTreeUI(getContentPane());
Ela faz o que eu quero, mas até um iniciante como eu consegue perceber que não é a maneira correta de se fazer isso.

Alguém pode me dar uma luz ?
Basta apenas dizer como eu posso estruturar essas janelas de acordo com o que eu expliquei, caso eu não tenha sido claro em alguma parte me digam que eu tentarei explicar de uma forma diferente.

No aguardo, abraços! :slight_smile:

EDIT -> Já vi que comecei mal, criando um tópico na aba errada, hehe. Algum moderador faça o favor de mudá-lo para a aba que fala a respeito de interfaces gráficas.

#2

o que você quer é alterar alguma coisa em uma janela e automaticamente em outra janela se autere tb caso tiver relacionamento com o que está sendo alterado na primeira janela?

#3

Não, eu quero saber qual o modo mais comum de estruturar um software com várias janelas, sendo elas abertas toda vez que uma opção for escolhida e não simultaneamente.

Dei até um exemplo sobre o JFrame->JDesktopFrame->JInternalFrame, mas acho que esse não é o modo mais correto para fazer o que eu quero, seria caso eu precisasse de mais de uma janela aberta dentro da janela principal (eu acho), e o que eu quero é que toda vez que uma janela seja aberta ela se torne a principal.

#4

quando você solicita uma janela, essa é a janela ativa, a janela principal de uma aplicação provavelmente é sempre a primeira(ou quase), pois nela é que te leva para qualquer outro caminho.
o que eu estou entendendo é que ao abrir uma janela, não consiga mexer em outra até que essa seja fechada, se for isso, a sua janela que for chamada deve estender JDialog e não JFrame.

#5

Não é isso também.

Eu apenas quero saber um modo de trabalhar com interfaces gráficas da forma que eu expliquei logo acima: Quando um usuário clicar em um botão “cadastrar”, a tela de cadastro surgirá no mesmo lugar que a tela anterior (a qual tinha o botão cadastrar e outras coisas) estava.
Eu não quero que abra uma segunda janela, quero ela no lugar onde a antiga estava.

#6

hummmm… a janela principal continua sendo a mesma pois ela não evapora…rsrs ela continua existindo mas você não a vê.
o que tem a fazer é simples poooo, quando exibir uma janela solicitada, “esconder” a anterior até que essa última se feche.
particularmente acho desnecessário, se você criar janelas modais, a janela anterior fica visível mas não fica acessível.
para fazer isso acho que você vai ter que sempre passar por parâmetro cada janela para a janela seguinte, para essa janela aberta saber a hora de reexibir a janela anterior que está fechada, ou melhor, escondida, por que se você a fechar perde o que tem lá(se tiver dados visíveis) e além disso uma vez fechada você pode se perder como num labirinto, para isso não acontecer você provavelmente vai gastar memória, que acho também desnecessário, ok a memória está barata e abundante, mas isso não quer dizer que vai relaxar e fazer tudo de qualquer jeito.

#7

Oi,

Vou tentar responder… :roll:

JFrame Login


 new Principal().setVisible(true);//Abrira tela principal
 dispose();//fecha tela de login

JFrame Principal

   // Botão da tela principal,que chama tela cliente
    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
     new clientes().setVisible(true);//abre tela cliente
     dispose();//fecha tela principal
    }

Não sei se é essa sua duvida…

#8

[quote=daquinho]hummmm… a janela principal continua sendo a mesma pois ela não evapora…rsrs ela continua existindo mas você não a vê.
o que tem a fazer é simples poooo, quando exibir uma janela solicitada, “esconder” a anterior até que essa última se feche.
particularmente acho desnecessário, se você criar janelas modais, a janela anterior fica visível mas não fica acessível.
para fazer isso acho que você vai ter que sempre passar por parâmetro cada janela para a janela seguinte, para essa janela aberta saber a hora de reexibir a janela anterior que está fechada, ou melhor, escondida, por que se você a fechar perde o que tem lá(se tiver dados visíveis) e além disso uma vez fechada você pode se perder como num labirinto, para isso não acontecer você provavelmente vai gastar memória, que acho também desnecessário, ok a memória está barata e abundante, mas isso não quer dizer que vai relaxar e fazer tudo de qualquer jeito.[/quote]

Oi,

Que confusão… :stuck_out_tongue:

#9

é né…
se é para deixar sempre visível uma janela apenas, acredito que vá ter que passar sempre por parâmetro as referências de sua janela, isso é para que a janela ativa, saiba a hora de exibir a janela anterior.
provavelmente o modo como estava fazendo também pode fazer isso, uma maneira ou de outra é questão de gosto, a não ser que influencie muito na hora de usar.

#10

Anime, esse método de fechar a janela atual e abrir uma outra quando necessário não é o que eu vejo nas aplicações que já usei.
Usando esse método da para o usuário perceber claramente que a janela está sendo fechada e uma outra sendo aberta, e o que eu mais vejo em aplicações é apenas o conteúdo da janela sendo mudado de acordo com o que é necessário, e não a janela em si sendo fechada e uma outra sendo aberta.

E daí vem a minha dúvida principal: Como fazer isso ?

#11

acho que ainda estou boiando.
o que você quer é que o usuário perceba que uma janela se fecha e outra se abre em seu lugar?

#12

[quote=daquinho]acho que ainda estou boiando.
o que você quer é que o usuário perceba que uma janela se fecha e outra se abre em seu lugar?[/quote]

Acho que ele não quer que perceba…está dificil entender rsrs… :roll: :roll:

Pelo que eu entendi,então não são 2 formulários ou mais.É um?

Só se for usando JPanel…

Ficaria mais ou menos assim:


 JP_op.setVisible(false);


 private void button1ActionPerformed(java.awt.event.ActionEvent evt) {
     JP_op.setVisible(true);
    }

Mas tem que trabalhar a lógica,acho que seria necessário uma variavel de controle.

E ai,cheguei perto… :stuck_out_tongue:

#13

[quote=Anime]Acho que ele não quer que perceba…está dificil entender rsrs…
[/quote]sim, está.

po… foi mal,
seria como num wizard de instalação? a mesma janela mudando apenas o conteúdo, de acordo com o que seleciona?
cara… tu vai ter trabalho dependendo do tamanho de sua aplicação, vai ficar um bom tempo preso em layout.
se você conhece os componentes visuais, principalmente JPanel, você vai ter que trabalhar muito nas lógicas para exibir e esconder os componentes.
se as mudanças que pretende fazer simular apenas trocas de janelas, pode criar JPanels como se fosse cada janela e exibir e esconder esses JPanels, assim fica bem simples.

#14

Que bagunça…rsrs… :stuck_out_tongue:

Agora sim… :wink:

#15

po, acho que escrevi confuso novamente?
não é fácil, vocês mesmo não entendeu de primeira.
rsrs

#16

[quote=daquinho]po, acho que escrevi confuso novamente?
[/quote]

Agora ficou bom…

#17

Sim, seria algo parecido com um Wizard de instalação.
Um outro exemplo seria um site web, onde de acordo com os links que você vai clicando, janelas vão sendo carregadas na tela sem a necessidade de fechar o browser e abrir um outro com o link desejado.

O único jeito de fazer isso é através dos JPanel mesmo ?
E esse modo de criar interfaces gráficas não é o melhor ou ao menos o mais comum não ? Sempre achei que fosse assim que as coisas eram estruturadas, por isso resolvi seguir esse caminho, caso não seja eu mudarei.

#18

de qualquer forma que quiser está correto, mas se quiser saber a forma mais comum, acredito ser usando JFrame com JDialog e em seguida JInternalFrame. Essa forma que indicou querer é muito comum em wizards, mas não impede que você faça uso desses recursos, eu mesmo se não me engano já vi uma aplicação assim, mas pode ter certeza que vai gastar um bom tempo só na lógica na tela.

#19