A linguagem Java oferece, dentre as funcionalidades incorporadas à sua API padrão, um extenso conjunto de classes e interfaces para o desenvolvimento de aplicações gráficas. Esse conjunto facilita a criação de saídas na forma gráfica e de interfaces gráficas com usuários (GUIs), tanto na forma de aplicações autônomas como na forma de applets.

Aplicações gráficas são criadas através da utilização de componentes gráficos, que estão agrupa- dos em dois grandes pacotes: java.awt e javax.swing.

AWT é o Abstract Windowing Toolkit, sendo definido através das classes do pacote java.awt e seus subpacotes, tais como java.awt.event. Essas classes agrupam as funcionalidades gráficas que estão presentes desde a primeira versão de Java, que operam tendo por base as funcionalidades de alguma biblioteca gráfica do sistema onde a aplicação é executada.

Já o pacote javax.swing define uma extensão padronizada a partir de AWT que congrega componentes gráficos que utilizam exclusivamente Java (lightweight components), com funcionali- dades e aparência independentes do sistema onde a aplicação é executada.

 

​

4.1 Apresentação gráfica

​

A base para tudo que é desenhado na tela de uma aplicação gráfica é o contexto gráfico, em Java um objeto da classe Graphics do pacote java.awt. São nesses objetos que linhas, retângulos, círculos, strings, etc. são desenhados, compondo a apresentação visual da aplicação gráfica.

Todo componente gráfico tem associado a si um contexto gráfico e alguns métodos chaves para manipulá-lo. A um objeto da classe Component pode-se aplicar os métodos getGraphics(), que permite obter uma referência para um objeto da classe Graphics; paint(Graphics), que determina o que é feito no contexto gráfico; e repaint(), que solicita uma atualização no contexto gráfico.

Para determinar o conteúdo gráfico do contexto, os métodos da classe Graphics são utilizados. Esses métodos incluem facilidades para definição de cores, fontes e definição de figuras geométricas. O sistema de coordenadas para definir a posição do desenho no contexto tem origem no canto superior esquerdo da área gráfica, tomando valores inteiros para e representando quantidades de pixels na horizontal e na vertical, respectivamente.

​

A cor corrente para o contexto gráfico pode ser obtida e definida pelos métodos getColor()

e setColor(), respectivamente. Esses métodos usam cores representadas por objetos da classe

Color, que oferece constantes para usar cores pré-definidas, métodos para definir cores especifican- do níveis RGB (red, green, blue) ou HSB (hue, saturation, brightness) e métodos para manipular as cores existentes.

Similarmente, a fonte usada para a apresentação de strings no contexto pode ser obtida e definida através de métodos getFont() e setFont(). Fontes são representadas por objetos da classe Font.

Entre os diversos métodos usados para desenhar no contexto, há métodos para desenhar texto usando a fonte de texto e a cor corrente, drawString(); desenhar linhas retas, drawLine(); e desenhar diversas formas geométricas, tais como arcos, drawArc(); retângulos, drawRect(), drawRoundRect(), draw3DRect(); polígonos,  drawPolygon(); ovais,  drawOval(); e suas correspondentes versões preenchidas, fillArc(), fillRect(), fillRoundRect(), fill3DRect(), fillPolygon() e fillOval().

 

4.1 Interfaces gráficas com usuários

​

Criar uma interface gráfica com usuários em Java envolve tipicamente a criação de um container, um componente que pode receber outros. Em uma aplicação gráfica autônoma, tipicamente o con- tainer usado como base é um frame (uma janela com bordas e barra de título), enquanto que em um applet o container base é um panel (uma área gráfica inserida em outra). Em aplicações complexas, qualquer tipo de combinação desses e de outros tipos de componentes é utilizado.

​

Após sua criação, os containers da aplicação recebem componentes de interface com usuários, que permitirão apresentar e receber dados aos e dos usuários. Embora seja possível posicionar esses componentes através de coordenadas absolutas em cada container, é recomendável que o projetista utilize sempre um gerenciador de layout para realizar essa tarefa. Deste modo, garante-se que a apli- cação possa ser executada independentemente das características da plataforma onde será executada.

Finalmente, é preciso especificar quais devem ser os efeitos das ações dos usuários — tais como um "clique"do mouse ou uma entrada de texto — quando realizadas sobre cada um desses compo- nentes. Isto se dá através da especificação de classes manipuladoras de eventos, projetadas para a aplicação. Ao associar objetos dessas classes aos componentes gráficos, o projetista determina o comportamento da aplicação.

 

4.1.1 Eventos da interface gráfica

​

No modelo de eventos suportado a partir da versão 1.1 de Java, um componente gráfico qual- quer pode reconhecer alguma ação do usuário e a partir dela disparar um evento — indicando, por exemplo, que o botão do mouse foi pressionado ou que um texto foi modificado — que será captu- rado por um objeto registrado especificamente para registrar aquele tipo de evento ocorrido naquele componente.

O pacote java.awt.event define as diversas classes de eventos que podem ocorrer através das interfaces gráficas. Eventos gráficos são objetos derivados da classe AWTEvent, que por sua vez são derivados de objetos de evento genéricos definidos pela classe EventObject. Desta, even- tos gráficos herdam o método getSource(), que permite identificar o objeto que deu origem ao evento.

​

Eventos gráficos genéricos são especializados de acordo com o tipo de evento sob consideração

— por exemplo, pressionar um botão do mouse gera um objeto da classe MouseEvent. A mesma ação sobre um botão, no entanto, gera também um ActionEvent, enquanto que sobre o botão de minimizar na barra de título de um frame um WindowEvent seria ao invés adicionalmente gerado. Outros eventos de interesse definidos em java.awt.event incluem ItemEvent, indicando que um item de uma lista de opções foi selecionado; TextEvent, quando o conteúdo de um componente de texto foi modificado; e KeyEvent, quando alguma tecla foi pressionada no teclado.

 

A resposta que uma aplicação dá a qualquer evento que ocorre em algum componente gráfico é determinada por métodos específicos, registrados para responder a cada evento. O nome e a assina- tura de cada um desses métodos é determinado por uma interface Java do tipo listener. Assim, para responder a um ActionEvent será utilizado o método definido na interface ActionListener; para responder a um WindowEvent, os métodos de WindowListener. Similarmente, há interfa- ces ItemListener, TextListener e KeyListener. Os eventos do mouse são manipulados através de métodos especificados em duas interfaces, MouseListener (para ações sobre o mouse)

