Desenvolvimento Código Aberto

Painel deslizante é um componente da interface gráfica que permite que o usuário redimensione componentes contidos normalmente dentro de duas células que podem ser posicionadas na horizontal ou vertical.

JSplitPane é usada para dividir dois (e somente dois) componentes. Os dois componentes são graficamente divididos de acordo com o look and feel de implementação, e os dois componentes podem ser interativamente redimensionados pelo usuário.

JSplitPane

Exemplo:

Neste exemplo criamos um painel de rolagem divido na horizontal que contem dois componentes que podem ser redimensionados pelo usuário, respeitando o tamanho mínimo de cada componente.

Java

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;

import javax.imageio.ImageIO;
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextArea;

public class Spliter {

	// Declara componentes 
	URL url;
	BufferedImage imagem;
	
	// Declara variaveis
	String txt = "O balonismo é um esporte aeronáutico praticado com um balão de ar quente.\n"+
		         "Possui adeptos em todo o mundo. No Brasil, o esporte começou a se popularizar\n" +
			     "a partir dos anos 90.\n"+
			     "O balão é considerado uma aeronave assim como avião, helicópteros e outros.\n" +
			     "Por esta razão o balão deve ter uma matricula (prefixo) registrado junto\n" +
			     "à ANAC, seu piloto deve possuir uma licença (brevê) específico para a pratica\n" +
			     "do balonismo também emitido pela ANAC.";
	
	public Container criaPainel()
	{
		// Cria painel principal
		JPanel painel = new JPanel();
		
		// Define layout
		painel.setLayout(new BorderLayout());
		painel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
		
		// Cria area de texto
		JTextArea area = new JTextArea(txt);
		
		// Cria painel para area
		JScrollPane areap = new JScrollPane(area);
		
		// Cria componente para imagem
		JLabel figura = new JLabel();
		
		// Tenta ler a imagem da internet
		try
	    {
			// Carrega imagem
			url = new URL("https://desenvolvimentoaberto.org/wp-content/uploads/2014/04/balonismo.jpg?");
	        imagem = ImageIO.read(url);	        
	    }	     
		catch ( IOException e)	
		{           
			e.printStackTrace();		
		}
		
		// Mostra imagem
		ImageIcon fig = new ImageIcon(imagem);
	    figura = new JLabel(fig);
	     
	    // Cria painel da imagem
	    JScrollPane imagemp = new JScrollPane(figura);
	     
	    // Cria painel de rolagem
	    JSplitPane painels = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, imagemp, areap);
	     	          
	    // Define tamanho minimo para os componentes
	    Dimension tamanhom = new Dimension(200,100);
	     
	    // Seta tamanho minimo
	    area.setMinimumSize(tamanhom);
	    figura.setMinimumSize(tamanhom);
	     
	    // Define painel como opaco
	    painel.setOpaque(true);
	    
	    // Adiciona paineis
	    painel.add(painels);

		return painel;
	}
	
	public static void criaGui()
	{
		// Cria formulario
		JFrame formulario = new JFrame("DA - Painel Deslizante");
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		// Cria nova instancia e da classe
		Spliter spliter = new Spliter();
		
		// Adiciona painel ao formulario
		formulario.setContentPane(spliter.criaPainel() );
		
		// Define propriedades do formulario
		formulario.pack();
		formulario.setVisible(true);
		
	}

	public static void main(String[] args) {

		javax.swing.SwingUtilities.invokeLater(new Runnable() {
			
			@Override
			public void run() {
				// Exibe GUI na thread do swing
				criaGui();
				
			}
		});
	}
}

Em computação caixas de diálogo reutilizáveis ​​que são comuns a todas as aplicações, incluindo caixas de diálogo para abrir arquivos, salvar arquivos e impressão. Uma vez que estas caixas de diálogo são implementadas pelo sistema operacional, ou classes no caso de linguagens multi plataforma,  podem ser compartilhadas entre todos os aplicativos que são executados no sistema operacional, o que ajuda o usuário a experiência de consistência; quando os usuários estão familiarizados com o uso de uma caixa de diálogo de funcionamento fornecido pelo sistema em um aplicativo, eles não precisam aprender a usar essa caixa de diálogo em outras aplicações. Como essas caixas de diálogo estão disponíveis para todas as aplicações e porque ajudam a proporcionar uma experiência de usuário consistente,

JFileChooser

Fornece uma interface gráfica para navegar no sistema de arquivos, e em seguida, escolher um arquivo ou pasta a partir de uma lista ou digitando o nome de um arquivo ou diretório. Para exibir um seletor de arquivos, você costuma usar a JFileChooser API para mostrar uma caixa de diálogo modal que contém o seletor de arquivos.

Caixa de Diálogo

Exemplo:

Neste exemplo usamos as caixas de diálogos no modo abrir e salvar arquivos para executar estes eventos sobre uma área de texto através de um buffer de escrita e leitura.

