Curso Java - Básico - Swing

Introdução

  • Conjunto de componentes
    • Assim como o AWT, Swing é um conjunto de componentes usados para a criação de aplicativos gráficos usando a tecnologia Java.
  • 100% Java
    • Os componentes têm a mesma aparência e o mesmo comportamento em qualquer plataforma.
    • Flexibilidade para implementar qualquer componente, mesmo que não exista um componente análogo na plataforma-alvo.
    • A grande diferença entre componentes AWT e Swing, é que Swing são implementados com nenhum código nativo.
  • Flexibilidade
    • Os componentes não estão restritos a somente às características presentes em todas as plataformas e podem implementar mais facilidades do que os componentes AWT possuem.

Arquitetura MVC

  • Modelo
  • Vista
  • Controle

    ./images/MVC.jpg

JComponent

  • Superclasse dos componentes Swing.
  • Oferece, automaticamente, suporte a
    • Tooltips
      • setToolTipText(String text)
    • LayoutManagers
      • setMinimumSize(Dimension minimumSize);
      • setMaximumSize(Dimension maximumSize);
      • setPreferredSize(Dimension preferredSize).

JFrameJWindow

  • JFrame é o principal container de uma aplicação baseada em Swing.
  • JWindow é usada geralmente como Splash Screen ou janela pop-up.

    ./images/JFrameJWindow.jpg

RootPaneContainer & JRootPane (1)

  • Único componente presente em JFrame e Jwindow.
  • Oferece suporte à Barra de Menus e Menus Pop-up.
  • Os componentes de uma JFrame (ou JWindow) devem estar contidos no Content Pane
    • getContentPane()
    • setContentPane().

JPanel (1)

  • Container genérico.
  • Útil para agrupar e posicionar outros componentes.
  • Exibe um texto e/ou um ícone.
  • Usado para identificar outros componentes

    ./images/JLabel.jpg

JPanel (2)

  • Exemplo

    ./images/ExJPanel.jpg

JLabel (2)

  • Construtores
    • JLabel()
    • JLabel(Icon image)
    • JLabel(Icon image, int horizontalAlignment)
    • JLabel(String text)
    • JLabel(String text, Icon icon, int horizontalAlignment)
    • JLabel(String text, int horizontalAlignment)
  • Conteúdo
    • Texto e/ou imagem.
    • Opcionalmente, mais uma imagem disabled.
    • Especificado no construtor (texto e/ou apenas uma imagem)
    • Alterado através dos métodos
      • setText(String text)
      • setIcon(Icon icon)
      • setDisabledIcon(Icon icon)

JLabel (3)

  • Alinhamento
    • Alinhamento do conteúdo como um todo dentro da área do Jlabel.
    • Determinado no construtor.
    • Alterado usando os métodos
      • setHorizontalAlignment
      • setVerticalAlignment.
    • Constantes de alinhamento definidas em SwingConstants
      • LEFT
      • TOP
      • CENTER
      • RIGHT
      • BOTTOM

JLabel (4)

  • Alinhamento

    ./images/Alinhamento.jpg

JLabel (5)

  • Posicionamento
    • Posicionamento do texto em relação à imagem.
    • Determinado pelos métodos
      • setHorizontalTextPosition
      • setVerticalTextPosition
    • Espaço entre o texto e a imagem
      • setIconTextGap
    • Constantes de posicionamento definidas em SwingConstants
      • LEFT
      • TOP
      • CENTER
      • RIGHT
      • BOTTOM

JLabel (6)

  • Posicionamento

    ./images/Posicionamento.jpg

JLabel (7)

  • Propriedades de Acesso
    • JLabel nunca tem o foco do teclado.
    • Mnemônico associado ao JLabel deve desviar o foco para o componente rotulado pelo Jlabel.
    • Componente rotulado pelo JLabel
      • setLabelFor(Component c)
    • Caractere mnemônico
      • setDisplayedMnemonic(char a)