e MouseMotionListener (para tratar movimentos realizados com o mouse).

​

Apesar de existir um grande número de eventos e possibilidades de resposta que a aplicação poderia dar a cada um deles, cada aplicação pode especificar apenas aqueles para os quais há interesse que sejam tratados. Para os eventos que o projetista da aplicação tem interesse de oferecer uma reação, ele deve definir classes manipuladoras de eventos (handlers), implementações de cada listener correspondente ao tipo de evento de interesse.

​

Para interfaces listener que especificam diversos métodos, classes adaptadoras são definidas. Essas classes adaptadoras são classes abstratas definidas no pacote de eventos AWT, com nome XX- XAdapter, onde XXX seria o prefixo correspondente ao tipo de evento de interesse. Assim, para que a aplicação use uma classe adaptadora para tratar os eventos do tipo WindowEvent, por exem- plo, uma classe que estende a classe WindowAdapter pode ser definida. Nessa classe derivada, os métodos relacionados aos eventos de interesse são redefinidos (pelo mecanismo de overriding). Co- mo a classe adaptadora implementa a interface correspondente WindowListener, assim o fará a classe derivada. Os métodos não redefinidos herdarão a definição original, que simplesmente ignora os demais eventos.

​

A API de eventos AWT de Java define, além de WindowAdapter, as classes adaptadoras Mou- seAdapter, MouseMotionAdapter e KeyAdapter. Uma vez que uma classe handler tenha sido criada para responder aos eventos de um compo- nente, é preciso associar esse componente ao objeto handler. Para tanto, cada tipo de componente gráfico oferece métodos na forma addXXXListener(XXXListener l) e removeXXXLis- tener(XXXListener l), onde XXX está associado a algum evento do tipo XXXEvent. Por exemplo, para o componente Window (e por herança para todas os componentes derivados des- se) são definidos os métodos public void addWindowListener(WindowListener l) e public void removeWindowListener(WindowListener l), uma vez que nesse ti- po de componente é possível ocorrer um WindowEvent.

 

Manipuladores de eventos de baixo nível

​

Eventos de mouse são tratados pelos métodos definidos em dois listeners distintos definidos em

java.awt.event. A interface MouseListener especifica os métodos para os eventos de maior

destaque na interação do usuário com o mouse. A classe abstrata MouseAdapter oferece imple- mentações vazias para todos esses métodos.

​

Um objeto associado a um evento do mouse descreve eventos notáveis ocorridos com o mouse, como o fato de ter entrado ou saído na área de interesse (uma janela, tipicamente), um “clique” ocorrido, se alguma tecla de modificação (ALT, SHIFT ou CONTROL) estava pressionada e a posição na qual o evento ocorreu.

A interface MouseMotionListener especifica métodos para manipular eventos de movi- mentação do mouse. A classe abstrata MouseMotionAdapter é uma adaptadora para esse liste- ner. Nesse caso, qualquer movimentação do mouse é relatada, diferenciando entre eventos da forma MOUSE_MOVED, para movimentos com o mouse livre, e MOUSE_DRAGGED, para movimentos do mouse com algum botão pressionado.

​

A interface KeyListener especifica os métodos necessários para detectar e tratar eventos de teclado. São eles: keyPressed(), para indicar que a tecla foi pressionada; keyReleased(), para indicar que a tecla foi solta; e keyTyped(), para indicar que uma tecla que não de controle foi pressionada e solta. Todos os métodos recebem um objeto KeyEvent como parâmetro. Esse objeto indica o tipo de evento ocorrido (KEY_PRESSED, KEY_TYPED ou KEY_RELEASED), o código da tecla e se havia modificadores associados. Como essa interface listener especifica mais de um método, uma classe adaptadora, KeyAdapter, é oferecida.

 

Manipuladores de eventos de alto nível

​

Raramente uma aplicação está preocupada em tratar eventos no nível tão básico como qualquer movimento do mouse ou tecla pressionada. Java oferece um conjunto de funcionalidades que filtram esses eventos para outros mais próximos da visão da aplicação, como o pressionar de um botão ou entrar texto em um campo.

A interface ActionListener especifica o método actionPerformed() para tratar even- tos do tipo ação. Objetos da classe ActionEvent representam eventos associados a uma ação aplicada a algum componente AWT.

Uma descrição (na forma de uma string) da ação pode ser obtida através do método getAc- tionCommand(). Dessa forma, se mais de um componente compartilha um mesmo listener, esse método permite diferenciar qual componente foi o gerador da ação.

​

Outro atributo que está representado em um objeto evento diz respeito aos modificadores, teclas que podem estar apertadas simultaneamente à ocorrência do evento para requisitar um tratamento alternativo. A classe ActionEvent define o método getModifiers(), que retorna um valor inteiro que pode ser analisado em relação a quatro constantes da classe, ALT_MASK, CTRL_MASK, META_MASK e SHIFT_MASK.

Um objeto de uma classe que implemente ActionListener deve ser associado a um com-

ponente através do método addActionListener(), que é definido para componentes do tipo botão, listas e campos de texto.

​

Quando um evento desse tipo ocorre, o objeto registrado é notificado. O método actionPer- formed() é então invocado, recebendo como argumento o objeto que representa o evento.

Eventos associados à manipulação de janelas são definidos na interface WindowListener.

 

Essa interface especifica os seguintes métodos:

 

windowOpened() trata evento que é apenas gerado quando a janela é criada e aberta pela primeira vez

windowClosing() usuário solicitou que a janela fosse fechada, seja através de um menu do sistema ou através de um botão da barra de títulos ou através de uma sequência de teclas do sistema.

windowClosed() trata evento que indica que a janela foi fechada. windowIconified() trata evento que indica que janela foi iconificada. windowDeiconified() trata evento indicando que o ícone da janela foi aberto.

windowActivated() trata evento que indica que a janela ganhou o foco do teclado e tornou-se a janela ativa.

windowDeactivated() trata evento que indica que a janela deixou de ser a janela ativa, provavel- mente porque outra janela foi ativada.

​

