Bem, estou aqui pois a minha procura não foi bem sucedida e gostaria de uma ajuda. Estou iniciando os estudos na parte gráfica, criando janelas, botões e campos de texto. Não é nada avançado, não há ações ainda, somente o desenho dos componentes na tela. Gostaria de saber se há alguma regra, convenção específica ou padrão do prótotipo do layout que deve ser respeitada. Estou dando uma estudada na parte de gerenciamento de layout pois é altamente recomendado o uso dele, correto? Em questão a usabilidade, como posso projetar o layout para a melhoria dele?
Tbem estou interessado em saber se existe alguma convenção, geralmente uso Singletons para comunicaçoes entre as telas e o controle da aplicação.
Sobre Layout, fazer um é simples mas trabalhoso
O exemplo abaixo é um Layout q empilha os components(invertido) parecido com o FlowLayout mas na vertical
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;
public class LayoutPilha implements LayoutManager {
private int gap;
public LayoutPilha(int gap) {
this.gap = gap;
}
public LayoutPilha() {
this(0);
}
@Override
public void addLayoutComponent(String name, Component comp) {
}
@Override
public void removeLayoutComponent(Component comp) {
}
@Override
public Dimension preferredLayoutSize(Container parent) {
synchronized (parent.getTreeLock()) {
Insets i = parent.getInsets();
int w = 0;
int h = 0;
Component[] cs = parent.getComponents();
for (Component c : cs) {
w = Math.max(w, c.getPreferredSize().width);
h += c.getPreferredSize().height;
}
int v = gap * (cs.length - 1);
if (v < 0) v = 0;
w += i.left + i.right;
h += i.top + i.bottom + v;
return new Dimension(w, h);
}
}
@Override
public Dimension minimumLayoutSize(Container parent) {
synchronized (parent.getTreeLock()) {
Insets i = parent.getInsets();
int w = 0;
int h = 0;
Component[] cs = parent.getComponents();
for (Component c : cs) {
w = Math.max(w, c.getMinimumSize().width);
h += c.getMinimumSize().height;
}
int v = gap * (cs.length - 1);
if (v < 0) v = 0;
w += i.left + i.right;
h += i.top + i.bottom + v;
return new Dimension(w, h);
}
}
@Override
public void layoutContainer(Container parent) {
synchronized (parent.getTreeLock()) {
Insets i = parent.getInsets();
int w = parent.getWidth() - i.left - i.right;
int h = parent.getHeight() - i.top - i.bottom;
int x = i.left;
int y = i.top;
Component[] cs = parent.getComponents();
for (Component c : cs) {
if (y < h) {
c.setBounds(x, y, w, c.getPreferredSize().height);
c.setVisible(true);
y += c.getPreferredSize().height;
y += gap;
} else {
c.setVisible(false);
}
}
}
}
}
o “layoutContainer” é q organiza e posiciona os components
Insets seria a borda do Container
sim existem algumas regras que são RECOMENDADAS para que a interface possa ser usual, intuitiva, ágil etc. Procure pelo assunto interface-homem maquina.
Há muitas regras para sistemas web, já sistemas desktop é bem mais tranquilo.
ChronosSage,
já estou estudando sobre os gerenciadores de layout.
hvivox,
Sim, para web existem várias regras porém para desktop eu desconheço. O que você quis dizer com "é bem mais tranquilo. "? Que não é preciso se preocupar com isso?
ViniGodoy,
Obrigado pelo link, era um material desta forma que eu estava procurando.
Agora vai algumas perguntas, se puderem me ajudar a entender melhor…
Há como exibir uma janela sem utilizar o método setVisible ?
Quer dizer que se eu precisar chamar uma nova janela, eu devo enviar os dados através de um construtor? Seria essa a única opção?
Ao utilizar gerenciador de layout, eu escolho ser o mais apropriado para minha aplicação ou um layout A serve somente para uma aplicação do tipo A?
Existe o método show(), mas está deprecated. Portanto, o meio oficial é só o serVisible mesmo. Para que você queria outro método?
Não, é a geralmente a melhor opção.
Outras opções são através de métodos setters, ou fazer com que sua janela escute eventos de outras.
E claro, há sempre a opção gambi de variáveis estáticas, mas essa gera tantos problemas que não deveria nem ser considerada (embora seja relativamente popular nos códigos dos iniciantes do GUJ).
Na verdade, você usa uma combinação de gerenciadores de layout para chegar na tela desejada.
Por exemplo, você pode começar com um BorderLayout para dividir a tela nas 5 áreas. Na área sul você coloca um painel com FlowLayout para conter botões (salvar, fechar, etc). Na área CENTER você coloca um GridBagLayout, para conter alguns componentes. E na área EAST você poderia colocar um GridLayout com uma JTree e um JTable de propriedades.
Usar paineis sobre paineis, cada um com seu próprio layout manager é uma maneira bastante efetiva de se conseguir o layout final desejado. Mas não crie layouts que dependam de posições exatas de componentes, pixel-a-pixel. Isso não só não é portável, como será muito difícil de fazer, e dificilmente tornará as janelas redimensionáveis.
Sobre a alternativa ao setVisible, é só para conhecimento mesmo, sempre procuro as várias formas que posso fazer algo.
Então irei testar com construtores já que é a melhor opção, detesto código feio e POG.
E acho que já comecei interpretando o gerenciamento de layout de forma errônea ou incompleta, achei que para cada janela só poderia ser utilizado um. Então eu posso utilizar vários tipos para cada painel que eu utilizar, vamos dizer.
Obrigado pelo esclarecimento das minhas dúvidas. Caso alguém tenha algo para complementar o tópico, fique a vontade, irei colocar como resolvido.