JLabel (8)

  • Exemplo

    ./images/ExJLabel.jpg

JButton (1)

  • Construtores
    • JButton()
    • JButton(Action a)
    • JButton(Icon icon)
    • JButton(String text)
    • JButton(String text, Icon icon)

    ./images/JButton.jpg

JButton (2)

  • Exemplo

    ./images/ExJButton.jpg

JToggleButton (1)

  • Botão que alterna de estado entre selecionado e não-selecionado

    ./images/JToggleButton.jpg

ButtonGroup (1)

  • Conjunto de JToggleButtons onde apenas um deles estará selecionado a cada momento.
  • Para gerenciar quais JToggleButtons pertencem a um ButtonGroup usamos os métodos
    • add(AbstractButton b)
    • remove(AbstractButton b)
  • Para descobrir qual botão está selecionado dentro do grupo usamos o método
    • getSelection()

ButtonGroup (2)

  • Exemplo

    ./images/ExButtonGroup.jpg

JCheckBox & JRadioButton (1)

  • Outras implementações de JToggleButton.
  • Diferem apenas na aparência.

    ./images/JCheckBoxJRadioButton.jpg

Componentes de Texto

  • javax.swing.text.JTextField
  • javax.swing.text.JPasswordField
  • javax.swing.JTextArea

JTextField (1)

  • É um componente de texto de linha única.
  • A propriedade horizontalAligment especifica o alinhamento do texto. Os métodos associados são
    • setHorizontalAligment()
    • getHorizontalAligment()
  • Os possíveis valores são:
    • JTextField.LEFT
    • JTextField.CENTER
    • JTextField.RIGHT

JTextField (2)

  • O número de colunas corresponde ao número de caracteres do texto. Isto pode ser especificado no construtor, ou pode ser manipulado através dos métodos:
    • setColumns()
    • getColumns()

    ./images/JTextField.jpg

JTextField (3)

  • Exemplo

    ./images/ExJTextField.jpg

JPasswordField (1)

  • É uma simples extensão de JTextField.
    • Exibe um determinado caracter ao invés do conteúdo armazenado no modelo.
    • Esse caracter default é '*', mas pode ser especificado um outro caracter através do método setEchoChar().
  • O conteúdo do JPasswordField não é acessado pelo método getText(), ao invés disso deve ser usado o método getPassword().
  • JPasswordField redefine os métodos:
    • copy()
    • cut()
  • Esses métodos não fazem nada, apenas emitem um beep.

    ./images/JPasswordField.jpg

JTextArea (1)

  • Permite várias linhas de texto.
  • Este componente não suporta várias fontes ou várias cores, mas permite quebra de linha.
    • A property lineWrap habilita ou desabilita a quebra de linha.
    • A property wrapStyleWord especifica se a linha quebra no limite da palavra ou não, quando a quebra de linha está habilitada.
  • O texto pode ser passado num dos construtores, ou um os seguintes métodos podem ser usados:
    • append() - o texto é adicionado ao final do documento
    • insert() - insere uma string
    • replaceRange() - substitui uma parte do texto
    • setText() - o texto pode ser adicionado ou removido diretamente de seu Document

JTextArea (2)

  • JTextArea redefine isManagingFocus(), que retorna sempre true.
  • O FocusManager não irá transferir o foco para fora do JTextArea quando a tecla TAB for pressionada. Neste caso, um TAB será inserido no documento.
  • A propriedade rows indica quantas linhas estão sendo mostradas. Seu valor muda toda vez que o JTextArea é redimensionado.
  • A propriedade lineCount especifica quantas linhas o texto do documento contém.

    ./images/JTextArea.jpg

JTextArea (3)

  • Exemplo

    ./images/ExJTextArea.jpg