Todos esses métodos têm como argumento um objeto da classe WindowEvent, que representa um evento de janela. Como a interface WindowListener especifica diversos métodos, uma classe adaptadora abs- trata, WindowAdapter, é fornecida com implementações vazias de todos os métodos.

Para implementar a interface ItemListener é preciso definir a implementação do método itemStateChanged(), que recebe como argumento um objeto evento do tipo ItemEvent. Um ItemEvent sinaliza que um elemento de algum tipo de lista de opções foi selecionado ou desselecionado. Componentes que emitem esse tipo de evento implementam a interface ItemSelectable.

​

A interface TextListener especifica o método que trata eventos do tipo texto. Um obje-  to da classe TextEvent está relacionado a um evento indicando que o usuário modificou o valor de texto que aparece em um TextComponent — qualquer modificação no texto apresentado no componente gera esse evento. Um método apenas é especificado na interface, textValueChan- ged(TextEvent e). O corpo desse método determina o que deve ser executado quando o texto em algum componente de texto é alterado.

 

4.1.1 Componentes gráficos

​

A criação de uma interface gráfica com usuários utiliza tipicamente uma série de componentes pré-estabelecidos para tal fim, tais como rótulos (labels, textos que são apresentados mas não alterá- veis) e botões, um componente que pode ser ativado pelo usuário através do mouse.

Java oferece um amplo conjunto de classes pré-definidas e re-utilizáveis que simplificam o desen- volvimento de aplicações gráficas. A raiz desse conjunto de classes gráficas no pacote java.awt é a classe abstrata Component, que representa qualquer objeto que pode ser apresentado na tela e ter interação com usuários. Similarmente, o pacote Swing tem por raiz a classe JComponent, que (indiretamente) é em si uma extensão de Component.

​

Os métodos da classe Component definem funcionalidades que dizem respeito à manipulação de qualquer componente gráfico em Java. O método getSize() permite obter a dimensão do componente, expressa na forma de um objeto da classe Dimension — um objeto dessa classe tem

campos públicos width e height que indicam respectivamente as dimensões horizontais e verti- cais do componente em pixels. Já o método setSize() permite definir a dimensão do componente. Outro grupo de métodos importantes dessa classe é composto pelos métodos que permitem deter- minar os manipuladores de eventos que são relevantes para qualquer tipo de objeto gráfico,

 

como os eventos de mouse (addMouseListener(),

 

addMouseMotionListener(),

removeMouseListener(),

removeMouseMotionListener())

 

e de teclado

​

addKeyListener(),

removeKeyListener()).

 

Subclasses de Component que são amplamente utilizadas no desenvolvimento de aplicações gráficas incluem os containers, um objeto gráfico que pode conter outros componentes, e os compo- nentes de interface gráfica com usuários.

​

Para manipular texto em uma interface gráfica há componentes dos tipos campos de texto e áreas de texto, que permitem a entrada e/ou apresentação de texto em uma janela gráfica, respectivamente para uma única linha ou para diversas linhas de texto.

Quando a aplicação oferece ao usuário uma série de opções pré-estabelecidas, os componentes tipicamente utilizados em interfaces gráficas são de escolha, que pode ser única, quando a seleção de uma opção exclui as demais, ou múltipla, quando várias opções podem ser selecionadas simultanea- mente.

 

Rótulos

​

Rótulos são campos de texto incluídos em uma janela gráfica com o único objetivo de apresenta- ção. Dessa forma, rótulos não reagem a interações com usuários.

A classe Label define um componente de AWT que apresenta uma única linha de texto não- alterável. Um dos atributos associados a um Label é o texto a ser apresentado, que pode ser especi- ficado em um dos construtores ou através do método setText(). O método getText() retorna o valor desse atributo. Outro atributo de Label é o alinhamento, que pode ser Label.CENTER, Label.LEFT ou Label.RIGHT. O alinhamento pode ser definido em um dos construtores (jun- tamente com o texto) ou através do método setAlignment(). O método getAlignment() retorna o valor desse atributo.

​

A classe JLabel define o componente Swing para implementar rótulos. Além de oferecer fa- cilidades equivalentes àquelas de Label, JLabel oferece a possibilidade de definir o alinhamento vertical (o padrão é centralizado) e de usar um ícone gráfico como rótulo, em adição ou em substitui- ção a um texto.

 

Botões

​

Um botão corresponde a um componente gráfico que pode ser “pressionado” através de um “cli- que” do mouse, podendo assim responder à ativação por parte de um usuário.

A classe Button implementa um botão no AWT. Para criar um botão com algum rótulo, basta usar o construtor que recebe como argumento uma string com o texto do rótulo. Alternativamen- te, pode-se usar o construtor padrão (sem argumentos) e definir o rótulo do botão com o método setLabel(). O rótulo que foi definido para o botão pode ser obtido do método getLabel().

​

Em Swing, o componente que define um botão é JButton. Além de poder ser definido com

rótulos de texto, um botão Swing pode conter também ícones.

Para manipular o evento associado à seleção de um botão, é preciso definir uma classe que realize o tratamento de um evento do tipo ação implementando um ActionListener.

 

Campos de texto

​

Um campo de texto é uma área retangular, de tamanho correspondente a uma linha, que pode ser utilizada para apresentar ou adquirir strings do usuário.

A classe TextField é uma extensão da classe TextComponent que implementa um campo de texto no toolkit AWT. Os construtores dessa classe permitem a criação de um campo de texto que pode estar vazio ou conter algum texto inicial. O número de colunas no campo também pode ser especificado através dos construtores.

O componente correspondente a esse em Swing é JTextField. Além de funcionalidades associadas a TextField, esse componente oferece outras que permitem definir campos de texto customizados.

​

Quando o usuário entra um texto em um campo de texto e tecla ENTER, é gerado um evento do tipo ação. Para indicar o objeto manipulador para esse evento, os métodos addActionListe- ner() e removeActionListener() são utilizados. Ambos têm como argumento um objeto ActionListener. Eventos relativos à modificação de um valor em um campo de texto (sem pres- sionar a tecla ENTER) estão associados a eventos do tipo texto. Desse modo, é possível monitorar se alguma modificação ocorreu no campo de texto.

É possível não ecoar a apresentação dos caracteres de entrada para a tela definindo um caráter alternativo que deve ser apresentado. Em AWT, utiliza-se o método setEchoChar() da classe TextField. Em Swing, para tal fim deve ser utilizado o componente JPasswordField.

 