Java

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;


public class Dialogo implements ActionListener {
	
	// Declara componentes
	JLabel rotulo;
	JTextArea texto;
	JScrollPane barra;
	JButton botao1, botao2;
	JFileChooser dlg;
	BufferedReader buffer;
	
	// Declara variaveis
	String linha;
	
	public Container criaPainel()
	{
		// Cria painel principal
		JPanel painel = new JPanel();
		
		// Define layout
		painel.setLayout(new BorderLayout());						
		painel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
		
		// Cria componentes
		rotulo = new JLabel("Digite abra ou salve um texto");
		texto = new JTextArea();
		barra = new JScrollPane(texto);
		botao1 = new JButton("Abrir");
		botao2 = new JButton("Salvar");
		dlg = new JFileChooser();
				
		// Cria barras de rolagem
		barra.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
		barra.setPreferredSize(new Dimension(300, 200));
			
		// Alinha componentes
		rotulo.setAlignmentX(Component.CENTER_ALIGNMENT);
						
		// Define eventos dos botões
		botao1.addActionListener(this);
		botao2.addActionListener(this);
		
		// Cria novos paineis
		JPanel painel1 = new JPanel();
		JPanel painel2 = new JPanel();
		
		// Cria layouts
		painel1.setLayout(new BoxLayout(painel1, BoxLayout.PAGE_AXIS));
		painel2.setLayout(new BoxLayout(painel2, BoxLayout.X_AXIS));		
		
		// Adiciona componentes aos paineis
		painel1.add(rotulo);
		painel1.add(Box.createVerticalStrut(10));
		painel1.add(barra);
		painel1.add(Box.createVerticalStrut(10));
		
		painel2.add(botao1);
		painel2.add(botao2);
				
		// Adiciona paineis ao painel principal
		painel.add(painel1, BorderLayout.PAGE_START);
		painel.add(painel2, BorderLayout.CENTER);			
		
		return painel;
	}
	
	@Override
	public void actionPerformed(ActionEvent arg0) 
	{
	 
		// Cria evento para os botões
		if (arg0.getSource() == botao1)
		{
			// Cria variavel de dialogo
			int retorno = dlg.showOpenDialog(texto);
			
			// Verifica dialogo
			if (retorno == JFileChooser.APPROVE_OPTION)
			{
				// Retorna nome do arquivo
				File arquivo = dlg.getSelectedFile();
				
				// Cria um buffer para o arquivo
				try 
				{					
					 buffer = new BufferedReader(new FileReader(arquivo));
				} 
				
				catch (FileNotFoundException e)				
				{
					e.printStackTrace();
				}				
				
				// Lê as linhas do buffer
				try 
				{
					linha = buffer.readLine();
				}
				
				catch (IOException e) 
				{
					e.printStackTrace();
				}
				
				// Laço nas linhas do arquivo
				while (linha != null)
				{
					// Adiciona linha na area de texto
					texto.append(linha + "\n");
					
					try {
						linha = buffer.readLine();
					} 
					catch (IOException e) 
					{						
						e.printStackTrace();
					}
					
				}
			}
		}
		
		// Cria evento para o botão
		if (arg0.getSource() == botao2)
		{
		
			int retorno = dlg.showSaveDialog(texto);
			
			if (retorno == JFileChooser.APPROVE_OPTION)
			{
				File arquivo = dlg.getSelectedFile();
				
				// Cria buffer e grava o arquivo;
				try 
				{
					BufferedWriter grava = new BufferedWriter(new FileWriter(arquivo));
					grava.write(texto.getText());
					grava.close();
				}
				catch (IOException e) 
				{				
					e.printStackTrace();
				}
			}	
			
		}
		
	}

	public static void criaGUI()
	{	
	  // Cria formulario
	  JFrame formulario = new JFrame("DA - Dialogos");
	  formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	  
	  Dialogo dialogo = new  Dialogo();
	  
	  formulario.setContentPane(dialogo.criaPainel());
	  
	  formulario.pack();;
	  formulario.setVisible(true);
	}
	
	public static void main(String[] args) {
		
		javax.swing.SwingUtilities.invokeLater(new Runnable() {
			
			@Override
			public void run() {
			
				// Thread do swing
				criaGUI();
				
			}
		});
	}
}

A Barra de ferramentas é um componente utilizado pelos softwares com interface gráfica (GUI) com a finalidade de permitir uma ação rápida por parte do usuário, facilitando o acesso a funções do programa. Uma das suas características é possuir ícones para as operações mais corriqueiras e representar através de imagens operações que poderiam demandar uma grande quantidade de informações para chegar ao mesmo objetivo.

JToolBar

Proporciona um componente que é útil para indicar ações ou comandos muito utilizado, gerando atalhos através de uma barra de tarefas. Caso queira que a barra de ferramentas possua a funcionalidade drag and drop, você precisa cria-la em um BorderLayout.

