Gestão de Componentes

Menus:

Exemplo de Menu

Para criar um menu é necessário acrescentar ao formulário um JMenuBar, que serve de contentor para menus e items de menu:

De seguida acrescenta-se um Jmenu:

O Jmenu pode comportar:

Para adicionar um atalho deve-se ir à propriedade accelerator, do menu item em questão, e adicionar a combinação de teclas pretendidas:

A cada item deve ser adicionada um evento do tipo ActionPerformed, para que o clique possa ter uma acção.

Exemplo:

private void menuIsalvarActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

Salvar();

}

Menus de contexto:

Exemplo de Menu que surge quando se clica na tecla direita do rato

Deve ser adicionado o componente JPopupMenu ao formulário

Depois através da janela do Inspector do Netbeans clicar com a tecla direita sobre o JPopupMenu, e em ‘Add From Palette’ adicionar o que entender que seja necessário ao menu de contexto.

Tendo o menu de contexto construído é necessário associa-lo a um componente, que depois em tempo de execução da aplicação, ele aparecerá quando clicar com a tecla direita do rato. Para isso na propriedade componentePopupMenu, do componente em questão, escolhe-se o nome do JPopupMenu anteriormente construído.

Barra de ferramentas:

Deve ser adicionado um JToolBar, que serve de suporte para colocar componentes JButtons ou JToggleButtoms

JButtons ou JToggleButtoms:

Formulário “secundário”:

Para que seja possível, a partir do formulário principal, lançar um formulário “secundário” deve ser adicionado o JDialog ao formulário principal.

Abas:

Exemplo de abas

Para ter abas na aplicação deve ser adicionado um JTabbedPane, ao formulário:

Ao JTabbedPane colocado no formulário é necessário colocar JPanels para que seja possível ter várias abas. Ter em atenção que ao adicionar um JPanel, a ponta do cursor ao arrastar o JPanel deve estar próxima da aba já existente:

Introdução à Programação com Componentes

Programação com componentes

• A tecnologia de programação com componentes é especialmente importante no desenvolvimento de aplicações que são distribuídas por várias máquinas, uma vez que a distribuição dos componentes pelas máquinas é mais fácil do que se forem utilizadas outras tecnologias

• A programação com componentes pretende aumentar o grau de reutilização do software, no entanto, o seu sucesso apenas foi significativo no desenvolvimento das interfaces gráficas das aplicações.

• A ideia base de programação com componentes é possibilitar o desenvolvimento de aplicações apenas através da colagem de peças de software (componentes) já existentes.

O que são componentes?

• Um componente pode ser um bloco de código, uma função, um objecto ou uma aplicação, ao qual foi adicionada lógica para implementar uma interface.

• Um componente é uma peça de software (i.é., executável) que implementa uma determinada funcionalidade (interface) e que pode ser configurada (alterando as propriedades do componente) em função do contexto onde é utilizada.

• Cada componente implementa um conjunto de serviços (i.é., interfaces que implementa) e pode basear-se em serviços fornecidos por outros componentes (i.é., pode utilizar interfaces implementados outros componentes) • Os componentes são frequentemente utilizados em ambientes de programação visual, os quais devem ser capazes de determinar os interfaces implementados por cada componente e os interfaces que cada componente utiliza

Como são construídas as aplicações com componentes

• A programação por componentes permite desenvolver aplicações simplesmente através da colagem de vários componentes, possivelmente de diferentes fabricantes. A “colagem” consiste em identificar as interligações entre componentes as propriedades de cada componente

• Uma forma de desenvolver aplicações baseadas em componentes é utilizando um ambiente visual de programação que permite, através de uma interface gráfica, fazer a configuração da aplicação

Introdução aos Componentes do GUI em Java

Historial do GUI (Graphical User Interface) de Java

• Java 1.0 incluía a versão inicial do Abstract Window Toolkit (AWT), que continha várias limitações, nomeadamente uma GUI medíocre em todos os sistemas e não adoptava uma filosofia orientada por objectos.

