Componentes gráficas

• Passeio pela documentação sobre componentes gráficas
• Tratamento de eventos
• Gerenciadores de disposição

• Passeio pela documentação

  A seguir listamos as componentes gráficas mais usuais encontradas no pacote java.awt. Limitamo-nos alguns poucos comentários, em especial a respeito dos eventos gerados por estas componentes, cujo tratamento será detalhado na seção seguinte.

  • Component
    Uma classe abstrata, superclasse de todas as componentes gráficas.
  • Container
    Uma classe abstrata, definindo propriedades gerais de componentes que podem conter outras componentes.
  • Panel
    O tipo o mais simples de Container. Vale notar que a classe Applet é subclasse de Panel.
  • Canvas
    Uma classe utilizada como fundo para pintar. O método paint deve ser sobre-escrito para realizar a pintura desejada.
  • Label
    Um rôtulo, i.e. uma linha de texto que fornece informação ao usuário. O texto pode ser modificado pelo programa mas não pelo usuário diretamente.
  • Button
    Um botão simples. A ação normalmente realizada pelo usuário é clicar, o que gera um evento do tipo ActionEvent. O objeto encarregado de tratar este evento (i.e. fazer o que o programador deseja que seja feito caso o usuário clicar o botão) deve implementar a interface ActionListener. O método addActionListener do botão deve ser chamado para registrar este objeto como "ouvidor de eventos" do botão. A referência ao ouvidor em questão é passada com argumento do método.
  • TextComponent
    Esta é a superclasse das classes destinadas a tratar texto (veja o dois itens seguintes). Se o texto for editável, a digitação ou alteração do mesmo gera eventos do tipo TextEvent. O objeto encarregado de tratar estes eventos deve implementar a interface TextListener. O método addTextListener da componente de texto deve ser chamado para registrar este objeto como "ouvidor de eventos" da componente. A referência ao ouvidor em questão é passada com argumento do método.
  • TextField
    Subclasse de TextComponent definindo um campo de texto, i.e. uma única linha de texto editável. Além dos eventos do tipo TextEvent discutidos acima, um campo de texto pode também gerar eventos do tipo ActionEvent, por exemplo quando aperta-se a tecla Enter. Tais eventos são tratados seguindo o modelo descrito para o botão.
  • TextArea
    Subclasse de TextComponent definindo uma área de texto, i.e. mais de uma linha de texto editável.
  • Choice
    Uma componente permitindo a escolha entre vários itens de uma lista. Um clique do mouse em cima de um pequeno botão faz aparecer a lista. Um item da lista pode ser selecionado com o mouse. Isto gera um evento do tipo ItemEvent. O objeto encarregado de tratar estes eventos deve implementar a interface ItemListener. A classe Choice implementa a interface ItemSelectable, que define alguns métodos relacionado com escolha, em especial o método addItemListener, que deve ser chamado para registrar o "ouvidor de eventos de escolha de item" da componente Choice. A referência ao ouvidor em questão é passada como argumento do método.
  • Checkbox
    Este tipo de botão permite uma escolha do tipo sim/não e vem acompanhado de alguma marca indicando a opção. Vários botões deste tipo podem ser agrupados num objeto CheckboxGroup. Neste caso, somente um dos botões pode estar selecionado (opção sim), os outros estando então automaticamente deselecionados (opção não). Botões assim agrupos são usualmente chamados botões de rádio. A classe Checkbox implementa a interface ItemSelectable e os seus eventos, do tipo ItemEvent, são tratados como descrito no item anterior.
  • List
    Uma lista de itens entre os quais um, ou vários, podem ser selecionados. Uma barra de rolagem aparece automaticamente se o número de itens for maior que o número de linhas visíveis. Esta classe também implementa a interface ItemSelectable. Um evento do tipo ItemEvent é gerado por um clique simples do mouse. Um evento do tipo ActionEvent é gerado por um clique duplo do mouse. Assim, esta componente pode utilizar dois ouvidores de eventos, um ItemListener e um ActionListener. Evidentemente, estas duas funcionalidades podem ser incorporadas numa única classe que implementa ambos interfaces.
  • Scrollbar
    Uma barra de rolagem que permite "rolar" um cursor sobre um dado intervalo de valores inteiros. A rolagem é realizada arrastando o cursor com o mouse ou clicando. Isto gera eventos do tipo AdjustmentEvent. O objeto encarregado de tratar estes eventos deve implementar a interface AjustmentListener. A classe Scrollbar implementa a interface Adjustable, que define alguns métodos relacionado com rolagem, em especial o método addAdjustmentListener, que deve ser chamado para registrar o "ouvidor de eventos de rolagem" da componente Scrollbar. A referência ao ouvidor em questão é passada como argumento do método.
  • ScrollPane
    Esta classe herda de Container pode conter uma única componente, que pode ser rolada horizontalmente e verticalmente. As barras de rolagem são partes intregrantes da componente.
  • Frame
    Um janela com uma barra de título e uma borda. Esta classe herda da classe Window, que representa o tipo mais rudimentar de janela e herda por sua vez da classe Container. A classe Frame implementa a interface MenuContainer, que permite que ela receba uma barra de menu. Os eventos associados à manipulação de uma janela (abertura, fechamento, iconização, redimensionamento...) são do tipo WindowEvent. O objeto encarregado de tratar estes eventos deve implementar a interface WindowListener. O método addWindowListener, da superclasse Window, deve ser chamado para registrar o "ouvidor de eventos de janela" da componente Frame. A referência ao ouvidor em questão é passada como argumento do método.
  • Dialog
    Uma caixa de diálogo é uma janela com uma barra de título, usualmente utilizada para permitir a entrada de dados ou para fornecer informação ao usuário. Uma caixa de diálogo pode ser modal ou não. Se ela for modal, nenhuma outra janela pode ser acessada enquanto a caixa de diálogo estiver aberta.
  • MenuComponent
    As componentes associadas a menus não herdam da classe Component e sim da classe MenuComponent, uma classe abstrata. As subclasses diretas de MenuComponent são MenuBar e MenuItem.
  • MenuBar
    Uma barra de menu, que pode ser acrescentada a um Frame, passando-a como argumento do método setMenuBar deste frame. Menus podem ser acrescentados à barra chamando-se o método add da mesma.
  • Menu
    Um menu, que pode ser acrescentado a uma barra de menu ou, tratando-se de um submenu, a outro menu. Já que um objeto deste tipo pode ser acrescentado a um menu, a classe Menu herda da classe MenuItem descrita abaixo. Um item pode ser acrescentado a um menu passando-o como argumento do método add do mesmo.
  • MenuItem
    Uma item de menu, que pode ser acrescentada a um Menu, passando-a como argumento do método add deste menu. Um clique em cima de um item de menu gera um evento do tipo ActionEvent, cujo tratamento já foi descrito acima.
  • CheckboxMenuItem
    Subclasse de MenuItem que fornece um item de menu que permite uma escolha do tipo sim/não e mostra uma marca especial se a selação for sim. Um clique em cima de um item de menu deste tipo gera um evento do tipo ItemEvent, cujo tratamento já foi descrito acima.
  • PopupMenu
    Subclasse de Menu que fornece um menu contextual, i.e. um menu que aparece quando o botão direito do mouse é clicado. O clique produz ume evento do tipo MouseEvent. o objeto encarregado de tratar este evento deve implementar a interface MouseListener. Deve comandar a aparição da caixa de diálogo chamando o método show da mesma.

  Tratamento de eventos

  O tratamento de eventos tipicamente segue o padrão seguinte:

  • O objeto responsável pelo tratamento dos eventos ("ouvidor") deve implementar uma determinada interface característica do tipo de eventos a serem tratados. Lembramos que uma interface é uma prescrição de um conjunto de métodos (de nome, acesso, valor de retorno e tipos de argumentos definidos) que devem ser todos implementados pela classe que implementa a interface. Métodos que não vão ser utilizados devem receber uma implementação trivial (não fazer nada). Os tipos de eventos e as interfaces de tratamento de eventos são definidos no pacote java.awt.event. Vale notar que existem classes de biblioteca, também definidas neste pacote, que fornecem implementações triviais destas interfaces. Estas classes são chamadas adaptadores (Adapter). Uma alternativa à implementação da interface é a criação de uma subclasse do adaptador na qual os métodos que vão ser utilizados são sobre-escritos. Lembramos porém que uma classe só poder herdar de uma única classe, embora possa implementar várias interfaces.
  • O objeto responsável pelo tratamento dos eventos deve ser registrado como "ouvidor" junto à componente que vai receber os eventos.

  O tipos de eventos e interfaces de tratamento correspondentes, eoncontrados nas componentes listadas acima são:

  • ActionEvent - ActionListener
    
    public void actionPerformed( ActionEvent e )
{
   // ação a ser realizada
}

  • TextEvent - TextListener
    
    public void textValueChanged( TextEvent e )
{
   // ação a ser realizada se o texto foi mudado
}

  • ItemEvent - ItemListener
    
    public void itemStateChanged( ItemEvent e )
{
   // ação a ser realizada se um novo item foi selecionado
}

  • AdjustmentEvent - AdjustmentListener
    
    public void adjustmentValueChanged( AdjustmentEvent e )
{
   // ação a ser realizada se houve rolagem
}

  • WindowEvent - WindowListener
    
    public void windowActivated( WindowEvent e )
    {
       // ação a ser realizada se a janela foi ativada
    }
    public void windowClosed( WindowEvent e )
    {
       // ação a ser realizada se a janela foi fechada
    }
    public void windowClosing( WindowEvent e )
    {
       // ação a ser realizada se a janela está sendo fechada
    }
    public void windowDeactivated( WindowEvent e )
    {
       // ação a ser realizada se a janela foi desativada
    }
    public void windowDeiconified( WindowEvent e )
    {
       // ação a ser realizada se a janela foi de-iconificada
    }
    public void windowIconified( WindowEvent e )
    {
       // ação a ser realizada se a janela foi iconificada
    }
    public void windowOpened( WindowEvent e )
    {
       // ação a ser realizada se a janela foi aberta
    }

  • MouseEvent - MouseListener
    
    public void mouseClicked( MouseEvent e )
    {
       // ação a ser realizada se o mouse foi clicado
    }
    public void mousePressed( MouseEvent e )
    {
       // ação a ser realizada se o botão do mouse foi apertado
    }
    public void mouseReleased( MouseEvent e )
    {
       // ação a ser realizada se o botão do mouse foi solto
    }
    public void mouseEntered( MouseEvent e )
    {
       // ação a ser realizada se o mouse entrou em cima da componente
    }
    public void mouseExited( MouseEvent e )
    {
       // ação a ser realizada se o mouse sai de cima da componente
    }

  Movimentos do mouse também ser tratados por

  MouseEvent - MouseMotionListener
  

  public void mouseDragged( MouseEvent e )
  {
     // ação a ser realizada se o mouse foi arrastado (com botão apertado)
  }

  public void mouseMoved( MouseEvent e )
  {
     // ação a ser realizada se o mouse foi movido (com botão solto)
  }