//Rafael Angel Montero Fernandez.
//sharkyc12@gmail.com
//"end_rs" es el separador de datos, esto permitira muchos saltos de linea en el codigo.
//Basandome en mi experiencia adquirida en otro lenguaje de programacion.
/////////////////////////////////////////
//Bibliotecas necesarias para leer archivos.
import java.io.FileReader;
import java.io.BufferedReader;
//////////////////////////////////////
//Estas son bibliotecas para poder guardar el archivo de texto.
import java.io.BufferedWriter;//Escribe la informacion en el archivo o sea lo graba en el disco duro.
import java.io.File;//Comprueva si existe el archivo.
import java.io.FileWriter;//Indica el archivo en el que se va a escribir.
import java.io.IOException;//Para el control de errores. Se debe poner entre public ....() y {}
import java.awt.FileDialog;//Muestra un dialogo salvar archivos.
/////////////////////////////////////
import javax.swing.JTextField;//Campor de texto simple.
import javax.swing.JFrame;//Biblioteca para crear el formulario.
import javax.swing.JButton;
import javax.swing.JTextArea;
import javax.swing.JScrollPane;
import javax.swing.JOptionPane;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.DefaultListModel;//Para añadir elemento por elemento al JList.
import java.util.ArrayList;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
//Para capturar eventos del JList cuandos e hace click en un item.
import javax.swing.event.ListSelectionListener;//Esta biblioteca este en javax.swing y no en java.awt.
import javax.swing.event.ListSelectionEvent;//Para el argumento de los eventos del JList.
import java.awt.Font;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JMenuBar;
public class frmLeerArchivoDeTexto extends JFrame implements ActionListener, ListSelectionListener
{ private ArrayList<String> rsDatos;
private Font fuente;
private JLabel jlDetalles, jlNombre, jlNombre_largo;
private JTextField jtNombre, jtNombre_largo;
private JTextArea jtaDetalles;
private JScrollPane jspDetalles, jspBusqueda;
private JMenuBar jmbBarra_de_menu;
private JMenu jmArchivo, jmEdision;
private JMenuItem jmiSalir, jmiAbrir, jmiGuardar, jmiAdd_registro, jmiLimpiar_campos;
private JList lstBusqueda;
private DefaultListModel dlmListador;
public frmLeerArchivoDeTexto()
{ super("Abrir archivo de texto"); //Propiedades del form
setSize(500,500);
setLayout(null);
setLocationRelativeTo(null);
setDefaultCloseOperation(3);//3 es lo mismo que EXIT_ON_CLOSE
setResizable(false);
//Iniciando variables
fuente=new Font("Tahoma", Font.BOLD, 14); lstBusqueda=new JList();
lstBusqueda.setFont(fuente);
dlmListador=new DefaultListModel();
lstBusqueda.setModel(dlmListador);
jspBusqueda=new JScrollPane(lstBusqueda);
jlDetalles=new JLabel("Detalles"); jlNombre=new JLabel("Nombre"); jlNombre_largo=new JLabel("Nombre largo"); jtNombre=new JTextField(""); jtNombre.setFont(fuente);
jtNombre_largo=new JTextField(""); jtNombre_largo.setFont(fuente);
jtaDetalles=new JTextArea(""); jtaDetalles.setFont(fuente);
jspDetalles=new JScrollPane(jtaDetalles);//Se agrega el control durante su inicializacion.
jmbBarra_de_menu=new JMenuBar();
setJMenuBar(jmbBarra_de_menu);//Esto agrega la barra de menu al form.
jmArchivo=new JMenu("Archivo"); jmEdision=new JMenu("Edision"); jmbBarra_de_menu.add(jmArchivo);//Esto agrega el menu Archivo a la barra de menu.
jmbBarra_de_menu.add(jmEdision);//Esto agrega el menu Archivo a la barra de menu.
jmiLimpiar_campos=new JMenuItem("Limpiar campos"); jmEdision.add(jmiLimpiar_campos);//Esto agrega el submenu Limpiar campos al menu Edision.
jmiSalir=new JMenuItem("Salir"); jmArchivo.add(jmiSalir);//Esto agrega el submenu Salir al menu Archivo.
jmiAbrir=new JMenuItem("Abrir"); jmArchivo.add(jmiAbrir);//Esto agrega el submenu Abrir al menu Archivo.
jmiAdd_registro=new JMenuItem("Add nuevo registro");//Agrega un registro.
jmArchivo.add(jmiAdd_registro);//Esto agrega el submenu Add nuevo registro al menu Archivo.
jmiGuardar=new JMenuItem("Guardar"); jmiGuardar.setEnabled(false);
jmArchivo.add(jmiGuardar);//Esto agrega el submenu Guardar al menu Archivo.
rsDatos=new ArrayList<String>();//Inicializando el ArrayList.
//Capturando eventos o escuchando eventos.
jmiLimpiar_campos.addActionListener(this);
jmiSalir.addActionListener(this);
jmiAbrir.addActionListener(this);
jmiAdd_registro.addActionListener(this);
jmiGuardar.addActionListener(this);
lstBusqueda.addListSelectionListener(this);//Forma de agregarle los eventos al JList.
//Dando coordenadas a los controles al form.
jlNombre.setBounds(0,0,100,25);
jtNombre.setBounds(0,35,100,25);
jlNombre_largo.setBounds(0,70,150,25);
jtNombre_largo.setBounds(0,95,150,25);
jlDetalles.setBounds(0,125,150,25);
jtaDetalles.setBounds(0,155,200,100);
jspDetalles.setBounds(0,155,200,100);
lstBusqueda.setBounds(220,35,200,200);
jspBusqueda.setBounds(220,35,200,200);
//Agregando los controles al form.
getContentPane().add(jlNombre);
getContentPane().add(jtNombre);
getContentPane().add(jlNombre_largo);
getContentPane().add(jtNombre_largo);
getContentPane().add(jlDetalles);
getContentPane().add(jspDetalles);
getContentPane().add(jspBusqueda);
show();
}//constructor.
public void valueChanged(ListSelectionEvent evt)
{ //Implementando el metodo de la interface ListSelectionListener.
if( lstBusqueda.isSelectionEmpty())
{ //JOptionPane.showMessageDialog(null, "Ha seleccionado un item nulo.");
}//if
else
{ //Este algoritmo que se ve a continuacion es para encontrar los datos y acomodarlos a los campos de texto.
for(int i=0; i<=rsDatos.size()-1;i++)
{ if(rsDatos.size()!=-1)
{ //Agregando datos al JList.
if(rsDatos.get(i).equalsIgnoreCase(dlmListador.getElementAt(lstBusqueda.getSelectedIndex()).toString() ))
{ try{ jtNombre.setText(rsDatos.get(i).toString());
jtNombre_largo.setText(rsDatos.get(i+1).toString());
jtaDetalles.setText(rsDatos.get(i+2).toString());
}catch(Exception ex){} }//if
}//if
}//for
}//else
}//valueChanged
public void click_Abrir(ActionEvent evt)
{ if(evt.getActionCommand().equalsIgnoreCase("Abrir")) { Leer_Archivo leer=new Leer_Archivo();
leer.abrir_archivo();
rsDatos=leer.getRegistros();//Cargando el ArrayList
//Poniendo datos en los campos de texto.
if(rsDatos.size()!=-1)
{ //Al abrir el archivo siempre se muestra el primer registro, de la base de datos casera.
jtNombre.setText(rsDatos.get(0).toString());
jtNombre_largo.setText(rsDatos.get(1).toString());
jtaDetalles.setText(rsDatos.get(2).toString());
}//if
dlmListador.clear();
int vStep=0;
for(int i=0; i<=rsDatos.size()-1;i++)
{ //Agregando datos al JList.
if (vStep==3)
{ dlmListador.addElement(rsDatos.get(i).toString());
vStep=0;
}//if
else if (i==0)
{ dlmListador.addElement(rsDatos.get(i).toString());
}
vStep++;
}//for
}//if
}//click_Abrir
public void click_Limpiar_campos(ActionEvent evt)
{ if(evt.getActionCommand().equalsIgnoreCase("Limpiar campos")) { jtNombre.setText(""); jtNombre_largo.setText(""); jtaDetalles.setText(""); }//if
}//click_Limpiar_campos
public void click_Add_registro(ActionEvent evt)
{ if(evt.getActionCommand().equalsIgnoreCase("Add nuevo registro")) { rsDatos.add(jtNombre.getText()+ " end_rs "+jtNombre_largo.getText()+ " end_rs " +jtaDetalles.getText());
JOptionPane.showMessageDialog(null,"Registro con el nombre " + rsDatos.get(rsDatos.size()-1) + " ha sido guardado");
jtNombre.setText(""); jtNombre_largo.setText(""); jtaDetalles.setText(""); jmiGuardar.setEnabled(true);
}//if
}//click_Add_registro
public void click_Guardar(ActionEvent evt)
{ if(evt.getActionCommand().equalsIgnoreCase("Guardar")) { Archivo guardando=new Archivo();
String respuesta="";
for(int i=0; i<=rsDatos.size()-1;i++)
{ respuesta+=rsDatos.get(i).toString() + " end_rs ";
}//for
guardando.escribir_archivo(respuesta);
}//if
}//click_Guardar
public void click_Salir(ActionEvent evt)
{ if(evt.getActionCommand().equalsIgnoreCase("Salir")) { System.exit(0);
}//if
}//click_Salir
@Override
public void actionPerformed(ActionEvent evt)
{ //Lo correcto es crear los procedimientos de eventos por ceparrado y luego llamarlos aqui, esto permitirá un mejor orden en la programacion.
click_Limpiar_campos(evt);
click_Abrir(evt);
click_Add_registro(evt);
click_Guardar( evt);
click_Salir(evt);
}//actionPerformed
public static void main(String args[])
{ new frmLeerArchivoDeTexto();
//Leer_Archivo ar=new Leer_Archivo();
//ar.abrir_archivo();
}//main
}//class LeerArchivoDeTexto
class Leer_Archivo
{ private File flArchivo;
private String Ruta_del_archivo;
private FileDialog fdAbrir;
private FileReader frArchivo =null;
private BufferedReader bwLector=null;
private String mDatos[];
public Leer_Archivo()
{ fdAbrir=new FileDialog(fdAbrir, "Abrir archivo", FileDialog.LOAD);
Ruta_del_archivo="";
try{ frArchivo =new FileReader(Ruta_del_archivo);}catch(IOException ex){/*mensaje de error por si se quiere verificar que sucede*/} }//constructor.
public String abrir_archivo()
{ fdAbrir.setVisible(true);
fdAbrir.dispose();
Ruta_del_archivo=fdAbrir.getDirectory()+fdAbrir.getFile().toString() ;
String respuesta="";
flArchivo=new File(Ruta_del_archivo);
try{ //Este bloque de codigo obligatoriamente debe ir dentro de un try.
frArchivo=new FileReader(flArchivo);
bwLector=new BufferedReader (frArchivo);
String linea="";
while ((linea=bwLector.readLine())!=null)
{ respuesta+=linea+"\n";//Se le pone "\n" al final porque el codigo lo abre pero omitiendo los saltos de liena, entonces, deben volverse a escribir los saltos de linea.
}//while
mDatos=respuesta.split("end_rs");//Se detecta el simbolo, se va colocando en el vector.
bwLector.close();//Se cierra el archivo.
}catch(Exception ex){JOptionPane.showMessageDialog(null,ex.getMessage());}
//Este condicional no afecta en nada la forma de guardar el archivo pero si es bueno usarlo para no borrar un trabajo previo.
if(flArchivo.exists())
{ //respuesta+="El archivo ya existia y ha sido sobreescrito posiblemente con informacion diferente. \nEn la direccion: " + flArchivo.getPath( ) ;
}//if
else
{ //respuesta+="El archivo ha sido creado exitosamente.\nEn la direccion: " + flArchivo.getPath( ) ;
}//else*/
return respuesta;
}//escribir_archivo
public String []getmTextos()
{ return mDatos;
}//get
public ArrayList<String> getRegistros()
{ //De esta manera se evita escribir codigo extra en el class formulario.
//Se crea un ArrayList local
ArrayList<String> rsRespuesta=new ArrayList<String>();
//Se recorre mDatos.
//i<=mDatos.length-2 para no agregar el ultimo elemento que esta en blanco.
for (int i=0; i<=mDatos.length-2; i++)
{ rsRespuesta.add(mDatos[i]);//Se carga el ArrayList local con los datos del vector mDatos.
}//for
return rsRespuesta;
}//get
}//class Leer_Archivo
////////////////////////////////////////////////////////////////////////////
//Este class permitirá que se puedan guardar archivos creados con el asistente y tambien si se puede se usara para guardar secuencias MsDos para compilar el archivo y ejecutarlo.
class Archivo
{ private File flArchivo;
private String Ruta_del_archivo;
private BufferedWriter bwEscritor;
private FileWriter fwArchivo_en_el_que_escribir;
private FileDialog fdGuardar;
public Archivo()
{ fdGuardar=new FileDialog(fdGuardar, "Guardar como", FileDialog.SAVE);
Ruta_del_archivo="";
flArchivo=new File(Ruta_del_archivo);
}//Constructor
public String escribir_archivo(String texto_a_guardar)
{ //JOptionPane.showMessageDialog(null,texto_a_guardar);
fdGuardar.setVisible(true);
fdGuardar.dispose();
String primera_letra=fdGuardar.getFile().charAt(0) +"";
String resto_de_la_palabra=fdGuardar.getFile().substring(1) ;
Ruta_del_archivo=fdGuardar.getDirectory()+primera_letra.toUpperCase() + resto_de_la_palabra + ".txt";//El class siempre empieza en mayuscula.
//No se usa "end_rs" para meterlo en el vector, se usara al abrirlo en guardar se usara \n
String mTextos[]=texto_a_guardar.split("\n");//Se detecta end_rs, se va colocando en el vector.
flArchivo=new File(Ruta_del_archivo);
try{ //Este bloque de codigo obligatoriamente debe ir dentro de un try.
fwArchivo_en_el_que_escribir=new FileWriter(flArchivo);//De momento se deja hasta aqui, listo para escribir, se escribe en el momento de dar la orden.
for (int i=0; i<=mTextos.length-1;i++)
{ //Se va escribiendo cada linea en el archivo de texto.
fwArchivo_en_el_que_escribir.write(mTextos[i] + "\r\n" );//"\r\n" significa enter y retorno de carro.
}//for
//Este metodo escribe el archivo en el disco duro.
bwEscritor=new BufferedWriter(fwArchivo_en_el_que_escribir);
bwEscritor.close();//Se cierra el archivo.
}catch(Exception ex){JOptionPane.showMessageDialog(null,ex.getMessage());} String respuesta="";
//Este condicional no afecta en nada la forma de guardar el archivo pero si es bueno usarlo para no borrar un trabajo previo.
if(flArchivo.exists())
{ respuesta="El archivo ya existia y ha sido sobreescrito posiblemente con informacion diferente. \nEn la direccion: " + flArchivo.getPath( ) ;
}//if
else
{ respuesta="El archivo ha sido creado exitosamente.\nEn la direccion: " + flArchivo.getPath( ) ;
}//else*/
return respuesta;
}//escribir_archivo
}//Class Archivo
///////////////////////////////////////////////////////////////////////////////