JDialog (1)

  • javax.swing.JDialog
  • Esta classe estende java.awt.Dialog e é usada para criar uma caixa de diálogo numa janela em separado.
  • A caixa de diálogo pode ser modal ou não.
    • Uma caixa de diálogo modal não permite que outras janelas fiquem ativas enquanto ela estiver ativa.
  • Para criar uma JDialog devem ser especificados o seu dono (instância de Frame ou Dialog), um título, e um estado modal/não-modal.

    ./images/JDialog.jpg

JDialog (2)

  • Exemplo

    ./images/ExJDialog.jpg

JMenuBar

  • É um container para objetos JMenu, dispostos horizontalmente no topo de uma janela.
  • O método add(JMenu) é usado para adicionar um objeto JMenu a uma JMenuBar.
  • O método setJMenuBar(JMenuBar) das classes JFrame, JDialog, JApplet e JRootPane atribui uma JMenuBar à janela.
  • JMenuBar usa um DefaultSingleSelectionModel para forçar a seleção de um único item a cada momento.
  • Uma vez que JMenuBar também é um JComponent, pode ser colocada em qualquer outro container.

JMenuItem

  • JMenuItem estende AbstractButton.
  • Representa um único item dentro de um menu.
  • Assim como fazemos com botões tradicionais, podemos atribuir um ícone e um caracter mnemônico a um JMenuItem.
  • Como com qualquer outro JComponent, podemos associar uma tecla de atalho a um JMenuItem.
  • No item de menu a tecla de atalho aparece como um pequeno texto à direita do item.
  • JMenuItem pode ser criado das mesmas formas que JButton.
  • Além disso, JMenuItem acrescenta ainda outro construtor, não disponível para JButtons:
    • JMenuItem(String text, int mnemonic) - Cria um JMenuItem com uma String e um caracter mnemônico.
  • ActionListeners podem ser adicionados a um item de menu, para serem notificados de qualquer clique do usuário.

JMenu (1)

  • Esta classe estende JMenuItem.
  • É um container para JMenuItem's.
  • Um JMenu é normalmente adicionado a uma JMenuBar ou adicionado a outro JMenu.
  • Em ambos os casos, JMenu aparece na forma de um item de menu que, ao ser selecionado, abre um outro menu em cascata.
  • A classe JMenu especificamente sobrescreve o método setAccelerator() (herdado de JComponent) com uma implementação vazia, para impedir que teclas de atalho sejam associadas a um JMenu.

JMenu (2)

  • Os construtores disponíveis para JMenu são:
    • JMenu() - Cria um JMenu sem rótulo.
    • JMenu(Action a) - Cria um JMenu a partir de uma Action.
    • JMenu(String s) - Cria um JMenu a partir de uma String.

    ./images/JMenu.jpg

JMenu (3)

  • Internamente, o JMenu mantém uma instância de JPopupMenu para exibir o menu em cascata.
  • O método getPopupMenu() pode ser usado para acessar esse objeto.
  • JMenu redefine o método add() para adicionar JMenuItem's, Component's, Action's ou String's.
  • Quando uma string é adicionada, é criado um JMenuItem, que tem essa string como texto.
  • O método addSeparator() provê uma forma conveniente de organizar visualmente os itens do menu.

JMenu (5)

  • Exemplo

    ./images/ExJMenu.jpg

JPopupMenu (1)

  • Esta classe representa uma janela que pode aparecer em qualquer lugar da tela e contém uma coleção de componentes dispostos em uma única coluna.
  • JPopupMenu usa um DefaultSingleSelectionModel para forçar a seleção de um único elemento a cada momento.
  • O método show() pode ser usado para exibir um JPopupMenu em algum lugar da área de um componente (é o invoker do menu popup).
  • Um JPopupMenu dispara PopupMenuEvents que podem ser capturados por PopupMenuListeners.

JCheckBoxMenuItem e JRadioButtonMenuItem

  • A classe JCheckBoxMenuItem estende JMenuItem.
  • Pode ser marcada e desmarcada.
  • Sua representação visual é idêntica a JCheckBox.
  • A classe JRadioButtonMenuItem também estende JMenuItem.
  • É análoga a JCheckBoxMenuItem, com representação visual idêntica a JRadioButton.