JToolBar

Exemplo:

Neste exemplo criamos uma barra de tarefas utilizando botões e seus eventos de clique. Para testar este exemplo você precisa de imagens de ícones do formato PNG, as imagens podem ser baixadas neste link: http://www.iconesbr.net/icone/Linux

Java

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JToolBar;

public class BarraFerramenta implements ActionListener {

	// Declara componentes
	JToolBar ferramenta;
	JLabel rotulo;
	JButton botao = null;

	public Container criaPainel()
	{
		// Cria painel
		JPanel painel = new JPanel();

		// Define layout
		painel.setLayout(new BorderLayout());
		painel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));

		// Cria componentes
		ferramenta = new JToolBar();
		rotulo = new JLabel("Evento da barra de ferramentas");

		botao  = criaBotao("9445_128x128", "BNT1");
		ferramenta.add(botao);

		botao  = criaBotao("9450_128x128", "BNT2");
		ferramenta.add(botao);

		botao  = criaBotao("9451_128x128", "BNT3");
		ferramenta.add(botao);

		// Adiciona componentes ao painel
		painel.add(ferramenta, BorderLayout.PAGE_START);
		painel.add(Box.createVerticalStrut(20));
		painel.add(rotulo, BorderLayout.PAGE_END);

		return painel;
	}

	private JButton criaBotao(String icone, String acao) 

	{
		// Cria botões
		JButton bto = new JButton();
		String caminho = "C:/Desenvolvimento Aberto/" + icone + ".png";

		// Define eventos
		bto.setActionCommand(acao);
		bto.addActionListener(this);

		// Adiciona imagem
		bto.setIcon(new ImageIcon(caminho, "Icone"));

		return bto;
	}

	public void actionPerformed(ActionEvent arg0)
	{
		// Eventos dos botões
		String acao = arg0.getActionCommand();

		if (acao == "BNT1" )
		{
			rotulo.setText("Você clicou no botão 1");
		}

		if (acao == "BNT2" )
		{
			rotulo.setText("Você clicou no botão 2");
		}

		if (acao == "BNT3" )
		{
			rotulo.setText("Você clicou no botão 3");
		}		

	}

	public static void criaGUI()
	{
		// Cria Formulario
		JFrame formulario = new JFrame("DA - Barra de Ferramentas");
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		// Instancia da classe
		BarraFerramenta barra = new BarraFerramenta();

		// Adiciona painel ao formulario
		formulario.setContentPane(barra.criaPainel());

		formulario.pack();
		formulario.setVisible(true);	

	}

	public static void main(String[] args) {

		javax.swing.SwingUtilities.invokeLater(new Runnable() {

			@Override
			public void run() {

				// Cria GUI
				criaGUI();

			}
		});
	}
}

Em computação, um tree view (literalmente do inglês vista de árvore) é um elemento de interface gráfica (isto é um componente widget) que permite ao usuário mostrar dados hierárquicos em forma de árvore, expandir ou recolher os ramos e nós. Dependendo do wiget toolkit ou aplicação em uso, existem muitos estilos de apresentação gráfica de tree views.

JTree

Um controle que exibe um conjunto de dados hierárquicos como um esboço.

DefaultTreeModel

Um modelo simples de dados em árvore que usa nós em uma árvore.

DefaultMutableTreeNode

É um nó de uso geral em uma estrutura de dados em árvore.

JTree – Tree View

Exemplo:

Neste exemplo usamos uma visão de arvore para exibir uma discografia musical, você pode abrir e fechar os nós do modelo de dados em visão de  árvore, um duplo clique do mouse em cada nó dispara um evento para que exibido a descrição do nó corrente em um rodapé.

Java

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.ScrollPane;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeSelectionModel;

public class Arvore {

	// Declara componentes
	JLabel rotulo;
	JLabel rodape;
	JTree disco;
	DefaultTreeModel modelo;
	DefaultMutableTreeNode titulo;

	// Declara variaveis e Arrays
	String albumB = "Please, Please Me";

	String[] MusicaB = {  "I Saw Her Standing There",  "Misery",  "Anna (Go to Him)",
			    "Chains" ,  "Boys" , "Ask Me Why",  "Please Please Me",  "Love Me Do" ,
			    "P.S. I Love You",  "Baby It's You",  "Do You Want To Know A Secret?",
			    "A Taste of Honey",  "There's A Place",  "Twist and Shout"	};

	String albumR = "The Rolling Stones";

	String [] MusicaR ={ "Route 66", "I Just Want to Make Love to You", "Honest I Do",
			   "Mona (I Need You Baby)",  "You Can Make It If You Try", "Little by Little",
			   "I\'m a King Bee", "Carol", "Tell Me (You \'re Coming Back)", "Can I Get a Witness",
			   "Tell Me (You\'re Coming Back)",  "Walking the Dog" };   

