Esta publicación esta dedicado a mostrar el estado actual de mi proyecto así que mostrare su funcionamiento y abajo mi código.
package mxText;
import java.lang.StringBuffer;
//import mxEdit.*;
/**
* Gestiona el editor de texto para que funcione correctamente y junta diferentes partes.
* @author Max Hernandez
*
*/
public class MxText {
/**
*/
String nombreArchivo;
Sheet areaTexto = new Sheet();
TextManager textActions;
//TextManager manager = null;
//GUI Grafic = null;
public MxText(){
textActions = new TextManager(areaTexto);
GUI ventana = new GUI("Soy una ventana",areaTexto);
ventana.barraPrincipal(textActions);
}
//void Main(){}
/**
* Crea un archivo con las opciones de usuario.
*/
public void opciones(){}
public static void main(String[] args){
MxText CorazonNegro = new MxText();
}
};
package mxText;
import javax.swing.*;
import java.awt.*;
//import mxEdit.Sheet;
/**
*Clase que sirve de interfaz grafica para un programa podria utilizarse como base
*para cualquier programa, esta se encarga de dibujar una ventana en la pantalla y
*agregar diferentes elementos y controlarlos.
* @author Max Hernandez
*/
public class GUI extends javax.swing.JFrame{
private int numerodeBotones;
private Sheet texto;
JPanel p1, p2;
JMenuBar barraMenu;
String[] jMenu={"Archivo","Editar","Abrir","Nuevo","Guardar","Guardar Como"};
public GUI(String titulo, Sheet texto){
super(titulo);
super.setTitle(titulo);
super.setLocation(0,0);
super.setSize(500,500);
super.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
super.setLayout(new BorderLayout());
p1 = new JPanel();
p2 = new JPanel();
super.add(p1,BorderLayout.CENTER);
p1.setLayout(new BorderLayout());
this.texto = texto;
JScrollPane scrollb = new JScrollPane(this.texto);
JTabbedPane tabs = new JTabbedPane();
p1.setPreferredSize(new Dimension(20,5));
barraMenu = new JMenuBar();
super.add(p2,BorderLayout.NORTH);
super.setJMenuBar(barraMenu);
tabs.addTab("archivo 1",scrollb);
p1.add(tabs, BorderLayout.CENTER);
super.setVisible(true);
}
/**
* Es la clase que prepara todos los componentes para e imprime en la pantalla.
*/
public void barraPrincipal(TextManager listener){
JMenu archivo = new JMenu(jMenu[0]);
JMenu editar = new JMenu(jMenu[1]);
barraMenu.add(archivo);
barraMenu.add(editar);
JMenuItem abrir = new JMenuItem(jMenu[2]);
JMenuItem nuevo = new JMenuItem(jMenu[3]);
JMenuItem guardar = new JMenuItem(jMenu[4]);
JMenuItem guardarComo = new JMenuItem(jMenu[5]);
abrir.addActionListener(listener);
abrir.setActionCommand("abrir");
nuevo.addActionListener(listener);
nuevo.setActionCommand("nuevo");
guardar.addActionListener(listener);
guardar.setActionCommand("guardar");
guardarComo.addActionListener(listener);
guardarComo.setActionCommand("guardarComo");
archivo.add(nuevo);
archivo.add(abrir);
archivo.add(new JSeparator());
archivo.add(guardar);
archivo.add(guardarComo);
}
public void dibujar(){
}
/**
* Este metodo se encarga de cambiar la posición de los elementos en la pantalla.
* @param elemt numero que identifica el elemento.
* @param cord cordenada de a donde se desea mover el elemento
* @return cordenada Regresa la cordenada en la pantalla del elemento movido o un -1 si no se puede mover
*/
public int moverElemento(){return 0;}
/**
* Alamacena y gestiona la posicion en la pantalla de los elementos cuales deses sean añadidos.
* @return cordenada
*/
public void gestorElemento(){}
/**
* Recibe elementos y les da un lugar en la pantalla para despues ser gestionado.
*/
public void anadirElemento(){}
};
package mxText;
import java.nio.charset.Charset;
import java.io.*;
import java.lang.StringBuffer;
/**
* Clase que verifica la códificacion de un arcvhio y despues regresa el contenido de este.
* @author Max Hernandez
*/
public class Reader{
// Atributos
public String nameFile;
private File ar=null;
private FileReader fr=null;
private BufferedReader into =null;
private StringBuffer buffer =null;
//Constructor
public Reader(String name,File fl, StringBuffer buffer){
this.nameFile = name;
this.buffer= buffer;
try{
ar =fl;
fr = new FileReader(ar);
into = new BufferedReader(fr);
}catch(Exception e){
e.printStackTrace();
}
}
/**
* prepara el texto para ser pedido por la clase Administradora de texto.
*/
void lector(){}
/**
* Revisa la codificación de caracteres del archivo.
*/
public void decodificador(){}
/**
* Devuelve el contenido de el documento en un estado con el cual es facil para un programa trabajar.
*/
public void devolverDocumento(){
int c;
try{
while( (c = into.read()) != -1){
buffer.append((char)c);
}
buffer.deleteCharAt(buffer.length()-1);
}catch(Exception e){
e.printStackTrace();
}
}
public void cerrarArchivo(){
try{
fr.close();
}catch(Exception e){
e.printStackTrace();
}
}
/*public static void main(String[] args){
StringBuffer bufferFeliz = new StringBuffer();
Reader leer = new Reader(args[0], bufferFeliz);
leer.devolverDocumento();
leer.cerrarArchivo();
System.out.print(bufferFeliz.toString());
}*/
};
package mxText;
/**
* Esta clase es una extencion de una herramienta que sirve de interfaz
* entre el usuario y el programa. Es una area donde se ingresa y se edita
* el texto de archivos.
*@author Max Hernandez
*/
class Sheet extends javax.swing.JTextPane { // Una pare de la interfaz grafica y sabe estructurar el texto en la pantalla
public Sheet(){
super();
}
/**
* Método que se encarga de imprimir el texto en la pantalla.
*/
void dibujar(){} // lo que sea que le manden
/**
* Verifica el área de texto para ver las modificaciónes hechas por el usuario al texto.
*/
}
package mxText;
import javax.swing.JFileChooser;
import java.io.File;
import java.lang.StringBuffer;
import java.awt.event.*;
/**
* Sirve para trabajar con el texto de un archivo y prepararlo para imprimirlo en la pantalla o en una hoja.
* @author Max Hernandez
*/
public class TextManager implements ActionListener {
String nombreDeArchivo=null;
Reader lector =null;
Sheet hoja =null;
Writer escritor =null;
StringBuffer buffer = new StringBuffer();
File fichero;
JFileChooser fileChooser= new JFileChooser();
/**
* Buscar elementos en un texto
*/
public void actionPerformed(ActionEvent e){
String cmd = e.getActionCommand();
if(cmd == "abrir")
this.abrir();
if(cmd == "nuevo")
System.out.println("Se ha picado nuevo");
if(cmd == "guardar")
this.guardar();
if(cmd == "guardarComo" )
this.guardarComo();
}
public TextManager(Sheet hoja){
this.hoja=hoja;
}
public void buscar(){}
public void abrir(){
fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
int seleccion = fileChooser.showOpenDialog(hoja);
if (seleccion == JFileChooser.APPROVE_OPTION){
buffer.delete(0,buffer.capacity());
fichero = fileChooser.getSelectedFile();
lector = new Reader(" ",fichero,buffer);
lector.devolverDocumento();
lector.cerrarArchivo();
hoja.setText(buffer.toString());
}
}
public void guardar(){
buffer.delete(0,buffer.capacity());
buffer.append(hoja.getText());
escritor = new Writer("",fichero,buffer);
escritor.escribirDocumento();
escritor.cerrarArchivo();
}
public void guardarComo(){
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int seleccion = fileChooser.showOpenDialog(hoja);
if (seleccion == JFileChooser.APPROVE_OPTION){
fichero = fileChooser.getSelectedFile();
}
}
/**
* Organiza el texto para mas sensilla modificación.
*/
public void acomodarTexto(){}
}
package mxText;
import java.nio.charset.Charset;
import java.io.*;
import java.lang.StringBuffer;
/**
* La funcionalidad de esta clase va orientada a la impresion de datos
* en un archivo de texto, revisa la códificacion de caracteres y tiene los metodos
* necesarios para obtener.
* @author Max Hernandez
*/
public class Writer{
// atributos
private String nameFile;
private File ar=null;
private FileWriter fw=null;
private StringBuffer buffer =null;
/**
* Constructor que ocupa la direccion del archivo con la informacion dada.
*/
public Writer (String name,File fl, StringBuffer buffer){
this.nameFile = name;
this.buffer= buffer;
try{
if(fl == null){
ar=new File(name);
}else{
ar =fl; }
fw = new FileWriter(ar);
}catch(Exception e){
e.printStackTrace();
}
}
/**
* Guarda en un archivo la informacion que se le es mandada caracter por caracter con su codificacion
* que le es mandada.
*/
void escribirDocumento(){
try{
fw.write(buffer.toString());
// es como solia decir la vieja abuela argaslakslasdlaskjlaklskaslsj X_X
// abuela? abuela!!? :(
}catch(Exception e){
e.printStackTrace();
}
}
void cerrarArchivo(){
try{
fw.close();
}catch(Exception e){
e.printStackTrace();
}
}
/*public static void main(String[] args){
StringBuffer bufferFeliz = new StringBuffer();
bufferFeliz.append("Su hermano fue en su busca, a tierras muy lejanas. En medio de las tropas, jugándose hasta el alma. Aquel corazón negro, de oscuros sentimientos, quedo en el pasado hoy es un gran guerrero. La tierra que lo vio nacer, celebra su regreso.");
Writer escribir = new Writer(args[0], bufferFeliz);
escribir.escribirDocumento();
escribir.cerrarArchivo();
}*/
};
Hasta ahora mi editor de texto es capaz de desplegar una ventana con un JFrame, y adentro de esta un area de trabajo esto logrado con la clase JTextPane escogì esta clase puesto que es la mas potente que encontre en las clases estandar de java. para la barra superior use un JMenuBar que lo unico que hace es mostrar la barra, despues le añado elementos con el JMenu y les asigno un listener que se encuentra en la clase TextManager.
Con la opciòn abrir tiene la capacidad de mostrar esta ventana que la agregue facilmente con un JFileChoose y esta regresa un File el cual mando a mi clase Reader este optiene todo el texto y lo guarda en un StringBuffer para regresarlo a TextManager para que este lo mande a la clase Sheet y se imprima en la pantalla.