JToolBar (1)

  • A classe JToolBar é a implementação de uma barra de ferramentas em Swing.
  • Barras de ferramentas normalmente são colocadas diretamente abaixo de barras de menu, no topo de uma janela.
  • A JToolBar funciona como um container para qualquer componente, sendo botões e combo boxes os mais comuns.
  • A forma mais conveniente de inserir botões numa JToolBar é usando Actions.
  • Duas orientações são suportadas: VERTICAL e HORIZONTAL.
  • A JToolBar também permite a inserção de separadores entre grupos de botões. Estes separadores podem ser inseridos com os métodos addSeparator() e addSeparator(Dimension), este último recebendo um Dimension especificando o tamanho do separador.

JToolBar (2)

  • A JToolBar pode ser arrastada para dentro e para fora de seu container pai, se sua propriedade floatable for true.

    ./images/JToolBar.jpg

JToolBar (3)

  • Exemplo

    ./images/ExJToolBar.jpg

JList (1)

  • javax.swing.JList
  • Representa o componente básico que permite a seleção de um ou mais itens de uma lista de elementos.
  • Possui dois modelos:
    • ListModel - trata dos dados da lista
    • ListSelectionModel - trata da seleção

JList (2)

  • O acesso aos elementos da JList deve ser feito através do ListModel, assim como o acesso aos elementos selecionados deve ser feito através do ListSelectionModel.
  • Existem vários construtores disponíveis para a criação de uma JList:
    • JList() - Constrói uma JList com um modelo vazio.
    • JList(ListModel dataModel) - A lista de elementos é passada na forma de um ListModel.
    • JList(Object[] listData) - A lista de elementos é passada na forma de um array unidimensional
    • JList(Vector listData) - A lista de elementos é passada na forma de um Vector.

    ./images/JList.jpg

JList (3)

  • Os dados podem ser atribuídos através dos métodos:
    • setModel(model) - os dados são passados na forma de um ListModel
    • setListData(listData) - os dados são passados na forma de um array ou de um Vector
  • JList implementa a interface Scrollable para suportar a rolagem de seu conteúdo.
  • A propriedade visibleRowCount especifica quantas células devem estar visíveis quando a JList é colocada no scroll pane.
  • O valor default é 8, que pode ser modificado pelo método setVisibleRowCount().

JList (4)

  • Exemplo

    ./images/ExJList.jpg

JComboBox (1)

  • A interface gráfica do JComboBox é composta de duas partes:
  • Um menu popup (uma implementação de javax.swing.plaf.basic.ComboPopup). Por default, é uma subclasse de JPopupMenu (javax.swing.plaf.basic.BasicComboPopup) que contém uma JList e um JScrollPane;
  • Um botão que atua como um container para um componente e uma seta. O componente pode ser tanto um editor que permite mudanças no item selecionado, ou um componente que representa graficamente o item selecionado. A seta é um botão usado para mostrar o menu popup.
  • A JList permite apenas seleção única. Além disso, JComboBox usa um único modelo, um ComboBoxModel, que gerencia o conteúdo da JList.

JComboBox (2)

  • Existem vários construtores disponíveis para a criação de uma JComboBox:
    • JComboBox() - Constrói uma JComboBox com um modelo vazio.
    • JComboBox (ComboBoxModel aModel) - A lista de elementos é passada na forma de um ComboBoxModel.
    • JComboBox (Object[] listData) - A lista de elementos é passada na forma de um array unidimensional
    • JComboBox (Vector listData) – A lista de elementos é passada na forma de um Vector.
  • Assim como outros componentes complexos do swing, JComboBox permite a customização de um renderizador para cada um dos itens de sua lista (por default, é uma subclasse de JLabel, que implementa a interface ListCellRenderer), além da customização do editor usado para entrada de dados da combo box (por default, é uma instância de ComboBoxEditor, que usa um JTextField).
  • Assim como a JList, esta classe usa ListDataEvents para avisar sobre mudanças ocorridas no estado do modelo da lista. ItemEvents e ActionEvents são disparados quando a seleção corrente da lista muda. Logo, podem ser registrados ItemListeners e ActionListeners na JComboBox.
    • A exibição do menu popup pode ser programada através dos métodos showPopup() e hidePopup().