Áreas de texto

​

Uma área de texto permite apresentar e opcionalmente editar textos de múltiplas linhas. É pos- sível adicionar texto a uma área através do método append(), que recebe uma string como argu- mento.

Em AWT, a classe TextArea oferece essa funcionalidade, sendo também uma extensão da classe TextComponent. Assim como para um campo de texto de uma linha, o texto apresenta- do inicialmente e o número de colunas visíveis pode ser definido em construtores. Adicionalmente, o número de linhas visíveis pode ser definido no momento da construção do objeto. Para a apre- sentação de textos que ocupam uma área maior que a visível, um construtor tem um argumento  que indica se e quantas barras de rolagem estarão presentes na área de texto. Os valores possí-  veis, definidos como constantes estáticas dessa classe, são

 

SCROLLBARS_BOTH (barras de rolagem nas direções vertical e horizontal), SCROLLBARS_HORIZONTAL_ONLY (apenas na horizontal),

SCROLLBARS_VERTICAL_ONLY (apenas na vertical) e

SCROLLBARS_NONE (sem barras de ro- lagem).

​

O componente correspondente a esse em Swing é o JTextArea. Em Swing, o comportamento default para a área de texto é não ter barras de rolagem — se isso for necessário, a aplicação deve usar um componente decorador JScrollPane. Outras diferenças dizem respeito à habilidade de mudar de linha (automático em AWT) e à geração de eventos do tipo texto (não presente em Swing). O framework Swing oferece, no entanto, outros componentes mais elaborados que também ma- nipulam áreas de texto. Componentes das classes JEditorPane e JTextPane conseguem manipular vários tipos de conteúdo, como por exemplo texto em HTML.

 

Componentes de seleção

​

Java apresenta três mecanismos básicos para definir um componente que permite ao usuário a seleção de opções apresentadas: drop-down, lista ou caixa de seleção.

Um componente de interação em drop-down é aquele que deixa visível uma única opção (aquela que está selecionada) ao usuário, mas que permite que esse visualize e selecione as outras opções através da ativação de um mini-botão associado ao componente. Quando esse tipo de componente permite também a entrada de valores em um campo de texto combinado à lista, é usualmente chamado de combo box. Em componentes do tipo combo box, a seleção é restrita a uma única opção, com uma lista de itens em apresentação drop-down onde apenas o elemento selecionado é visível. Os demais itens podem ser apresentados para seleção através de interação com o mouse.

​

Em AWT, a funcionalidade de lista em drop-down é suportada através da classe Choice, que permite definir uma lista de itens não-editáveis. Para essa classe, apenas o construtor padrão é ofe- recido. Os principais métodos para manipular objetos dessa classe são: add(String s), que permite adicionar itens à lista; getSelectedIndex(), que retorna a posição numérica do item selecionado na lista (o primeiro elemento tem índice 0); getSelectedItem(), que retorna o ró- tulo do item selecionado na lista; e getItem(int index), retorna o rótulo do item cujo índice foi especificado.

​

A classe Choice implementa a interface ItemSelectable, o que permite associar objetos dessa classe a um manipulador de eventos do tipo item, ItemListener.

Em Swing, o mecanismo de lista em drop-down é suportado pela classe JComboBox, que pode ser configurado para ser editável ou não.

​

A segunda opção para seleção de itens é oferecida através de listas, onde vários itens são apre- sentados simultaneamente em uma janela. Na construção desse tipo de componente, o programador pode estabelecer se a seleção será exclusiva ou múltipla. Um componente do tipo lista oferece a fun- cionalidade de apresentar uma lista de opções dos quais um ou vários itens podem ser selecionados. Em AWT, a classe List oferece essa funcionalidade. Além do construtor padrão, essa classe oferece um construtor que permite especificar quantas linhas da lista serão visíveis. Um terceiro construtor permite especificar um valor booleano indicando se o modo de seleção de vários itens está habilitado (true) ou não. Se não especificado, apenas um item pode ser selecionado da lista.

​

Os principais métodos dessa classe incluem: add(String item), que acrescenta o item à lis- ta; add(String item, int index), que acrescenta um item à lista na posição especificada; getSelectedIndex(), que retorna a posição numérica do item selecionado na lista, sendo que o primeiro item está na posição 0; getSelectedItem(), que retorna o rótulo do item selecionado na lista; e getItem(int index), que retorna o rótulo do item cujo índice foi especificado. Há ainda métodos para a manipulação de seleções múltiplas: getSelectedIndexes(), que retorna um arranjo de inteiros correspondendo às posições selecionadas, e getSelectedItems(), que retorna um arranjo de String correspondente aos rótulos dos itens selecionados.

​

Assim como a classe Choice, a classe List implementa a interface ItemSelectable, que permite associar um objeto dessa classe a um manipulador de eventos do tipo item, ou seja, a um objeto ItemListener. Esse tipo de evento é gerado quando o item é alvo de um único toque do mouse. Além disso,  um item da lista pode reagir a um toque duplo do mouse através da geração  de um evento do tipo ação, usando para o tratamento do evento nesse caso um manipulador do tipo ActionListener. O tratamento de múltiplas seleções através de eventos de itens não é amigável através dessa interface, pois a cada seleção um novo  evento é gerado.  Por esse motivo,  a documentação da API Java recomenda que esse tipo de seleção múltipla em AWT seja efetivada através de algum controle externo, como um botão.

​

Em Swing, funcionalidade similar à apresentada por List é oferecida pela classe JList, em- bora algumas diferenças devam ser observadas. Por exemplo, ao contrário de List, um JList não suporta barras de rolagem diretamente, o que deve ser acrescido através de um objeto decorador JScrollPane.

A terceira opção para selecionar itens em uma interface gráfica é utilizar componentes do tipo caixas de seleção, que podem ser independentemente selecionadas ou organizadas em grupos de caixas de seleção das quais apenas uma pode estar selecionada. Uma caixa de seleção oferece um mecanismo de seleção em que uma opção pode assumir um de dois valores, selecionada ou não- selecionada. Diz-se que tais componentes têm comportamento booleano.

​