Para guardarlo solo se da clik a la opcion guardar y con eso el editor ya tiene la capacidad de editar archivos sin estructura.
Hasta ahora solo puedo ver un archivo ala ves pero mis proximas metas son utilizar una lista enlazada para crear "n" numero de tabs para "n" numero de archivos para "n" numero de Sheets .
Mi otra meta es lograr que reconozca estructura o palabras en el texto y las resalte cambiandoles el color.
Saludos.
Con la opciòn abrir tiene la capacidad de mostrar esta ventana que la agregue facilmente con un JFileChoose y esta regresa un File el cual mando a mi clase Reader este optiene todo el texto y lo guarda en un StringBuffer para regresarlo a TextManager para que este lo mande a la clase Sheet y se imprima en la pantalla.
Para guardarlo solo se da clik a la opcion guardar y con eso el editor ya tiene la capacidad de editar archivos sin estructura.
Hasta ahora solo puedo ver un archivo ala ves pero mis proximas metas son utilizar una lista enlazada para crear "n" numero de tabs para "n" numero de archivos para "n" numero de Sheets .
Mi otra meta es lograr que reconozca estructura o palabras en el texto y las resalte cambiandoles el color.
Saludos.
Tu video como que se traba o esta lento :/, pero llevas mucho avance :)
ResponderBorrarVe bien; 10.
ResponderBorrar