import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.URI;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.*;
import javax.swing.border.TitledBorder;
import javax.swing.event.UndoableEditEvent;
import javax.swing.event.UndoableEditListener;
import javax.swing.text.Document;
import javax.swing.undo.CannotUndoException;
import javax.swing.undo.UndoManager;
/**
* Site: http://programjm.blogspot.com.br/
* @author João Matheus Santos Assis
* @version 1.5 2013-06-27
*/
@SuppressWarnings("serial")
public class EditorDeTexto extends JFrame {
/*
* Esta aplicação permite ao usuário a manipulação simples de texto e
* armazenamento em disco das informações;
* Foi desenvolvido no Netbeans 7.1, SO Windows e Java 6;
*/
public EditorDeTexto() {
super("Editor de Texto");
initComponents();
}
/**
* Aqui é definido as propriedades do Jframe, bem como adicionado os
* componentes gráficos a esta janela.
*/
private void initComponents() {
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// obtém as dimensões do monitor.
Toolkit Kit = Toolkit.getDefaultToolkit();
Dimension tamalhoDeTela = Kit.getScreenSize();
// variável altura recebe o valor da altura do monitor do usuário.
int altura = tamalhoDeTela.height;
// variável largura recebe o valor da largura do monitor do usuário.
int largura = tamalhoDeTela.width;
setSize(largura / 2 + 20, altura / 2);
// exibe a janela no meio da tela.
setLocationRelativeTo(null);
final EventosBlocoDeNotas eventosBlocoDeNotas = new EventosBlocoDeNotas();
// criação de uma barra de menu visualizada no topo da aplicação.
menuBar = new JMenuBar();
fontePadrão = new Font("Lucida Console", Font.PLAIN, 14);
// criação de uma área de inserção de texto.
texto = new JTextArea();
texto.setFont(fontePadrão);
texto.addMouseListener(new MouseAdapter() {
@Override
public void mouseReleased(MouseEvent event) {
if(event.isPopupTrigger())
botãoEsquerdo.show(
event.getComponent(), event.getX(), event.getY()
);
}
});
// adição de barra de rolagem ao JTextArea.
add(new JScrollPane(texto), BorderLayout.CENTER);
final UndoManager undo = new UndoManager();
Document documento = texto.getDocument();
// aqui é ouvido os eventos de Desfazer.
documento.addUndoableEditListener(new UndoableEditListener() {
@Override
public void undoableEditHappened(UndoableEditEvent event) {
undo.addEdit(event.getEdit());
}
});
/****************************** MENU ARQUIVO **************************/
/* Dentro do menu Arquivo encontrasse:
* Novo (Ctrl N), Abrir (Ctrl O), Salvar Como (Ctrl S) e Sair (Alt F4).
*/
menuArquivo = new JMenu();
menuArquivo.setText("Arquivo");
// propriedades do componente menuItemNovo.
menuItemNovo = new JMenuItem();
menuItemNovo.setText("Novo");
menuItemNovo.setAccelerator(
KeyStroke.getKeyStroke("ctrl N")
);
menuItemNovo.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemNovoActionListener();
}
});
menuArquivo.add(menuItemNovo);
// propriedades do componente menuItemAbrir.
menuItemAbrir = new JMenuItem();
menuItemAbrir.setText("Abrir...");
menuItemAbrir.setAccelerator(
KeyStroke.getKeyStroke("ctrl O")
);
menuItemAbrir.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemAbrirActionListener();
}
});
menuArquivo.add(menuItemAbrir);
// propriedades do componente menuItemSalvarComo.
menuItemSalvarComo = new JMenuItem();
menuItemSalvarComo.setText("Salvar como...");
menuItemSalvarComo.setAccelerator(
KeyStroke.getKeyStroke("ctrl S")
);
menuItemSalvarComo.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemSalvarComoActionListener();
}
});
menuArquivo.add(menuItemSalvarComo);
menuArquivo.addSeparator();
// propriedades do componente menuItemSair.
menuItemSair = new JMenuItem();
menuItemSair.setText("Sair");
menuItemSair.setAccelerator(
KeyStroke.getKeyStroke("alt F4")
);
menuItemSair.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemSairActionListener();
}
});
menuArquivo.add(menuItemSair);
/****************************** MENU EDITAR ***************************/
/*
* Dentro do menu Editar encontrasse:
* Desfazer (Ctrl Z), Recortar (Ctrl X), Copiar (Ctrl C), Colar (Ctrl V),
* Localizar (Ctrl F), Localizar próxima (F3) e Selecionar tudo (Ctrl T).
*/
menuEditar = new JMenu();
menuEditar.setText("Editar");
// propriedades do componente menuItemDesfazer.
menuItemDesfazer = new JMenuItem();
menuItemDesfazer.setText("Desfazer");
menuItemDesfazer.setAccelerator(
KeyStroke.getKeyStroke("ctrl Z")
);
menuItemDesfazer.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
try {
if(undo.canUndo()){
undo.undo();
}
}
catch(CannotUndoException Erro) { }
}
});
menuEditar.add(menuItemDesfazer);
menuEditar.addSeparator();
// propriedades do componente menuItemRecortar.
menuItemRecortar = new JMenuItem();
menuItemRecortar.setText("Recortar");
menuItemRecortar.setAccelerator(
KeyStroke.getKeyStroke("ctrl X")
);
menuItemRecortar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemRecortarActionListener();
}
});
menuEditar.add(menuItemRecortar);
// propriedades do componente menuItemCopiar.
menuItemCopiar = new JMenuItem();
menuItemCopiar.setText("Copiar");
menuItemCopiar.setAccelerator(
KeyStroke.getKeyStroke("ctrl C")
);
menuItemCopiar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemCopiarActionListener();
}
});
menuEditar.add(menuItemCopiar);
// propriedades do componente menuItemColar.
menuItemColar = new JMenuItem();
menuItemColar.setText("Colar");
menuItemColar.setAccelerator(
KeyStroke.getKeyStroke("ctrl V")
);
menuItemColar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemColarActionListener();
}
});
menuEditar.add(menuItemColar);
menuEditar.addSeparator();
// propriedades do componente menuItemLocalizar.
menuItemLocalizar = new JMenuItem();
menuItemLocalizar.setText("Localizar...");
menuItemLocalizar.setAccelerator(
KeyStroke.getKeyStroke("ctrl F")
);
menuItemLocalizar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemLocalizarActionListener();
}
});
menuEditar.add(menuItemLocalizar);
// propriedades do componente menuItemLocalizarProxima.
menuItemLocalizarProxima = new JMenuItem();
menuItemLocalizarProxima.setText("Localizar próxima");
menuItemLocalizarProxima.setAccelerator(
KeyStroke.getKeyStroke("F3")
);
menuItemLocalizarProxima.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemLocalizarProximaActionListener();
}
});
menuEditar.add(menuItemLocalizarProxima);
menuEditar.addSeparator();
// propriedades do componente menuItemSelecionarTudo.
menuItemSelecionarTudo = new JMenuItem();
menuItemSelecionarTudo.setText("Selecionar tudo");
menuItemSelecionarTudo.setAccelerator(
KeyStroke.getKeyStroke("ctrl T")
);
menuItemSelecionarTudo.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemSelecionarTudoActionListener();
}
});
menuEditar.add(menuItemSelecionarTudo);
/****************************** MENU FORMATAR *************************/
/*
* Dentro do menu Formatar encontrasse:
* Quebra automática de linha (Ctrl L), Fonte (Ctrl R)
* e Cor da fonte (Ctrl D).
*/
menuFormatar = new JMenu();
menuFormatar.setText("Formatar");
// propriedades do componente menuItemQuebraAtomaticaDeLinha.
menuItemQuebraAtomaticaDeLinha = new JCheckBoxMenuItem();
menuItemQuebraAtomaticaDeLinha.setText("Quebra automática de linha");
menuItemQuebraAtomaticaDeLinha.setAccelerator(
KeyStroke.getKeyStroke("ctrl L")
);
menuItemQuebraAtomaticaDeLinha.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemQuebraAtomaticaDeLinhaActionListener();
}
});
menuFormatar.add(menuItemQuebraAtomaticaDeLinha);
menuFormatar.addSeparator();
// propriedades do componente menuItemFonte.
menuItemFonte = new JMenuItem();
menuItemFonte.setText("Fonte...");
menuItemFonte.setAccelerator(
KeyStroke.getKeyStroke("ctrl R")
);
menuItemFonte.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemFonteActionListener();
}
});
menuFormatar.add(menuItemFonte);
// propriedades do componente menuItemCor.
menuItemCor = new JMenuItem();
menuItemCor.setText("Cor da fonte...");
menuItemCor.setAccelerator(
KeyStroke.getKeyStroke("ctrl D")
);
menuItemCor.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemCorActionListener();
}
});
menuFormatar.add(menuItemCor);
/****************************** MENU EXIBIR ***************************/
// dentro do menu Exibir encontrasse: Barra de status
menuExibir = new JMenu();
menuExibir.setText("Exibir");
// propriedades do componente menuItemBarraDeStatus.
menuItemBarraDeStatus = new JCheckBoxMenuItem();
menuItemBarraDeStatus.setText("Barra de status");
menuItemBarraDeStatus.setSelected(true);
menuItemBarraDeStatus.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemBarraDeStatusActionListener();
}
});
menuExibir.add(menuItemBarraDeStatus);
/*************************** MENU DESCRIÇÃO ***************************/
/*
* Dentro do menu Descrição encontrasse:
* Exibir descrição (F1) e Sobre o Editor de Texto (F6).
*/
menuDescrição = new JMenu();
menuDescrição.setText("Descrição");
// propriedades do componente menuItemExibirDescrição.
menuItemExibirDescrição = new JMenuItem();
menuItemExibirDescrição.setText("Exibir Descrição");
menuItemExibirDescrição.setAccelerator(
KeyStroke.getKeyStroke("F1")
);
menuItemExibirDescrição.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemExibirDescriçãoActionListener();
}
});
menuDescrição.add(menuItemExibirDescrição);
menuDescrição.addSeparator();
// propriedades do componente menuItemSobreEditorDeTexto.
menuItemSobreEditorDeTexto = new JMenuItem();
menuItemSobreEditorDeTexto.setText("Sobre o Editor de Texto");
menuItemSobreEditorDeTexto.setAccelerator(
KeyStroke.getKeyStroke("F6")
);
menuItemSobreEditorDeTexto.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemSobreEditorDeTextoActionListener();
}
});
menuDescrição.add(menuItemSobreEditorDeTexto);
// adicionando os menus a barra de menu (JMenuBar).
menuBar.add(menuArquivo);
menuBar.add(menuEditar);
menuBar.add(menuFormatar);
menuBar.add(menuExibir);
menuBar.add(menuDescrição);
setJMenuBar(menuBar);
/****************************** BOTÃO ESQUERDO DO MOUSE ***************/
botãoEsquerdo = new JPopupMenu();
popupMenuItemDesfazer = new JMenuItem();
popupMenuItemDesfazer.setText("Desfazer");
popupMenuItemDesfazer.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
try {
if(undo.canUndo()) {
undo.undo();
}
}
catch(CannotUndoException Erro) {
// possíveis erros são tratados aqui.
}
}
});
botãoEsquerdo.add(popupMenuItemDesfazer);
botãoEsquerdo.addSeparator();
popupMenuItemRecortar = new JMenuItem();
popupMenuItemRecortar.setText("Recortar");
popupMenuItemRecortar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemRecortarActionListener();
}
});
botãoEsquerdo.add(popupMenuItemRecortar);
popupMenuItemCopiar = new JMenuItem();
popupMenuItemCopiar.setText("Copiar");
popupMenuItemCopiar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemRecortarActionListener();
}
});
botãoEsquerdo.add(popupMenuItemCopiar);
popupMenuItemColar = new JMenuItem();
popupMenuItemColar.setText("Colar");
popupMenuItemColar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemColarActionListener();
}
});
botãoEsquerdo.add(popupMenuItemColar);
botãoEsquerdo.addSeparator();
popupMenuItemSelecionarTudo = new JMenuItem();
popupMenuItemSelecionarTudo.setText("Selecionar tudo");
popupMenuItemSelecionarTudo.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
eventosBlocoDeNotas.MenuItemSelecionarTudoActionListener();
}
});
botãoEsquerdo.add(popupMenuItemSelecionarTudo);
/****************************** BARRA DE STATUS ***********************/
barraDeStatus = new JLabel();
barraDeStatus.setHorizontalAlignment(JLabel.RIGHT);
barraDeStatus.setText("Lucida Console // Font.PLAIN // 14 ");
add(barraDeStatus, BorderLayout.SOUTH);
/****************************** FECHA JANELA **************************/
this.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent event) {
eventosBlocoDeNotas.FecharWindowListener();
}
});
}
/**************** CLASSE DESTINADA A TRATAMENTO DE EVENTOS ****************/
private class EventosBlocoDeNotas {
int posiçãoInicial;
int selecionar;
String pesquisa;
Color color = Color.BLACK;
Color últimaCor = Color.BLACK;
/**
* Apaga todo texto existente no documento.
*/
public void MenuItemNovoActionListener() {
texto.setText("");
}
/**
* Abre um documento já existente.
*/
public void MenuItemAbrirActionListener() {
AbrirArquivo();
}
/**
* Salva o arquivo texto em um diretório.
*/
public void MenuItemSalvarComoActionListener() {
SalvarArquivo();
}
/**
* Método responsável por fechar o aplicativo.
*/
public void MenuItemSairActionListener() {
FecharWindowListener();
}
/**
* Apaga o texto selecionado e transfere para a área de transferência.
*/
public void MenuItemRecortarActionListener() {
texto.cut();
}
/**
* Tranfere para a área de tranferência o texto selecionado.
*/
public void MenuItemCopiarActionListener() {
texto.copy();
}
/**
* Insere o texto no documento que esta na área de transferência.
*/
public void MenuItemColarActionListener() {
texto.paste();
}
/**
* Busca uma determinada palavra no documento;
* Quando o MenuItemLocalizar for acionado, uma caixa de diálogo será
* aberta e no campo de texto a palavra o qual desejasse buscar no
* documento deverá ser armazenada na variável, no formato String,
* pesquisa;
* Caso a variável pesquisa tenha um valor não nulo, a palavra solicitada
* deverá ser buscada no JTextArea, sendo está, quando encontrada,
* selecionada no texto.
*/
public void MenuItemLocalizarActionListener() {
pesquisa = JOptionPane.showInputDialog(
EditorDeTexto.this, "Pesquisar:" ,
"Localizar", JOptionPane.PLAIN_MESSAGE
);
if (pesquisa != null) {
posiçãoInicial = 0;
texto.requestFocus();
selecionar = texto.getText().indexOf(pesquisa, posiçãoInicial);
if (selecionar < 0) {
JOptionPane.showMessageDialog(
EditorDeTexto.this, "Texto não encontrado"
);
posiçãoInicial = 0;
}
else {
texto.requestFocus();
texto.select(selecionar, selecionar + pesquisa.length());
}
}
}
/**
* Localiza a ocorrência de uma palavra.
*/
public void MenuItemLocalizarProximaActionListener() {
if (pesquisa != null) {
texto.requestFocus();
posiçãoInicial = selecionar + pesquisa.length();
selecionar = texto.getText().indexOf(pesquisa, posiçãoInicial);
if(selecionar < 0) {
// informa ao usuário que todas as palavras foram encontradas.
JOptionPane.showMessageDialog(
EditorDeTexto.this,
"Não existe \"" + pesquisa + "\" em frente!"
);
selecionar = -1;
posiçãoInicial = 0;
} else {
texto.requestFocus();
texto.select(selecionar, selecionar + pesquisa.length());
posiçãoInicial = selecionar + pesquisa.length();
}
}
}
/**
* Agiliza o processo de recortar, copiar e colar todo o texto.
*/
public void MenuItemSelecionarTudoActionListener() {
texto.selectAll();
}
/**
* Estando ativado o menuItemQuebraAtomaticaDeLinha, o texto passa para
* a linha posterior quando este alcança a margem direita do documento;
* Estando desabilitado, o texto segue normalmente na mesma linha até o
* usuário apertar a tecla ENTER.
*/
public void MenuItemQuebraAtomaticaDeLinhaActionListener() {
if (menuItemQuebraAtomaticaDeLinha.isSelected())
texto.setLineWrap(true);
else
texto.setLineWrap(false);
}
/**
* Object obtêm todas as fontes do sistema, sendo estas fontes exibidas
* em um JOptionPane;
* Quando o usuário efetivar sua escolha toda a fonte do texto
* será mudada.
*/
public void MenuItemFonteActionListener() {
Object[] nomeFonte = GraphicsEnvironment.
getLocalGraphicsEnvironment().
getAvailableFontFamilyNames();
String fonteEscolhida = (String) JOptionPane.showInputDialog(
EditorDeTexto.this,"Escolha a fonte", "Fonte",
JOptionPane.PLAIN_MESSAGE,null,nomeFonte, ""
);
if (fonteEscolhida == null)
texto.setFont(new Font("Lucida Console", Font.PLAIN, 14));
else {
texto.setFont(new Font(fonteEscolhida, Font.PLAIN, 14));
barraDeStatus.setText(fonteEscolhida + " // Font.PLAIN // 14 ");
}
}
/**
* Abrindo uma caixa de diálogo que permite ao usuário selecionar uma
* determinada cor de forma interativa.
*/
public void MenuItemCorActionListener() {
color = JColorChooser.showDialog(
EditorDeTexto.this, "Alterar cor da fonte", color
);
if (color != null)
últimaCor = color;
texto.setForeground(últimaCor);
}
/**
* Estando abilitado, será exibido informações sobre a fonte
* e seu estilo e tamanho, no canto inferior da Janela.
*/
public void MenuItemBarraDeStatusActionListener() {
if (menuItemBarraDeStatus.isSelected())
barraDeStatus.setVisible(true);
else
barraDeStatus.setVisible(false);
}
/**
* Exibir informações do aplicativo.
*/
public void MenuItemExibirDescriçãoActionListener() {
JOptionPane.showMessageDialog(EditorDeTexto.this,
"Este é um simples Editor de Texto, que permite\n" +
"formatações básicas, como trocas da fonte, cor do\n" +
"Texto, entre outras.\n" +
"Com o aplicativo é possível eventos através de menus,\n" +
"combinações de teclas e Popup, trazendo interatividade\n" +
"para com os usuários.", "Ajuda", JOptionPane.PLAIN_MESSAGE);
}
/**
* Exibir o nome do programador e seu site, bem como o sistema
* operacional e plataforma de desenvolvimento Java o qual o
* aplicativo foi criado.
*/
public void MenuItemSobreEditorDeTextoActionListener() {
new SobreEditorDeTexto(
(int)getLocation().getX(),
(int)getLocation().getY(),
EditorDeTexto.this, true
).setVisible(true);
}
/**
* Permite ao usuário selecionar algum arquivo do computador para que
* este ser “aberto” pelo Editor de Texto.
*/
public void AbrirArquivo() {
JFileChooser abrindoArquivo = new JFileChooser();
// configurando para que somente arquivos seja abertos.
abrindoArquivo.setFileSelectionMode(JFileChooser.FILES_ONLY);
SwingUtilities.updateComponentTreeUI(abrindoArquivo);
// definindo filtro de Extensão para abrir somente arquivo *.txt
abrindoArquivo.setFileFilter(new javax.swing.filechooser.FileFilter() {
@Override
public boolean accept(File file) {
return file.getName().toLowerCase().endsWith(".txt")
|| file.isDirectory();
}
@Override
public String getDescription() {
return "Documento de Texto (.txt)";
}
});
// armazena a escolha do usuário.
int respostaDeAbrindoArquivo =
abrindoArquivo.showOpenDialog(EditorDeTexto.this);
// se o usuário clicar para abrir o arquivo...
if (respostaDeAbrindoArquivo == JFileChooser.APPROVE_OPTION) {
File Arquivo = abrindoArquivo.getSelectedFile();
texto.setText("");
try {
BufferedReader bufferedReader =
new BufferedReader(new FileReader(Arquivo));
String linha;
while ( (linha = bufferedReader.readLine()) != null) {
texto.append(linha + "\n");
}
bufferedReader.close();
}
catch (IOException ex){
// possíveis erros são tratatos aqui.
}
}
}
public void SalvarArquivo() {
JFileChooser salvandoArquivo = new JFileChooser();
if (salvandoArquivo.showSaveDialog(EditorDeTexto.this) !=
JFileChooser.APPROVE_OPTION)
return;
File arquivo = salvandoArquivo.getSelectedFile();
if (arquivo == null)
return;
FileWriter writer = null;
try {
writer = new FileWriter(arquivo);
writer.write(texto.getText());
}
catch(IOException Ex){
// possíveis erros aqui.
}
finally {
if(writer != null) {
try {
writer.close();
}
catch (IOException ex) { }
}
}
}
/**
* Permite que o usuário determine se deseja que o documento seja salvo
* ou não, quando clicado no botão fechar do aplicativo.
*/
public void FecharWindowListener() {
if(!texto.getText().equals("")) {
int resposta = JOptionPane.showConfirmDialog(
EditorDeTexto.this, "Deseja Salvar o Documento?",
"Editor de Texto", JOptionPane.INFORMATION_MESSAGE);
if (resposta == JOptionPane.YES_OPTION) {
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
SalvarArquivo();
}
if (resposta == JOptionPane.NO_OPTION) {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
System.exit(0);
}
if (resposta == JOptionPane.CANCEL_OPTION) {
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
}
} else {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
System.exit(0);
}
}
}
/**
* Método principal da aplicação;
* Este método é definindo a aparência e comportamento da interface, ou seja
* a forma como os componentes gráficos serão desenhados na tela do usuário;
* A classe EditorDeTexto é chamada no modo visível.
*/
public static void main(String [] args) {
try {
for (UIManager.LookAndFeelInfo info :
UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
Logger.getLogger(EditorDeTexto.class.getName()).log(Level.SEVERE,
null, ex);
} catch (InstantiationException ex) {
Logger.getLogger(EditorDeTexto.class.getName()).log(Level.SEVERE,
null, ex);
} catch (IllegalAccessException ex) {
Logger.getLogger(EditorDeTexto.class.getName()).log(Level.SEVERE,
null, ex);
} catch (UnsupportedLookAndFeelException ex) {
Logger.getLogger(EditorDeTexto.class.getName()).log(Level.SEVERE,
null, ex);
}
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new EditorDeTexto().setVisible(true);
}
});
}
// Componentes gráficos utilizados no JFrame.
private JMenuBar menuBar;
private JMenu menuArquivo;
private JMenuItem menuItemNovo;
private JMenuItem menuItemAbrir;
private JMenuItem menuItemSalvarComo;
private JMenuItem menuItemSair;
private JMenu menuEditar;
private JMenuItem menuItemDesfazer;
private JMenuItem menuItemRecortar;
private JMenuItem menuItemCopiar;
private JMenuItem menuItemColar;
private JMenuItem menuItemLocalizar;
private JMenuItem menuItemLocalizarProxima;
private JMenuItem menuItemSelecionarTudo;
private JMenu menuFormatar;
private JCheckBoxMenuItem menuItemQuebraAtomaticaDeLinha;
private JMenuItem menuItemFonte;
private JMenuItem menuItemCor;
private JMenu menuExibir;
private JCheckBoxMenuItem menuItemBarraDeStatus;
private JMenu menuDescrição;
private JMenuItem menuItemExibirDescrição;
private JMenuItem menuItemSobreEditorDeTexto;
private JPopupMenu botãoEsquerdo;
private JMenuItem popupMenuItemDesfazer;
private JMenuItem popupMenuItemRecortar;
private JMenuItem popupMenuItemCopiar;
private JMenuItem popupMenuItemColar;
private JMenuItem popupMenuItemSelecionarTudo;
private Font fontePadrão;
private JLabel barraDeStatus;
private JTextArea texto;
}
/************************** SOBRE O EDITOR DE TEXTO **************************/
@SuppressWarnings("serial")
class SobreEditorDeTexto extends JDialog {
private int X;
private int Y;
/**
* @param X distância da janela principal, da margem esquerda no monitor.
* @param Y distância da janela principal, da margem superior no monitor.
* @param parent o Frame é definido como uma janela pai.
* @param modal captura (quando true) o foco da janela até que seja fechado.
*/
public SobreEditorDeTexto(int X, int Y, Frame parent, boolean modal) {
super(parent, modal);
this.X = X;
this.Y = Y;
initComponents();
}
/**
* Método responsável pelo fechamento do JDialog.
*/
public void ButtonFecharSobrePreMatrículaActionListener() {
setVisible(false);
dispose();
}
/**
* Aqui é definido as propriedades do JDialog, bem como adicionado os
* componentes gráficos a este componente.
*/
private void initComponents() {
setTitle("Sobre a Pré Matrícula");
setSize(500, 210);
setResizable(false);
setLocation(X + 20, Y + 40);
fonte = new Font("Tahoma", Font.PLAIN, 12);
layoutInformaçõesDoAutor = new GridLayout(4, 1);
informaçõesDoAutor = new JPanel();
informaçõesDoAutor.setLayout(layoutInformaçõesDoAutor);
// propriedades do componente nomeDoAutor.
nomeDoAutor = new JLabel();
nomeDoAutor.setFont(fonte);
nomeDoAutor.setText("João Matheus Santos Assis");
informaçõesDoAutor.add(nomeDoAutor);
// propriedades do componente cidadeDoAutor.
cidadeDoAutor = new JLabel();
cidadeDoAutor.setFont(fonte);
cidadeDoAutor.setText("Valença/Bahia/Brasil");
informaçõesDoAutor.add(cidadeDoAutor);
// propriedades do componente siteDoCodigo.
siteDoCodigo = new JLabel();
siteDoCodigo.setFont(fonte);
siteDoCodigo.setText("Site do Editor de Texto:");
informaçõesDoAutor.add(siteDoCodigo);
// propriedades do componente endereçoEditorDeTexto.
endereçoEditorDeTexto = new JLabel();
endereçoEditorDeTexto.setFont(fonte);
endereçoEditorDeTexto.setCursor(new Cursor(Cursor.HAND_CURSOR));
endereçoEditorDeTexto.setText(
"<html><u>http://programjm.blogspot.com.br/</u></html>"
);
endereçoEditorDeTexto.setToolTipText("Programando em Pascal, C/C++ e Java");
/*
* Quando o JLabel endereçoEditorDeTexto for clicado o usuário será
* direcionado para a página do Programando em Pascal, C/C++ e Java.
*/
endereçoEditorDeTexto.addMouseListener(new MouseListener() {
@Override
public void mouseClicked(MouseEvent e) {
Desktop desktop = Desktop.getDesktop();
try {
desktop.browse(new URI("http://programjm.blogspot.com.br/"));
} catch (Exception erro) {
JOptionPane.showMessageDialog(
SobreEditorDeTexto.this, "Ocorreu um Erro!"
);
}
}
@Override
public void mousePressed(MouseEvent e) {
}
@Override
public void mouseReleased(MouseEvent e) {
}
@Override
public void mouseEntered(MouseEvent e) {
/*
* A cor do texto é modificada para a cor azul quando o mouse se
* aproxima do JLabel endereçoEditorDeTexto.
*/
endereçoEditorDeTexto.setForeground(Color.BLUE);
}
@Override
public void mouseExited(MouseEvent e) {
/*
* A cor do texto é modificada para a cor preta (sua cor padrão)
* quando o mouse se afasta do JLabel endereçoEditorDeTexto.
*/
endereçoEditorDeTexto.setForeground(Color.BLACK);
}
});
informaçõesDoAutor.add(endereçoEditorDeTexto);
// propriedades do componente informaçõesDoAutor.
informaçõesDoAutor.setPreferredSize(new Dimension (230, 140));
informaçõesDoAutor.setBackground(Color.WHITE);
informaçõesDoAutor.setBorder(
BorderFactory.createTitledBorder(
null, "Programador",
TitledBorder.DEFAULT_JUSTIFICATION,
TitledBorder.DEFAULT_POSITION,
new Font("Tahoma", 1, 14)
)
);
layoutInformaçõesTécnicas = new GridLayout(4, 1);
informaçõesTécnicas = new JPanel();
informaçõesTécnicas.setLayout(layoutInformaçõesTécnicas);
// propriedades do componente sistemaOperacional.
sistemaOperacional = new JLabel();
sistemaOperacional.setFont(fonte);
sistemaOperacional.setText("Windows 7");
informaçõesTécnicas.add(sistemaOperacional);
// propriedades do componente plataforma.
plataforma = new JLabel();
plataforma.setFont(fonte);
plataforma.setText("NetBeans 7.1");
informaçõesTécnicas.add(plataforma);
// propriedades do componente últimaAtualização.
últimaAtualização = new JLabel();
últimaAtualização.setFont(fonte);
últimaAtualização.setText("Data de Criação:");
informaçõesTécnicas.add(últimaAtualização);
// propriedades do componente data.
data = new JLabel();
data.setFont(fonte);
data.setText("8 de setembro de 2012");
informaçõesTécnicas.add(data);
// propriedades do componente informaçõesTécnicas.
informaçõesTécnicas.setPreferredSize(new Dimension (200, 140));
informaçõesTécnicas.setBackground(Color.WHITE);
informaçõesTécnicas.setBorder(
BorderFactory.createTitledBorder(
null, "Sistema",
TitledBorder.DEFAULT_JUSTIFICATION,
TitledBorder.DEFAULT_POSITION,
new Font("Tahoma", 1, 14)
)
);
// propriedades do componente buttonFecharSobrePreMatrícula.
buttonFecharSobrePreMatrícula = new JButton();
buttonFecharSobrePreMatrícula.setText("Fechar");
getRootPane().setDefaultButton(buttonFecharSobrePreMatrícula);
buttonFecharSobrePreMatrícula.setSelected(true);
buttonFecharSobrePreMatrícula.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent event) {
ButtonFecharSobrePreMatrículaActionListener();
}
});
panelGeral = new JPanel();
panelGeral.setBackground(Color.WHITE);
panelGeral.add(informaçõesDoAutor);
panelGeral.add(informaçõesTécnicas);
panelGeral.add(buttonFecharSobrePreMatrícula);
panelGeral.setFont(fonte);
add(panelGeral);
}
// componentes gráficos utilizados no JDialog.
private JPanel informaçõesDoAutor;
private GridLayout layoutInformaçõesDoAutor;
private JLabel nomeDoAutor;
private JLabel cidadeDoAutor;
private JLabel siteDoCodigo;
private JLabel endereçoEditorDeTexto;
private JPanel informaçõesTécnicas;
private GridLayout layoutInformaçõesTécnicas;
private JLabel sistemaOperacional;
private JLabel plataforma;
private JLabel últimaAtualização;
private JLabel data;
private JButton buttonFecharSobrePreMatrícula;
private Font fonte;
private JPanel panelGeral;
}
Palavras-Chaves: Editor de Texto, Arquivo, Editar, Formatar, Exibir, Descrição, Componentes Gráficos, JMenuBar, JMenu, JMenuItem, JCheckBoxMenuItem, JPopupMenu, JLabel, JTextArea, JDialog, JPanel, JButton, JFileChooser, JColorChooser, JOptionPane, JPopupMenu, Diretório, ações com o Mouse e Teclado, Conexão com a Internet, Obter fontes do sistema, Fonte, Cores, Layout, Propriedades, Bibliotecas, Documentação, Caixa de Diálogo, Interface da Janela, Métodos, Construtor, Java.
Artigos relacionados em Java:
- Criando um JFrame em Java
- MDC em Java
- Calculadora simples em Java
- Inserindo uma URL em Java
- Eventos com JButton (mudando a cor do JPanel) em Java
- Jogo da Forca em Java
- Calculadora Completa em Java
- Desenhando figuras com o mouse em Java
- Jogo da Memória em Java
- Implementacao de Pilha e Fila em Java
- Manipulando a fonte e a cor do JLabel.
- Jogo da Velha com Interface Gráfica em Java
- Sabatina da Multiplicação em Java
 |
| Feito no NetBeans-7.1 | Executável |
 |
| Feito no NetBeans-7.1 | Executável |
 |
| Feito no NetBeans-7.1 | Executável |
 |
| Feito no NetBeans-7.1 | Executável |
 |
| Feito no NetBeans-7.1 | Executável |
 |
| Feito no NetBeans-7.1 | Executável |