JComboBox (3)

  • Por default, a JComboBox não é editável. Quando ela é editável, o editor será exibido como um JTextField recebendo a entrada.
  • A JComboBox pode tornar-se editável através do método setEditable(). E o ComboBoxEditor pode ser especificado através do método setEditor().
  • Quando a propriedade editable recebe o valor true, o componente, que representa graficamente o item selecionado, é substituído por um editor. Assim como, quando a propriedade recebe o valor false, o editor é substituído pelo componente responsável pela representação visual.
  • O componente responsável pela representação visual do item selecionado pode ser acessado pelos métodos setRenderer() e getRenderer().

    ./images/JComboBox.jpg

JComboBox (4)

  • Exemplo

    ./images/ExJComboBox.jpg

Introdução (1)

  • Layout Managers
    • Classes que determinam a posição dos componentes dentro de um container.
  • Implementam a interface LayoutManager.
  • Layout para um container é estabelecido por
    • setLayout(LayoutManager)

Introdução (2)

  • AWT inclui os seguintes tipos de layout:
    • FlowLayout
    • BorderLayout
    • CardLayout
    • GridLayout
    • GridBagLayout
  • Programadores podem criar seus próprios gerentes de layout.

Como funciona

  • A cada componente que é inserido em um container, o gerente de layout recalcula a posição de cada componente.
  • Quando a janela é redimensionada, o gerente mais uma vez se encarrega de arrumar os componentes.

FlowLayout (1)

  • É o gerente de layout padrão do painel.
  • Os componentes são arrumados da esquerda para direita na ordem em que são adicionados ao container
  • Se um componente não cabe na linha, é colocado na próxima.
  • Quando o container é redimensionado, os componentes que estão nele são reposicionados de acordo com o novo tamanho. Se há espaço suficiente, o FlowLayout utiliza o tamanho definido em getPreferredSize(), senão não vemos os componentes por inteiro.
  • Podemos ainda definir o alinhamento do layout pelas constantes: LEFT, CENTER, RIGHT. O padrão é o alinhamento centralizado.

FlowLayout (3)

  • Exemplo

    ./images/ExFlowLayout.jpg

BorderLayout (1)

  • É o gerente de layout padrão do Frame.
  • Possibilita arrumar os componentes ao longo das margens da janela.
  • Administra a disposição de componentes em cinco regiões distintas:
    • "North" , "South", "East", "West" ou "Center"
  • Ao adicionar um componente, é preciso indicar sua posição
    • add(novoComponente, BordeLayout.CENTER)
    • add("Center", novoComponente)
  • A posição do centro tende a tomar todo o espaço.

BorderLayout (2)

  • Cada região pode só pode ser ocupada por um componente.
  • Se vários componentes forem adicionados na mesma região, o layout manager só mostrará o último que foi adicionado.
  • Ao ser adicionado, o componente é redimensionado de forma ocupar toda a região onde foi inserido.
  • Não é necessário utilizar todas as regiões.
  • Para conseguirmos o efeito de vários componentes na mesma região, arrumamos esses componentes num painel, e então adicionamos o painel nessa região.

CardLayout (1)

  • Enquanto outros layout managers mostram todos os componentes de uma só vez na tela, o CardLayout exibe um de cada vez.
  • Produz uma espécie de visualizador de slides dos componentes.
  • Somente um componente ("slide") é visualizado de cada vez.
  • Geralmente usado com painéis.
  • A ordem dos componentes segue a ordem de inserção dos mesmos no container.
  • Geralmente mantemos a referência para o layout criado para utilizar nos métodos de navegação.