	public Container criaPainel()
	{
		// Cria painel
		JPanel painel = new JPanel();

		// Define laylout
		painel.setLayout(new BoxLayout(painel, BoxLayout.PAGE_AXIS));
		painel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));

		// Cria componentes
		rotulo = new JLabel("Duplo clique em um nó da arvore:");
		rodape = new JLabel("Evento do mouse");

		titulo = new DefaultMutableTreeNode("Discografia");
		modelo = new DefaultTreeModel(titulo);
		disco = new JTree(modelo);

		// Alinha componente4s
		rotulo.setAlignmentX(Component.CENTER_ALIGNMENT);
		rodape.setAlignmentX(Component.CENTER_ALIGNMENT);

		// Cria evento do mouse
		disco.addMouseListener(new MouseAdapter()
		{
			// Duplo clique do mouse
			public void mouseClicked(MouseEvent e)
			{
				if (e.getClickCount() == 2 )
				{
					// retorna texto da arvore
					rodape.setText(disco.getLastSelectedPathComponent().toString());
				}

			}
		});

		// Define propriedades da arvore
		disco.setEditable(true);
                  disco.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
                  disco.setShowsRootHandles(true);

                  // Cria painel de rolagem
		ScrollPane barra = new ScrollPane();

		// Define tamanho do painel
		barra.setPreferredSize(new Dimension(300, 500));

		// Cria Nodes da arvore
		DefaultMutableTreeNode b1 = new DefaultMutableTreeNode("Beatles");
		DefaultMutableTreeNode b2 = new DefaultMutableTreeNode("Rolling Stones");

		DefaultMutableTreeNode a1 = new DefaultMutableTreeNode(albumB);
		DefaultMutableTreeNode a2 = new DefaultMutableTreeNode(albumR);

		DefaultMutableTreeNode m1;
		DefaultMutableTreeNode m2; 

		// Adiciona nodes na arvore
		titulo.add(b1);
		titulo.add(b2);

		b1.add(a1);
		b2.add(a2);

		// Adicina lista de musicas
		for (int i = 0; i < MusicaB.length; i++)
		{
			m1 = new DefaultMutableTreeNode (MusicaB[i]);
			a1.add(m1);
		}

		for (int i = 0; i < MusicaR.length; i++)
		{
			m2 = new DefaultMutableTreeNode (MusicaR[i]);
			a2.add(m2);
		}

		// Adiciona arvore ao painel de rolagem
		barra.add(disco);	

		// Adiciona componentes ao painel
		painel.add(rotulo);
		painel.add(Box.createVerticalStrut(10));
		painel.add(barra);
		painel.add(Box.createVerticalStrut(10));
		painel.add(rodape);

		return painel;

	}

	public static void criaGUI()
	{
		// Cria formulario
		JFrame formulario = new JFrame("DA - JTree");
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		// Cria classe arvore
		Arvore arvore = new Arvore();

		formulario.setContentPane(arvore.criaPainel());

		formulario.pack();

		formulario.setVisible(true);

	}

	public static void main(String[] args) {

		// Thread do swing
		javax.swing.SwingUtilities.invokeLater(new Runnable() {

			@Override
			public void run() {				

				// Chama a GUI
				criaGUI();
			}
		});

	}

}

O JTable é usado para exibir e editar tabelas bidimensionais regulares de células. O JTable tem muitas facilidades que tornam possível personalizar seu processamento e edição, mas fornece padrões para esses recursos para que tabelas simples possam ser configuradas facilmente.

TableColumn

Uma TableColumn representa todos os atributos de uma coluna em um JTable, como largura, expansão,  largura mínima e máxima. Além disso, o TableColumn oferece vagas para um processador e um editor que pode ser usado para exibir e editar os valores nesta coluna.

JTable

Exemplo:

Neste exemplo criamos uma variável Array responsável pela linha de titulo da tabela e um objeto vetor responsável pelos dados da tabela e os exibimos na grade de dados.

Java

import java.awt.Container;
import java.awt.Dimension;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.DefaultCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.TableColumn;


public class Tabela
{
	// Declara componentes	
	JTable tabela;
	
	// Declara Array e Matriz
	String colunas[] =  { "Album", "Artista",  "Musica", "Ano", "VideoClip" };
	
	Object  dados [][] = 		
	{			
		{"Nevermind", "Nirvana", "Smell Like Teen Spirit", new Integer(1991), new Boolean (true)},
		{"Ten", "Pearl Jam", "Jeremy", new Integer(1991), new Boolean (true)},
		{"Facelift", "Alice in Chains", "Man in the Box", new Integer(1990), new Boolean (true)},
		{"Badmotorfinger", "SoundGarden", "Outshined", new Integer(1991), new Boolean (true)},
		{"Sweet Oblivion", "Screaming Trees", "Nearly I Lost You", new Integer(1993), new Boolean (true)},
		{"Core", "Stone Temple Pilots", "Plush", new Integer(1992), new Boolean (true)},
			
	};
	