Em AWT, essa funcionalidade é suportada pela classe Checkbox. Além do construtor padrão, essa classe oferece construtores que permitem expressar um rótulo (String) para o botão e o es- tado inicial (boolean). O método getState() permite obter o estado da seleção; o método getLabel(), o rótulo associado à caixa de seleção. Checkbox implementa a interface Item- Selectable, permitindo tratar reações a eventos do tipo item através de um ItemListener.

​

Em Swing, essa funcionalidade é suportada de forma similar pela classe JCheckBox.

É também possível definir grupos de caixas de seleção das quais apenas uma pode estar seleci- onada em um dado instante, constituindo assim opções exclusivas entre si. Em AWT, esse tipo de funcionalidade é oferecido através do conceito de um grupo de checkboxes, suportado através da clas- se CheckboxGroup. Um CheckboxGroup não é um componente gráfico, como um container, mas sim um agrupamento lógico entre os componentes gráficos do tipo Checkbox, que devem es- pecificar na sua construção ou através do método setCheckboxGroup() a qual grupo pertencem, se for o caso de pertencer a algum.

Funcionalidade similar a essa é oferecida em Swing através das classes JRadioButton e But- tonGroup.

 

4.1.1 Containers

​

Dificilmente uma aplicação gráfica é composta por um único componente, mas sim por vários componentes inter-relacionados. Para este tipo de aplicação, um componente fundamental é a área onde os demais componentes da aplicação estarão dispostos. Um componente que pode conter outros componentes é denominado um container.

​

Em Java, a classe Container é a classe abstrata que define as funcionalidades básicas asso- ciadas a um container, tais como adicionar e remover componentes, o que é possível através dos métodos add() e remove(), respectivamente. É possível também estabelecer qual a estratégia de disposição de componentes no container, ou seja, qual o método de gerência de layout, através do método setLayout().

​

Window é uma classe derivada de Container cujos objetos estão associados a janelas. Cada objeto Window é uma janela independente em uma aplicação, embora a essa janela não estejam associadas as funcionalidades usualmente oferecidas por gerenciadores de janela. Raramente um objeto desse é usado diretamente, mas objetos dessa classe são muito utilizados através de suas subclasses, tais como Frame.

​

Outra classe derivada de Container de extensa aplicação é Panel, que define uma área de composição de componentes contida em alguma janela. A classe Applet é uma extensão de Panel que permite criar applets (Seção 4.3). Embora a classe JComponent, raiz da hierarquia para todos os componentes do novo framework para interfaces gráficas de Java, seja derivada da classe Container, não se pode acrescentar di- retamente um componente gráfico a qualquer componente Swing. Para as classes de Swing que correspondem a containers no sentido definido em AWT, ou seja, às quais podem ser acrescenta- dos outros componentes, deve-se obter uma referência ao objeto Container através do método getContentPane().

 

4.1.1 Janelas

​

Janelas são áreas retangulares que podem ser exibidas em qualquer parte da tela gráfica de um usuário. Em AWT, objetos da classe Window estão associados a essa funcionalidade, sendo que nessa classe são definidos os métodos aplicáveis a qualquer tipo de janela. O framework Swing oferece a classe JWindow, derivada da classe Window, com esse mesmo tipo de funcionalidade porém adaptada ao novo framework.

Um objeto Window, no entanto, corresponde a uma janela sem nenhum tipo de “decoração”. É mais comum que aplicações gráficas criem janelas através de uma das classes derivadas de Window, tais como um frame ou uma janela de diálogo. Convém destacar da classe Window os métodos show(), para trazer a janela para a frente da tela; dispose(), para eliminar uma janela e liberar os recursos usados por ela usados; e addWindowListener() e removeWindowListener() para associar ou remover objetos manipuladores de eventos de janelas.

​

Um frame agrega a uma janela as funcionalidades mínimas para que ela possa ser identificada e manipulada pelo usuário da aplicação, tais como uma borda e a barra de títulos com botões de controle da janela. Um frame é uma janela com propriedades adicionais que a habilitam a ter uma “vida independente” no ambiente de janelas gráficas. Para que um frame seja apresentado pela aplicação, um objeto desse tipo de classe deve ser criado e algumas de suas propriedades básicas — tais como sua dimensão e o fato de estar visível ou não — devem ser estabelecidas.

​

Em AWT, frames estão associados a objetos da classe Frame. Esse exemplo ilustra as operações essenciais para que um frame AWT seja criado e exibido em um ambiente gráfico. O resultado da execução desse código é a criação e exibição de uma janela gráfica com conteúdo vazio:

 

1    import java.awt.*;
2    import java.awt.event.*;
3    public class Janela extends Frame {
4    class WindowHandler extends WindowAdapter {
5    public void windowClosing(WindowEvent we) {
6        dispose();
7        System.exit(0);
8        }
9        public void windowActivated(WindowEvent we) {
10        we.getWindow().validate();
11        }
12    }    
13    public Janela() {
14    this("Janela");
15    }
16    public Janela(String titulo) {
17    setTitle(titulo);
18    setSize(320,200);
19    addWindowListener(new WindowHandler());
20    }
21    public static void main(String[] args) {
22    Janela j = new Janela();
23    j.setVisible(true);
24    }
25    }
 

Se o tamanho da janela (em pixels, horizontal e vertical) não for definido (método setSize()), então o default (x=0, y=0) é assumido, criando uma janela de dimensões nulas. Mesmo que o tama- nho seja definido, a janela quando criada é por padrão invisível — para exibi-la é preciso invocar o método setVisible().

Frame é uma extensão da classe Window que, por sua vez, é uma concretização de Contai-

ner, que é uma extensão de Component. Assim, é importante tomar contato com os diversos métodos definidos ao longo dessa hierarquia para ter uma noção mais precisa sobre o que é possível realizar com um objeto Frame. Por exemplo, para tratar eventos relativos a janelas é preciso asso- ciar ao frame um WindowListener através do método addWindowListener(), definido na classe Window.

​

A classe Frame propriamente dita define os métodos que dizem respeito ao que um frame tem de específico que uma janela (objeto da classe Window) não tem — por exemplo, setTitle() para definir um título para a barra da janela, setMenuBar() para incluir uma barra de menus e setCursor() para determinar o tipo de cursor a ser utilizado. O tipo de cursor é definido por uma das alternativas especificadas como constantes da classe Cursor, tais como HAND_CURSOR ou Cursor.TEXT_CURSOR.