• Java 1.1 melhorou o AWT original, com uma aproximação mais “limpa” e orientada ao objecto, juntamente com a adição de JavaBeans, um modelo de programação por componentes orientado para a criação de ambientes de programação visuais

• Java 2 terminou a transformação com a substituição de todos os elementos da GUI por um novo conjunto, designado por Swing (classes javax.swing), presente nas Java Foundation Classes (JFC)

Introdução aos Applets

• São pequenos programas em Java que executam num browser Web

• Por serem executados no browser dos clientes os applets devem ser seguros, razão que leva a que sejam limitadas as operações realizadas, ex: não podem aceder ao disco local, todas as classes necessárias ao applet devem ser empacotadas num ficheiro JAR (Java Archive)

• Não é necessário instalar os applets e estes são verdadeiramente portáveis e seguros.

• Os applets devem estender a classe JApplet, devendo redefinir os seguintes métodos:

void init(); // invocado quando é iniciado

void destroy(); // invocado quando é terminado

void start(); // invocado quando recebe a atenção

void stop(); // invocado quando perde a atenção

os métodos start() e stop() também são invocados, em init() e destroy().

• Exemplo:

import javax.swing.*;

import java.awt.*

public class Applet1 extends JApplet {

public void init() {

getContentPane().add(new JLabel(“App1″));

}

}

• O applet anterior pode ser incorporado numa página www através de seguinte código:

<applet code=Applet1.class width=100 height=50></applet>

• O utilitário appletviewer do JDK permite visualizar um applet.

• É possível construir uma classe que é um applet e que também pode ser executada como uma aplicação normal, a partir da linha de comando.

Para tal basta incluir a applet numa JFrame, adicionando o seguinte main() à definição do applet:

public static void main(String[] str) {

JApplet ap = new Applet1();

JFrame frame = new JFrame(“Appx”);

frame.getContentPane().add(ap);

frame.setSize(100,50);

ap.init(); // simula o focos do browser

ap.start();

frame.setVisible(true); // torna visível

}

Componentes da interface Swing

• O método getContentPane() permite obter o Container actual, o qual utiliza o padrão composto, onde add(Componet c) adiciona um componente ao composto e o método setLayout(LayoutManager mgr) indica a estratégia de posicionamento dos elementos (é um padrão do tipo estratégia). Button(String) é um componente que implementa um botão.

public class Applet1 extends JApplet {

public void init() {

Container ct = getContentPane();

// altera a estratégia de colocação dos elem

ct.setLayout(new FlowLayout());

ct.add(new JButton(“Botão1″));

ct.add(new JButton(“Botão2″));

}

}

Introdução aos Componentes JavaBeans

Programação com componentes em Java (JavaBeans)

• JavaBeans é uma arquitectura de componentes de software em Java, surgindo após o sucesso do Microsoft Visual Basic e do Borland Delphi. Esta arquitectura proporciona a interoperabilidade entre componentes e ferramentas de vários fabricantes, para além da independência da plataforma, assegurada para própria linguagem Java.

• Em JavaBeans, um componente é constituído por uma classe Java, sendo apenas necessárias pequenas alterações para tornar uma classe Java num Bean, o que torna o desenvolvimento de componentes extremamente simples em Java.

• Na programação por componentes é necessária uma ferramenta que permita a configuração e a ligação de um conjunto de beans, formando uma aplicação.

• A arquitectura JavaBeans baseia-se em propriedades que permitem controlar o comportamento do objecto, podendo ser variáveis de estado; em métodos que são invocados para executar código no componente e em eventos que são notificações geradas quando o objecto altera o estado.

• As ferramentas visuais de programação com JavaBeans permitem editar graficamente as propriedades dos componentes e visualmente associar os eventos gerados por um componente a invocações de métodos noutros componentes. Esta última operação é implementada através da utilização do padrão Observador e de Adaptadores para tornar as interfaces compatíveis.