	public Container criaPainel()
	{
		// Cria painel
		JPanel painel = new JPanel();
		
		// Define Layout
		painel.setLayout(new BoxLayout(painel, BoxLayout.PAGE_AXIS));
		painel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
		painel.setOpaque(true);
		
		// Cria tabela
		tabela = new JTable(dados, colunas);		
		
		// Modifica ultima coluna
		JCheckBox box = new JCheckBox();
		TableColumn videoclip = tabela.getColumnModel().getColumn(4);
		videoclip.setCellEditor(new DefaultCellEditor(box));
		
		tabela.setPreferredScrollableViewportSize(new Dimension(600, 50));
		
		
		// Cria barra de rolagem
		JScrollPane barra = new JScrollPane(tabela);
			
		// Adiciona barra ao painel
		painel.add(barra);
		
		return painel;
		
	}
	
	public static void criaGUI()
	{
		// Cria formulario
		JFrame formulario = new JFrame("DA - Tabela - JTable");
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		// Instancia classe 
		Tabela tab = new Tabela();
		formulario.setContentPane(tab.criaPainel());
		
		formulario.setSize(500, 300);
		formulario.setVisible(true);
	}

	public static void main(String[] args) {
		
		javax.swing.SwingUtilities.invokeLater(new Runnable() {
			
			@Override
			public void run() {
				
				// Cria GUI
				criaGUI();
				
			}
		});

	}

}

Uma imagem digital é a representação de uma imagem bidimensional usando números binários codificados de modo a permitir seu armazenamento, transferência, impressão ou reprodução, e seu processamento por meios eletrônicos. Há dois tipos fundamentais de imagem digital. Uma é do tipo rastreio (raster) e outra do tipo vetorial. Uma imagem digital do tipo raster, ou bitmap, ou ainda matricial, é aquela que em algum momento apresenta uma correspondência bit-a-bit entre os pontos da imagem raster e os pontos da imagem reproduzida na tela de um monitor.

A imagem vetorial não é reproduzida necessariamente por aproximação de pontos, antes era destinada a ser reproduzida por plotters de traços que reproduziam a imagem por deslocamento de canetas-tinteiro.

Tipicamente, as imagens raster são imagens fotográficas, e as imagens vetoriais são desenhos técnicos de engenharia. Os quadrinhos ilustrados se assemelham em qualidade a imagens raster, mas são impressos em plotters que passaram a imprimir à maneira das impressoras comuns por jato de tinta.

Image

BufferedImage

A subclasse BufferedImage descreve uma imagem com um buffer de acesso de dados de imagem. A BufferedImage é composto de um modelo de cor e um Raster de dados de imagem.

ImageIcon

Uma implementação da interface do ícone que pinta ícones de imagens. Imagens que são criados a partir de uma URL, nome de um arquivo ou da matriz de bytes que são pré-carregados usando o MediaTracker para monitorar o estado de carga da imagem.

ImageIO

Uma classe que contém métodos de conveniência estáticos para localizar os leitores de imagem e gravadores de imagem, e realizar a codificação e decodificação simples.

Url

A classe URL representa um Uniform Resource Locator, um ponteiro para um “recurso” na World Wide Web. Um recurso pode ser algo tão simples como um arquivo ou um diretório, ou pode ser uma referência a um objeto mais complexo, como uma consulta a um banco de dados ou a um motor de busca.

Exemplo:

Neste exemplo carregamos uma imagem cujo sua fonte é uma Url da internet e  a exibimos em um componente de rótulos.

Java

import java.awt.Component;
import java.awt.Container;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;

import javax.imageio.ImageIO;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;


public class Imagem 
{
	// Declara componentes
	JLabel rotulo;
	JLabel figura;
	BufferedImage imagem;
	URL url;
	
	public Container criaPainel()
	{
		// Cria painel
		JPanel painel = new JPanel();
		
		// Cria layout
		painel.setLayout(new BoxLayout(painel, BoxLayout.PAGE_AXIS));
		painel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
		
		// Cria componentes
		rotulo = new JLabel("Imagem - Picture");		
		
		// Tenta abrir uma imagem de uma url
		try 
		{
			url = new URL("https://desenvolvimentoaberto.org/wp-content/uploads/2014/04/images.jpg");
			imagem = ImageIO.read(url);		
		}
		catch ( IOException e)
		{			
			e.printStackTrace();
		}
		
		// Cria uma figura e a exibe em um JLabel
		ImageIcon fig = new ImageIcon(imagem);
		figura = new JLabel(fig);		
		
		// Alinha componentes
		rotulo.setAlignmentX(Component.CENTER_ALIGNMENT);
		figura.setAlignmentX(Component.CENTER_ALIGNMENT);
		
		// Adiciona componentes ao painel
		painel.add(rotulo);
		painel.add(Box.createVerticalStrut(10));
		painel.add(figura);		
		
		return painel;
	}
	