O pacote Swing também oferece a sua versão de um frame através da classe JFrame, que é uma extensão da classe Frame. Esse código ilustra a criação de uma janela vazia, como acima, usando JFrame:​

​

1    import javax.swing.*;
2    import java.awt.event.*;
3    public class SJanela extends JFrame {
4    class WindowHandler extends WindowAdapter {
5    public void windowClosing(WindowEvent we) {
6    dispose();
7    System.exit(0);
8    }
9    }
10    public SJanela() {
11    this("Janela");

12    }
13    public SJanela(String title) {
14    setSize(200,120);
15    setTitle(title);
16    addWindowListener(new WindowHandler());
17    }
18    public static void main(String[] args) {
19    SJanela je = new SJanela();
20    je.show();
21    }
22    }
 

1. Gerenciadores de layout

​

Quando um container tem mais de um componente, é preciso especificar como esses componen- tes devem ser dispostos na apresentação. Em Java, um objeto que implemente a interface Layout- Manager é responsável por esse gerenciamento de disposição. A interface LayoutManager2 é uma extensão de LayoutManager que incorpora o conceito de restrições de posicionamento de componentes em um container.

Os principais métodos da classe Container relacionados ao layout de componentes são se- tLayout(), que recebe como argumento o objeto que implementa LayoutManager e que deter- mina qual a política de gerência de disposição de componentes adotada; e validate(), usado para rearranjar os componentes em um container se o gerenciador de layout sofreu alguma modificação ou novos componentes foram adicionados.

 

O pacote java.awt apresenta vários gerenciadores de layout pré-definidos. As classes Flo- wLayout e GridLayout são implementações de LayoutManager; as classes BorderLayout, CardLayout e GridBagLayout são implementações de LayoutManager2. Swing acrescenta ainda um gerenciador de layout através da classe BoxLayout. Para determinar que o gerenciador de layout em um container c seja do tipo XXXLayout, é preciso invocar setLayout() passando como argumento um objeto gerenciador:

c.setLayout(new XXXLayout());

​

Containers derivados da classe Window têm como padrão um gerenciador de layout do tipo

BorderLayout, enquanto aqueles derivados de Panel usam como padrão FlowLayout.

 

FlowLayout

​

FlowLayout é uma classe gerenciadora de layout que arranja os componentes seqüencialmente na janela, da esquerda para a direita, do topo para baixo, à medida que os componentes são adiciona- dos ao container.

Os componentes são adicionados ao container da forma similar a um texto em um parágrafo, permitindo que cada componente mantenha seu tamanho natural. Como padrão, os componentes são horizontalmente centralizados no container. É possível mudar esse padrão de alinhamento especi- ficando um valor alternativo como parâmetro para um dos construtores da classe ou para o método setAlignment(). Esse parâmetro pode assumir um dos valores constantes definidos na classe, tais como LEFT ou RIGHT.

​

É possível também modificar a distância em pixels entre os componentes arranjados através desse tipo de gerenciador com os métodos setHgap() e setVgap(); alternativamente, esses valores podem também ser especificados através de construtores da classe FlowLayout. Para obter os valores utilizados, há métodos getHgap() e getVgap().

​

Esse é o gerenciador de layout padrão para containers derivados de Panel, tais como Applet.

Esse exemplo ilustra o uso desse tipo de gerenciador de layout para dispor um conjunto de botões em um frame:

1    import java.awt.*;
2    public class JanelaFlow extends Frame {
3    public JanelaFlow() {
4    setTitle("FlowLayout");
5    setSize(240,100);
6    setLayout(new FlowLayout());
7    }
8    public void addButton(int count) {
9    for(int i=1; i <= count; ++i)
10    add(new Button("B"+i));
11    }
12    public static void main(String[] args) {
13    JanelaFlow j = new JanelaFlow();
14    int qtde = 10;
15    try {
16    if (args.length > 0)
17    qtde = Integer.parseInt(args[0]);
18    }
19    catch (Exception e) {
20    }
21
22    j.addButton(qtde);
23    j.validate();
24    j.setVisible(true);
25    }
26    }​

 

GridLayout

GridLayout é uma implementação de LayoutManager que permite distribuir componentes ao longo de linhas e colunas. A distribuição dá-se na ordem de adição do componente ao container, da esquerda para a direita e de cima para baixo. Essa classe oferece um construtor que permite especificar o número de linhas e colunas desejado para o grid — para o construtor padrão, um grid de uma única coluna é usado. Adicionalmente, há

outro construtor que permite especificar, além da quantidade de linhas e colunas, o espaço em pixels

entre esses componentes nas direções horizontal e vertical.

Deve-se observar que, nesse tipo de layout, as dimensões dos componentes são ajustadas para ocupar o espaço completo de uma posição no grid.

Esse exemplo mostra como GridLayout dispõe um conjunto de dez botões em um grid de três linhas e quatro colunas:

 

1    import java.awt.*;
2
3    public class JanelaGrid extends Frame {
4    private final int rows=3, cols=4;
5    public JanelaGrid() {
6    setTitle("GridLayout");
7    setSize(240,100);
8    setLayout(new GridLayout(rows, cols));
9    }
10
11    public void addButton(int count) {
12    int max = rows*cols;
13    if (count < max)
14    max = count;
15    for(int i=1; i <= max; ++i)
16    add(new Button("B"+i));
17    }
18
19    public static void main(String[] args) {
20    JanelaGrid j = new JanelaGrid();
21    int qtde = 10;
22    try {
23    if (args.length > 0)
24    qtde = Integer.parseInt(args[0]);
25    }
26    catch (Exception e) {
27    }
28
29    j.addButton(qtde);
30    j.validate();
31    j.setVisible(true);
32    }
33    }
 

BorderLayout

​

BorderLayout é uma implementação de LayoutManager2 adequado para janelas com até cinco componentes. Ele permite arranjar os componentes de um container em cinco regiões, cujo posicionamento é representado pelas constantes BorderLayout.NORTH, SOUTH, EAST, WEST e CENTER:

 

1. import java.awt.*;