• As ferramentas de desenvolvimento de aplicações por componentes baseiam-se num mecanismo designado por introspecção, que permite determinar as propriedades, eventos e métodos de cada componente.

Bibliotecas

O que é classpath?

No contexto da plataforma Java, é uma variável de ambiente que diz ao compilador e à JVM onde encontrar as classes que o software irá utilizar.

Configurando o Classpath de um Projecto no NetBeans

Na janela Projects, localize o projecto em questão – Registo, no neste caso – clique com o botão direito do rato em Libraries. Selecione Add Library… no menu de contexto.

A janela Add Library irá aparecer, no entanto ainda não adicionamos a API ao conjunto de bibliotecas disponíveis no NetBeans. Por isso, clique em Create.

Defina o nome e o tipo da biblioteca, na caixa de diálogo Create New Library – SwingX e Class Libraries respectivamente.

Clique em Add JAR/Folder… e navegue até o directório onde a API está localizada.

Faça o mesmo nas abas Sources e Javadoc, indicando o caminho para o directório com o código-fonte da biblioteca no primeiro caso, e da documentação, no segundo. Nem sempre, a API inclui o seu código-fonte e documentação. Nesse caso, não há problema – o importante mesmo é o classpath.

Clique em Ok para voltar à caixa de diálogo Add Library, selecione a biblioteca e clique em Add Library.

De seguida vá à palete, clicando com a tecla direita do rato escolha Palette Manager.

Clique em New Palette Category:

A seguir clique em Add form Library e escolha SwingX e clique em Next. O Gerenciador da Paleta irá procurar por componentes disponíveis. Isto é, irá procurar classes que estejam de acordo com a especificação JavaBeans.

SwingX

Contém extensões para o toolkit GUI Swing, incluindo novos e aprimorados componentes que fornecem funcionalidades comummente requisitadas por aplicações. Destaques incluem:

* Ordenamento, filtragem, destaques (highlighting) para tabelas, árvores (trees) e listas

* Find/Search

* Auto-complemento

* Framework para autenticação/login

* Componente TreeTable

* Collapsible Panel (painel dobrável)

* Componente Date Picker (seletor de datas)

* Componente Tip-of-the-Day (dica-do-dia)

SwingX é um subprojecto do SwingLabs, que conta com suporte da Sun Microsystems e com a participação de alguns dos mais importantes engenheiros da Sun responsáveis pelo Swing. Requer pelo menos JDK 5 e é licenciado sob LGPL.

SwingLabs serve para implementação e teste de ideias relacionadas à tecnologia voltada para o desenvolvimento de GUI’s (Graphical User Interface) para clientes ricos. Experimentos bem-sucedidos serão considerados para inclusão em versões futuras do JDK (Java Development Kit).

Todos os componentes do projecto SwingLabs, incluindo portanto os componentes SwingX, são focados para uso em ambiente de produção. Entretanto, a Sun não oferece qualquer garantia de suporte e desenvolvimento presente ou futuro para qualquer desses componentes.

Componentes SwingX

* JXCollapsiblePane

* JXComboBox

* JXDatePicker

* JXEditorPane

* JXErrorPane

* JXFindBar

* JXFindPanel

* JXFrame

* JXGlassBox

* JXHyperlink

* JXImagePanel

* JXList

* JXLoginDialog

* JXLoginPanel

* JXMonthView

* JXPanel

* JXRadioGroup

* JXRootPane

* JXSearchPanel

* JXStatusBar

* JXTable

* JXTableHeader

* JXTaskPane

* JXTaskPaneContainer

* JXTipOfTheDay

* JXTitledPanel

* JXTree

* JXTreeTable

SwingX em IDE’s

Componentes SwingX são JavaBeans, por isso podem ser adicionados à paleta de componentes de uma IDE (NetBeans, Eclipse, Intellij) e usados para a construção de GUI’s.