	// Cria GUI 
	public static void criaGUI()
	{
		// Cria formulario
		JFrame formulario = new JFrame("DA - Image");
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		// cria nova instancia da classe
		Imagem pic = new Imagem();
		
		// Adiciona painel ao formulario
		formulario.setContentPane(pic.criaPainel());
		
		// Adiciona tamanho do formulario
		formulario.setSize(300,290);
		
		// Exibe formulario
		formulario.setVisible(true);
	}

	public static void main(String[] args) {
		
		// Thread do swing
		javax.swing.SwingUtilities.invokeLater(new Runnable() {	
			
			public void run() {
				// Mostra Gui
				criaGUI();				
			}
		});
	}
}

Uma barra de progresso é um componente de uma interface gráfica de usuário usado para visualizar a progressão de uma operação de computador estendida, como um download, transferência de arquivos, ou de instalação. Às vezes, o gráfico é acompanhada por uma representação textual do progresso em um formato por cento.

JProgressBar

Um componente que exibe visualmente o progresso de alguma tarefa. À medida que a tarefa avança para a sua conclusão, a barra de progresso exibe porcentagem da tarefa de conclusão. Esse percentual é normalmente representado visualmente por um retângulo que começa vazio e gradualmente se torna cheio mostrando como a tarefa progride. Além disso, a barra de progresso pode exibir uma representação textual desse percentual.

Thread.sleep

Faz com que o segmento atual suspenda a execução por um período determinado.

SwingWorker

O SwingWorker em si é uma classe abstrata; você deve definir uma subclasse, a fim de criar um objeto SwingWorker; classes internas anônimas são muitas vezes útil para a criação de objetos.

doInBackground

O método doInBackground () é chamado nesta para executar uma tarefa simultânea as demais tarefas, e é como todas as atividades de fundo devem acontecer. Para notificar a mudança de alguma propriedade use PropertyChangeListeners. Por padrão, existem duas propriedades ligadas disponíveis: state e progress.

PropertyChangeListeners

Um evento “PropertyChange” é disparado quando um objeto altera uma propriedade ligada a ele.

Processando Menssagens

Imagine uma barra de progresso que por padrão atinge um valor de 0 à 100, a principio podemos incrementar este valor no evento do clique do botão, porem a GUI sozinha não conseguirá atualizar os frames do andamento do status da barra progresso porque esta ocupada processando o contador do incremento, deste modo podemos ver o progresso vazio(0%) quando iniciar e cheio(100%) quando o contador chegar ao final, entretanto não poderemos ver o andamento desta porcentagem.  Para que possamos ver o andamento precisamos trabalhar os processos simultaneamente, em algumas linguagens de programação como o Delphi por exemplo temos o comando Application.ProcessMessages que executa este trabalho para nós. O Java possui uma classe abstrata chamada SwingWorker e podemos usa-la para executar um trabalho equivalente ao comando do Delphi para processar mensagens.

JProgressBar – SwingWorker

Exemplo:

Neste exemplo usamos um contador e um temporizador para simular uma tarefa e usamos a classe abstrata SwingWorker para processar o andamento da tarefa.

Java

import java.awt.Component;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.SwingWorker;

public class BarraProgresso implements ActionListener, PropertyChangeListener
{

	// Declara componentes
	JLabel rotulo;
	JProgressBar progresso;
	JButton botao;

	public Container criaPainel()
	{
		// Cria painel
		JPanel painel = new JPanel();

		// Cria layout
		painel.setLayout(new BoxLayout(painel,BoxLayout.PAGE_AXIS));
		painel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));

		// Cria componentes
		rotulo = new JLabel("Barra de progresso");
		progresso = new JProgressBar(0,100);
		botao = new JButton("Ok");

		// Alinha componentes
		rotulo.setAlignmentX(Component.CENTER_ALIGNMENT);
		progresso.setAlignmentX(Component.CENTER_ALIGNMENT);
		botao.setAlignmentX(Component.CENTER_ALIGNMENT);

		// Adiciona propriedade a barra de progresso
		progresso.setStringPainted(true);

		// Cria evento do botão
		botao.addActionListener(this);

		// Adiciona componentes ao painel
		painel.add(rotulo);
		painel.add(Box.createVerticalStrut(10));
		painel.add(progresso);
		painel.add(Box.createVerticalStrut(10));
		painel.add(botao);

		return painel;
	}

	// Cria classe SwingWorker para a propriedade progress
	class ProcessaMenssagem extends SwingWorker<Void, Void>
	{

		@Override
		public Void doInBackground() throws Exception {

			// Progresso inical
			setProgress(0);

			// cria contador
			for (int andamento = 0; andamento <= 100; andamento++)
			{
				// Cria um efeito de espera
				try
				{
					Thread.sleep(500);
				}
			    catch (InterruptedException e)
				{
					e.printStackTrace();
				}

				// Atualiza o contador
				setProgress(Math.min(andamento, 100));
			}

			return null;
		}

	}

	// Evento do botão
	public void actionPerformed(ActionEvent arg0)
	{

		if (arg0.getSource() == botao)
		{
			// Cria objeto de progresso
			ProcessaMenssagem processa = new ProcessaMenssagem();
			processa.addPropertyChangeListener(this);
			processa.execute();
		}

	}

	// Atualiza a propriedade do objeto
	public void propertyChange(PropertyChangeEvent evt) {

		if ("progress" == evt.getPropertyName())
		{
			int andamento = (Integer) evt.getNewValue();
			progresso.setValue(andamento);
		}
	}

	// Cria GUI
	public static void criaGUI()
	{
		// Cria formulario principal
		JFrame formulario = new JFrame("DA - Progress Bar");
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		// Cria instancia da classe
		BarraProgresso barra = new BarraProgresso();

		// Adiciona painel principal
		formulario.setContentPane(barra.criaPainel());

		formulario.setSize(300,150);

		formulario.setVisible(true);
	}

	public static void main(String[] args) {

		// Thread do swing
		javax.swing.SwingUtilities.invokeLater(new Runnable() {

			public void run() {
				criaGUI();
			}
		});

	}

}