CardLayout (2)

  • Navegação
    • Seguindo a ordem de inserção, a classe permite a navegação através dos métodos:
      • first(Container)
      • previous(Container)
      • next(Container)
      • last(Container)
  • Acesso a um dado slide
    • É possível especificar um nome ao slide quando adicionado ao container
    • A partir desse nome, o CardLayout pode mostrar o slide
      • show(Container,String)

CardLayout (4)

  • Exemplo

    ./images/ExCardLayout.jpg

GridLayout (1)

  • Oferece mais controle sobre a localização dos componentes dentro de um painel.
  • Particiona a área do painel em linhas e colunas. Todas as células tem o mesmo tamanho.
  • Cada componente adicionado é colocado em uma célula, iniciando na linha superior, linha a linha, da esquerda para direita.
  • Os componentes são expandidos de forma a ocupar todo o espaço da célula

GridLayout (3)

  • Definir o número de colunas ou o número de linhas igual a zero quer dizer que o layout irá crescer naquela direção, sem limite. Mas não podemos ter nunca os dois igual a zero ao mesmo tempo, isso gera uma exceção.
  • Os valores para linhas e colunas fornecidos no construtor são apenas os recomendados. O sistema poderá modificar esses valores caso sejam adicionados um número de componentes diferente do número de elementos do grid.

GridLayout (4)

  • Exemplo

    ./images/ExGridLayout.jpg

GridBagLayout, GridBagConstraints (1)

  • De todos os gerentes de layout este é o mais flexível, porém o mais complexo.
  • O GridBagLayout, assim como GridLayout, é do tipo grade.
  • Os componentes podem ter tamanhos diferentes e ocupar múltiplas linhas e colunas.
  • Pode-se juntar células adjacentes para dar espaço para componentes maiores.
  • Os componentes não precisam ocupar todo espaço da célula.
  • A posição de cada elemento é especificado pelo objeto GridBagConstraints.

GridBagLayout, GridBagConstraints (2)

  • Como utilizar...
    • Criar um GridBagLayout. Não se diz quantas colunas ou linhas o container vai mostar. O gerente se encarrega de extrair essas informações mais tarde
    • Registrar esse gerente no container
    • Criar um GridBagConstraints. Esse objeto irá especificar com o componente irá ser visualizado no container
    • Para cada componente, ajustar o GridBagConstraints. Adicionar o componente com o objeto de constraints
      • add(component, constraints)

GridBagLayout, GridBagConstraints (4)

  • fill - usado quando a área de exposição do componente é maior do que o tamanho pedido do componente.
    • NONE
    • HORIZONTAL
    • VERTICAL
    • BOTH
  • anchor - usado quando o componente é menor do que sua área de exposição.
    • CENTER
    • NORTH
    • NORTHEAST
    • EAST,...
  • Se o componente for adicionado sem restrição, este layout o posiciona numa linha no centro da tela, e dimensiona pelo método getPreferredSize(). Isso permite que você possa ter um componente no meio da tela, sem ser alargado, como faz o BorderLayout.

Combinando layouts (1)

  • Com uma combinação de gerentes de layout simples, é possível obter grande flexibilidade na construção de interfaces gráficas.
  • Podemos definir layouts independentes para cada painel da interface.
  • Os painéis aninhados formam uma hierarquia, desde o painel mais externo até o componente mais interno.
  • Eventos são recebidos pelo componente mais interno e passado para a raiz.

Desabilitando Gerente de Layout (1)

  • Para criar um container sem layout manager use null no argumento do método setLayout().
  • Na maioria das vezes não e uma boa idéia desabilitar o layout manager, pois o que aparece muito bonito em uma plataforma, pode aparece um desastre em outra.
  • Para mostrar os componentes num container sem layout, devemos especificar sua posição e tamanho.
nÒ