2. public class JanelaBorder extends Frame {

3. public JanelaBorder() {

4. setTitle("BorderLayout");

5                              setSize(240,100);

1. add(new Button("North"), BorderLayout.NORTH);

2. add(new Button("South"), BorderLayout.SOUTH);

3. add(new Button("East"), BorderLayout.EAST);

4. add(new Button("West"), BorderLayout.WEST);

5. add(new Button("Center"), BorderLayout.CENTER);

11                   }

1. public static void main(String[] args) {

2. JanelaBorder j = new JanelaBorder();

3. j.validate();

4. j.setVisible(true);

16                   }

 

Observe a utilização do método add(Component c, Object o) da classe Container, que incorpora a especificação das restrições de posicionamento.

Além do construtor padrão, outro construtor permite especificar o gap horizontal e vertical (em

pixels) entre os componentes.

​

Esse tipo de layout é o padrão para containers do tipo Frame. Para utilizar esse tipo de geren- ciador para janelas com mais de cinco componentes, basta definir que o componente inserido em um BorderLayout seja um Panel, que é um container que pode ter seu próprio gerenciador de layout.

 

1    import java.awt.*;
2    public class JanelaBorder extends Frame {
3    public JanelaBorder() {
4    setTitle("BorderLayout");
5    setSize(240,100);
6    add(new Button("North"), BorderLayout.NORTH);
7    add(new Button("South"), BorderLayout.SOUTH);
8    add(new Button("East"), BorderLayout.EAST);
9    add(new Button("West"), BorderLayout.WEST);
10    add(new Button("Center"), BorderLayout.CENTER);
11    }
12    public static void main(String[] args) {
13    JanelaBorder j = new JanelaBorder();
14    j.validate();
15    j.setVisible(true);
16    }

CardLayout

​

Um gerenciador do tipo CardLayout empilha os componentes de um container de tal forma que apenas o componente que está no topo permanece visível. Esse gerenciador implementa a interface LayoutManager2.

Os métodos do gerenciador estabelecem funcionalidades que permitem “navegar” entre os com- ponentes empilhados, determinando qual item deve estar visível em um dado momento. Os méto- dos de navegação first(), next(), previous() e last() permitem realizar uma varredura seqüencial pelos componentes de container especificado, cujo gerenciador de layout deve ser do tipo CardLayout.

O método show() permite selecionar um componente para exposição diretamente através de uma string, que é especificada como uma restrição quando da adição do componente ao container, como no seguinte fragmento:

​

Panel p = new Panel(); cm = new CardLayout();

p.setLayout(cm);

Button b = new Button("Teste"); p.add(b, b.getLabel());

que permitiria a exibição desse botão com a invocação cm.show(p, b.getLabel());

​

Tipicamente, os componentes manipulados por um gerenciador do tipo CardLayout são con- tainers, os quais por sua vez utilizam qualquer outro tipo de gerenciador de layout.

Esse exemplo ilustra o uso de CardLayout para organizar cinco rótulos distintos em um contai- ner alocado ao elemento central de um frame com BorderLayout. Os quatro elementos periféricos do BorderLayout são usados para navegar entre os rótulos do CardLayout central:

1    import java.awt.*;
2    import java.awt.event.*;
3    public class JanelaCard extends Frame {
4    Panel central = new Panel();
5    CardLayout cl = new CardLayout();
6    class FirstHandler implements ActionListener {
7    public void actionPerformed(ActionEvent ae) {
8    cl.first(central);
9    }
10    }
11    class LastHandler implements ActionListener {
12    public void actionPerformed(ActionEvent ae) {
13    cl.last(central);
14    }
15    }
16    class NextHandler implements ActionListener {
17    public void actionPerformed(ActionEvent ae) {
18    cl.next(central);
19    }
20    }
21    class PreviousHandler implements ActionListener {
22    public void actionPerformed(ActionEvent ae) {
23    cl.previous(central);
24    }
25    }
26    public JanelaCard() {
27    setTitle("CardLayout");
28    setSize(240,200);
29    Button next = new Button("Proximo");
30    next.addActionListener(new NextHandler());
31    Button previous = new Button("Anterior");
32    previous.addActionListener(new PreviousHandler());
33    Button first = new Button("Primeiro");
34    first.addActionListener(new FirstHandler());
35    Button last = new Button("Ultimo");
36    last.addActionListener(new LastHandler());
37    add(first, BorderLayout.NORTH);
38    add(last, BorderLayout.SOUTH);
39    add(previous, BorderLayout.WEST);
40    add(next, BorderLayout.EAST);
41    add(central, BorderLayout.CENTER);
42    central.setLayout(cl);
43    central.add(new Label("Primeiro painel"), "Primeiro");
44    central.add(new Label("Segundo painel"), "Segundo");
45    central.add(new Label("Terceiro painel"), "Terceiro");
46    central.add(new Label("Quarto painel"), "Quarto");
47    central.add(new Label("Quinto painel"), "Quinto");
48    }
49    public static void main(String[] args) {
50    JanelaCard jc = new JanelaCard();
51    jc.setVisible(true);
52    }
53    }
 

Nesse exemplo, o rótulo “Primeiro painel” é inicialmente exibido por estar no topo da pilha do objeto Panel com gerenciador do tipo CardLayout. Se o botão “Próximo” for pressionado, o rótulo “Segundo painel” será exibido.

​

GridBagLayout

GridBagLayout é o gerenciador de layout mais flexível dentre aqueles pré-definidos em ja- va.awt; é também, em decorrência dessa flexibilidade, o mais complexo. É uma implementação de LayoutManager2 que permite, como GridLayout, arranjar componentes ao longo de uma matriz de linhas e colunas.

 

No entanto, componentes podem ser acrescentados em qualquer ordem e podem também variar em tamanho, podendo ocupar mais de uma linha ou coluna. Uma vez que o desenho da interface tenha sido especificado, a chave para a utilização desse gerenciador é a criação de um objeto de restrição de posicionamento. Esse objeto é da classe Grid- BagConstraints. Objetos da classe GridBagConstraints determinam como um gerencia- dor do tipo GridBagLayout deve posicionar um dado componente em seu container.

Uma vez que esse objeto tenha sido criado e suas restrições especificadas, basta associar essas restrições ao componente usando o método setConstraints() e adicioná-lo ao container com o método add() com o segundo parâmetro de restrições. A especificação das restrições de posiciona- mento, tamanho e propriedades de um componente nesse tipo de gerenciador é determinada através da atribuição de valores a campos públicos do objeto da classe GridBagConstraints.

​

O posicionamento é especificado pelas variáveis gridx e gridy, respectivamente para indicar

a coluna e a linha onde o componente deve ser posicionado. Para gridx, o valor 0 indica a coluna mais à esquerda.  Do mesmo modo, para gridy o valor 0 indica a linha mais ao topo.  Além de

valores absolutos de posicionamento, essa classe define a constante RELATIVE para posicionamento relativo, após o último componente incluído, sendo esse o valor padrão para esses campos.

​

O número de células que o componente ocupa no grid é indicado pelas variáveis gridwidth e gridheight, relacionadas respectivamente ao número de colunas e ao número de linhas que será ocupado pelo componente. O valor REMAINDER para esses campos indica que o componente será o último dessa linha ou coluna, devendo ocupar a largura ou altura restante. O valor padrão desses campos é 1.

​

Outras variáveis de restrição definidas nessa classe incluem weightx, weighty, fill e an- chor. Os atributos weightx e weighty indicam o peso, ou a prioridade, que o componente terá para receber porções de espaço extra horizontalmente ou verticalmente, respectivamente, quando o container é redimensionado e espaço adicional torna-se disponível. O padrão é um componente não receber espaço extra (valor 0).

​

O atributo  fill é utilizado quando a área para a apresentação do componente  é maior que  o tamanho natural do componente. Indica como a apresentação do componente irá ocupar a área disponível, podendo assumir os valores definidos em constantes da classe: NONE, não modifica o tamanho do componente (o padrão); VERTICAL, ocupa o espaço vertical mas não altera a largura do componente; HORIZONTAL, ocupa o espaço disponível na horizontal mas não altera a altura do componente; e BOTH, ocupa os espaço disponível nas duas dimensões.

​

O atributo anchor é utilizado quando o tamanho do componente é menor que a área da célula à qual ele foi alocado para indicar a posição do componente na célula. O padrão é CENTER, mas outros valores possíveis são NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, NORTHWEST.

Esse exemplo de código ilustra a criação de uma janela com três regiões, sendo que a primeira região contém uma lista, a segunda um grupo de três botões e a terceira uma área de texto:

1    import java.awt.*;
2    import java.awt.event.*;
3    public class JanelaGridBag extends Frame {
4    GridBagLayout gb = new GridBagLayout();
5    private final int noLinhas = 3;
6    public JanelaGridBag() {
7    setTitle("GridBagLayout");
8    setSize(320,200);
9    setLayout(gb);
10    List lEsq = new List(noLinhas, true);
11    lEsq.add("Um");
12    lEsq.add("Dois");
13    lEsq.add("Tres");
14    lEsq.add("Quatro");
15    lEsq.add("Cinco");
16    lEsq.add("Seis");
17    lEsq.add("Sete");
18    Button add = new Button(">>");
19    Button clear = new Button("Clear");
20    Button close = new Button("Close");
21    TextArea tDir = new TextArea("", noLinhas,
22    10, TextArea.SCROLLBARS_NONE);
23    GridBagConstraints gc = new GridBagConstraints();
24    gc.gridx = 0;
25    gc.gridy = 0;
26    gc.gridwidth = 1;
27    gc.gridheight = 3;
28    gc.fill = GridBagConstraints.VERTICAL;
29    add(lEsq, gc);
30    gc.gridx = 2;
31    add(tDir, gc);
32    Insets margens = new Insets(4, 3, 4, 3);
33    gc.gridx = 1;
34    gc.gridy = 0;
35    gc.gridwidth = 1;
36    gc.gridheight = 1;
37    gc.fill = GridBagConstraints.BOTH;
38    gc.ipadx = 4;
39    gc.ipady = 4;
40    gc.insets = margens;
41    add(add, gc);
42    gc.gridy = 1;
43    add(clear, gc);
44    gc.gridy = 2;
45    add(close, gc);
46    }
47    public static void main(String[] args) {
48    JanelaGridBag jgb = new JanelaGridBag();
49    jgb.setVisible(true);
50    }
51    }
 

BoxLayout

​

Swing oferece um gerenciador de layout simples, com alto grau de flexibilidade, que é o Box- Layout. Nesse tipo de layout, componentes podem ser dispostos em uma única linha ou em uma única coluna, porém arranjos de componentes bem complexos podem ser obtidos através da combi- nação desses mecanismos.

Em BoxLayout os componentes mantêm sua dimensão natural, como em FlowLayout. A direção na qual os componentes serão dispostos — se da esquerda para a direita ou se de cima  para baixo — pode ser especificada no construtor da classe, através respectivamente das constantes X_AXIS ou Y_AXIS.

​

Tipicamente, esse tipo de layout não é utilizado diretamente, mas sim através de um container

do tipo Box, que adota BoxLayout como padrão único de gerenciamento de layout.

Esse código ilustra a construção de uma interface similar àquela usando GridBagLayout, porém construída usando caixas aninhadas:

​

1    import javax.swing.*;
2    public class JanelaBox extends JFrame {
3    public JanelaBox() {
4        setTitle("BoxLayout");
5        setSize(240,120);
6        Box h = Box.createHorizontalBox();
7        Box v = Box.createVerticalBox();
8        String[] lista = {"Um", "Dois", "Tres", "Quatro",
9        "Cinco", "Seis", "Sete"};
10        JList jl = new JList(lista);
11        jl.setFixedCellWidth(70);
12        int mis = ListSelectionModel.MULTIPLE_INTERVAL_SELECTION;
13        jl.setSelectionMode(mis);
14        JScrollPane lEsq = new JScrollPane(jl);
15        lEsq.setMinimumSize(new java.awt.Dimension(100,100));
16        JButton add = new JButton(">>");
17        JButton clear = new JButton("Clear");
18        JButton close = new JButton("Close");
19        JTextArea tDir = new JTextArea();
20        v.add(add);
21        v.add(clear);
22        v.add(close);
23        h.add(lEsq);
24        h.add(v);
25        h.add(tDir);
26        getContentPane().add(h);
27        }
28        public static void main(String[] args) {
29        JanelaBox jb = new JanelaBox();
30        jb.setVisible(true);
31        jb.validate();
32        }
33    }