Em interfaces gráficas de usuário (GUI), uma interface tabulada  ou um Tab Control  é um widget que permite a interação de vários documentos ou painéis para ser contido dentro de uma única janela, usando guias como um widget de navegação para alternar entre conjuntos de painéis.

JTabbedPane

Guias/ componentes são adicionados a um objeto JTabbedPane usando os métodos e AddTab ou insertTab. Uma aba é representada por um índice correspondente à posição em que foi adicionado em, em que a primeira guia tem um índice igual a 0 e a última aba tem um índice igual à contagem de guia menos 1.

Exemplo:

Neste exemplo criamos um painel tabulado com 3 guias onde na primeira e na segunda guia o usuário entrará com um numero inteiro e na terceira guia sobre o evento StateChange efetuaremos a soma dos números escolhidos.

Java

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.GridLayout;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import javax.swing.JTextField;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class TabControl implements ChangeListener
{
	// Declara componentes
	JLabel rotulo1;
	JLabel rotulo2;
	JLabel rotulo3;

	JPanel painel1;
	JPanel painel2;
	JPanel painel3;

	JTabbedPane abas;

	JTextField numero1;
	JTextField numero2;

	JLabel total;

	public Container criaPainel()
	{

		// Cria painel do formulario
		JPanel painel = new JPanel(new GridLayout(1,1));

		// Cria componentes
		rotulo1 = new JLabel("Escolha o primero numero inteiro:");

		rotulo2 = new JLabel("Escolha o segundo numero inteiro:");

		rotulo3 = new JLabel("Total da soma:");

		numero1 = new JTextField();

		numero2 = new JTextField();

		total = new JLabel("0");

		// Cria painel para a primeira aba
		painel1 = new JPanel(new BorderLayout());

		painel1.add(rotulo1, BorderLayout.PAGE_START);
		painel1.add(numero1, BorderLayout.CENTER);

		// Cria painel para a segunda aba
		painel2 = new JPanel(new BorderLayout());	

		painel2.add(rotulo2, BorderLayout.PAGE_START);
		painel2.add(numero2, BorderLayout.CENTER);

		// Cria painel para a terceira aba
		painel3 = new JPanel(new BorderLayout());

		painel3.add(rotulo3, BorderLayout.PAGE_START);
		painel3.add(total, BorderLayout.CENTER);

		// Cria abas
		abas = new JTabbedPane(); 

		// Adiciona paineis nas abas
		abas.addTab("Numeros 1", painel1);
		abas.addTab("Numeros 2", painel2);
		abas.addTab("Total", painel3);

		// Cria evento para as abas
		abas.addChangeListener(this);

		// Adiciona abas ao painel do formulario
		painel.add(abas);

		// Retorna painel principal
		return painel;
	}

	public void stateChanged(ChangeEvent arg0)
	{
		// Escolha indice da aba
		if (abas.getSelectedIndex() == 2)
		{
			// Efetua calculo
			int soma = Integer.parseInt(numero1.getText()) + Integer.parseInt(numero2.getText());
			total.setText( Integer.toString(soma));
		}

	}

	 // Cria GUI
		public static void criaGUI()
		{
			// Cria formulario principal
			JFrame formulario = new JFrame("DA - Tabbed Panes");
			formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

			// Cria instancia da classe
			TabControl pass = new TabControl();

			// Adiciona painel principal
			formulario.setContentPane(pass.criaPainel());

			formulario.setSize(300,110);

			formulario.setVisible(true);
		}

	// Cria formulario
	public static void main(String[] args) {

		javax.swing.SwingUtilities.invokeLater(new Runnable() {

			@Override
			public void run() {

				criaGUI();

			}
		});

	}
}

Uma caixa de texto, campo de texto ou caixa de entrada de texto é uma espécie de ferramenta utilizada na construção de uma interface gráfica de usuário (GUI). A finalidade de um caixa de texto é o de permitir ao utilizador inserir informações de texto de entrada a ser utilizado pelo programa. Diretrizes de interface do usuário recomendam uma caixa com uma única linha de texto quando é necessária apenas uma linha de entrada, e uma caixa de texto de várias linhas somente se for necessária mais de uma linha de entrada. Caixas de texto não editáveis ​​pode servir ao propósito de simplesmente exibir texto.

JTextArea

A JTextArea é uma área multi-linha que exibe textos simples. Ela destina-se a ser um componente leve que proporciona compatibilidade com a fonte de classe java.awt.TextArea. Usa-se este componente para inserir ou exibir textos.

JScrollPane

Fornece uma visão de rolagem. A JScrollPane gerencia uma janela, barras de rolagem verticais e horizontais opcionais, linhas e título da coluna.

Exemplo:

Neste exemplo criamos um programa com uma área de texto onde se pode editar diretamente o texto ou inserir linhas no texto através de uma caixa de texto simples e um botão.

Java

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class Texto implements ActionListener 
{
	// Declara Componentes
	JLabel rotulo;
	JTextArea area;
	JTextField texto;
	JButton botao;
	
	// Cria painel
	public Container CriaPainel()
	{
		// Cria conteudo da area de texto
	    String conteudo =  "Escreva um texto dentro da caixa de texto \n" +
	    				   "Você também pode adicionar novas linhas nesta caixa" +
	    				    "Escrevendo no editor e clicando no botão";
		
	    // Cria componentes
	    rotulo = new JLabel("Insira um texto na caixa:");
		area = new JTextArea(conteudo);
		texto = new JTextField();
		botao = new JButton("Ok");
		
		// Cria evento do botão
		botao.addActionListener(this);
			
		// Adiciona valores as propriedades da area de texto
		area.setFont(new Font("Serif", Font.ITALIC, 12));
        area.setLineWrap(true);
        area.setWrapStyleWord(true);
        
        // Cria barra de rolagem e adiciona a area de texto
        JScrollPane scrooll = new JScrollPane(area);
        
        // Adiciona valores as propriedades da barra de rolagem
        
        // Barra vertical
        scrooll.setVerticalScrollBarPolicy(
                        JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
       
        // Tamanho da barra
        scrooll.setPreferredSize(new Dimension(250, 250));
        
        // Borda com titulo
        scrooll.setBorder(
            BorderFactory.createCompoundBorder(
                BorderFactory.createCompoundBorder(
                                BorderFactory.createTitledBorder("Caixa de Texto"),
                                BorderFactory.createEmptyBorder(5,5,5,5)),
                                scrooll.getBorder()));
		
		
        // Cria o painel
		JPanel painel = new  JPanel();
		
		// Cria um layout para os componentes
		painel.setLayout(new BoxLayout(painel,BoxLayout.PAGE_AXIS));
		painel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
		
		// Alinha componentes
		rotulo.setAlignmentX(Component.CENTER_ALIGNMENT);
		area.setAlignmentX(Component.CENTER_ALIGNMENT);
		texto.setAlignmentX(Component.CENTER_ALIGNMENT);
		botao.setAlignmentX(Component.CENTER_ALIGNMENT);
		
		// Adiciona componentes no painel
		painel.add(rotulo);
		painel.add(Box.createVerticalStrut(10));
		
		// Adiciona a barra de rolagem pois a area de texto
		// está já foi adiciona dentro dela logo acima.
		painel.add(scrooll);
		painel.add(Box.createVerticalStrut(5));
		painel.add(texto);
		painel.add(Box.createVerticalStrut(5));
		painel.add(botao);
					
		// Retorna o painel
		return painel;
	}	
	
	public void actionPerformed(ActionEvent arg0)
	{
		// Cria evento para o botão		
		if (arg0.getSource() == botao)
		{
			area.append(texto.getText() + "\n");
		}		
	}	
	
	// Cria a GUI
	public static void criaGUI()
	{
		// Cria formulario
		JFrame formulario = new JFrame("DA - JTextArea");
		
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		// Cria nova instancia da classe
		Texto texto = new Texto();
		
		// adiciona painel ao formulario
		formulario.setContentPane(texto.CriaPainel());
				
		// Compacta componetes no formulario
		formulario.pack();
		
		// Mostra formulario
		formulario.setVisible(true);
	}
	
	public static void main(String[] args)
	{
		// Cria thread do swing
		javax.swing.SwingUtilities.invokeLater(new Runnable() {			
			@Override
			public void run() {
				
				// Chama a GUI
				criaGUI();				
			}
		});

	}
	
}