Taller oop presentacion
View more presentations from maxkalavera
Aquí esta el link ha la documentación:
http://www.maxkalavera.iblogger.org/
Aquí el link para descargar el proyecto:
Da click aquí :D
saludos
Blog dedicado a documentar mi aprendizaje durante el transcurso de mi estudio de licenciatura.
package mxText;
public class GUI extends javax.swing.JFrame{
private int numerodeBotones;
private static GUI instancia = null;
private Sheet texto;
JPanel p1, p2, p3;
JMenuBar barraMenu;
static JLabel label= new JLabel("");
String[] jMenu={"Archivo","Editar","Abrir","Nuevo","Guardar","Guardar Como"};
private GUI(String titulo, JTabbedPane tabs){
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 = tabs;
p1.setPreferredSize(new Dimension(20,5));
barraMenu = new JMenuBar();
super.add(p2,BorderLayout.NORTH);
super.add(label,BorderLayout.SOUTH);
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]);
JMenu buscar = new JMenu("Buscar");
barraMenu.add(archivo);
barraMenu.add(editar);
barraMenu.add(buscar);
JMenuItem abrir = new JMenuItem(jMenu[2]);
JMenuItem nuevo = new JMenuItem(jMenu[3]);
JMenuItem guardar = new JMenuItem(jMenu[4]);
JMenuItem guardarComo = new JMenuItem(jMenu[5]);
JMenuItem buscari = new JMenuItem("Buscar");
JMenuItem remplazar = new JMenuItem("Remplazar");
abrir.addActionListener(listener);
abrir.setActionCommand("abrir");
nuevo.addActionListener(listener);
nuevo.setActionCommand("nuevo");
guardar.addActionListener(listener);
guardar.setActionCommand("guardar");
guardarComo.addActionListener(listener);
guardarComo.setActionCommand("guardarComo");
buscar.add(buscari);
buscar.add(remplazar);
archivo.add(nuevo);
archivo.add(abrir);
archivo.add(new JSeparator());
archivo.add(guardar);
archivo.add(guardarComo);
}
};
package mxText;
import javax.swing.*;
import javax.swing.text.*;
import java.awt.Color;
import java.util.Hashtable;
import javax.swing.event.*;
/**
* 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 implements CaretListener { // Una pare de la interfaz grafica y sabe estructurar el texto en la pantalla
Hashtable colores = new Hashtable();
StyleContext sc = new StyleContext();
DefaultStyledDocument doc = new DefaultStyledDocument(sc);
JTextPane pane = new JTextPane(doc);
public void caretUpdate(CaretEvent e){
String[] lista = {"int","null","void","extends","implements"};
int valores[] = this.procesadorColumnas(super.getCaretPosition());
System.out.println("Ln "+valores[0]+" Col "+valores[1]);
GUI.label.setText("Ln "+valores[0]+" Col "+valores[1]);
}
public Sheet(){
super();
super.addCaretListener(this);
}
private void anadirColor(String colorString, Color colorAwt ){
Style color = sc.addStyle("ConstantWidth", null);
StyleConstants.setForeground(color, colorAwt);
colores.put(colorString, color);
}
private int[] procesadorColumnas(int n){
String text1 = super.getText();
char text[] =text1.toCharArray();
int cont=0, valores[]={0,0};
for(int i=0;i
Saludos.
package pruebas;
import java.io.*;
import java.lang.StringBuffer;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
public class PruebaWriter extends TestCase {
protected Writer w;
private File prueba;
private File secundario;
private StringBuffer buffer = new StringBuffer();
protected void setUp() {
try{
this.prueba = new File("ejemplo.txt");
this.secundario = new File("ejemplo.txt");
this.w = new Writer("",secundario,buffer);
}catch(Exception e){
e.printStackTrace();
}
return;
}
public static Test suite() {
return new TestSuite(PruebaWriter.class);
}
public void testEscribiendo() {
System.out.println("Escribiendo Documento...");
buffer.append("Su hermano fue en su busca, a tierras muy lejanas.");
w.escribirDocumento();
w.cerrarArchivo();
super.assertEquals(secundario,prueba);
return;
}
public static void main(String[] args) {
TestRunner.run(PruebaWriter.suite());
return;
}
}
package pruebas;
import java.io.*;
import java.lang.StringBuffer;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
public class PruebaReader extends TestCase {
protected Reader r;
private File prueba;
private StringBuffer buffer = new StringBuffer();
protected void setUp() {
try{
this.prueba = new File("ejemplo.txt");
this.r = new Reader("",prueba,buffer);
}catch(Exception e){
e.printStackTrace();
}
return;
}
public static Test suite() {
return new TestSuite(PruebaReader.class);
}
public void testLeyendo() {
System.out.println("Devolviendo Documento...");
r.devolverDocumento();
r.cerrarArchivo();
super.assertEquals("Su hermano fue en su busca, a tierras muy lejanas.",buffer.toString());
return;
}
public static void main(String[] args) {
TestRunner.run(PruebaReader.suite());
return;
}
}
public class TextManager implements ActionListener {
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 class GUI extends javax.swing.JFrame{
public void barraPrincipal(TextManager listener){
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");
}
};
try {
textActions = TextManager.obtenerInstancia(hojas);
}catch(Error e){
e.printStackTrace();
System.out.println("TextActions No se ha iniciado correctamente");
}
try {
GUI ventana = GUI.obtenerInstancia("MxText",hojas);
ventana.barraPrincipal(textActions);
}catch(Error e){
e.printStackTrace();
System.out.println("GUI No se ha iniciado correctamente");
}
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 boolean abrirDocumento(){
try{
ar =fl;
fr = new FileReader(ar);
into = new BufferedReader(fr);
return true;
}catch(Exception e){
e.printStackTrace();
return false;
}
}
};
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 boolean guardarDocumento (){
try{
if(fl == null){
ar=new File(name);
}else{
ar =fl; }
fw = new FileWriter(ar);
return true;
}catch(Exception e){
e.printStackTrace();
return false;
}
}
];
public class Reader{
public boolean devolverDocumento(){
int c;
try{
while( (c = into.read()) != -1){
buffer.append((char)c);
}
return true;
}catch(Exception e){
e.printStackTrace();
buffer.delete(0,buffer.capacity());
return false;
}
}
};
public class Writer{
public boolean escribirDocumento(){
try{
fw.write(buffer.toString());
// es como solia decir la abuela argaslakslasdlaskjlaklskaslsj X_X
// abuela? abuela!!? :(
return true;
}catch(Exception e){
e.printStackTrace();
return false;
}
}
};





package mxText;
import javax.swing.*;
import java.awt.*;
public class GUI extends javax.swing.JFrame{
private int numerodeBotones;
private static GUI instancia = null;
private Sheet texto;
JPanel p1, p2;
JMenuBar barraMenu;
String[] jMenu={"Archivo","Editar","Abrir","Nuevo","Guardar","Guardar Como"};
private GUI(String titulo, JTabbedPane tabs){
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 = tabs;
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);
}
private synchronized static void crearInstancia(String titulo, JTabbedPane tabs){
if(instancia == null){
instancia = new GUI( titulo, tabs);
}
}
public static GUI obtenerInstancia(String titulo, JTabbedPane tabs){
if(instancia == null)
crearInstancia(titulo, tabs);
return instancia;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
};
package mxText;
import javax.swing.JFileChooser;
import javax.swing.*;
import javax.swing.text.*;
import java.io.File;
import java.lang.StringBuffer;
import java.awt.event.*;
import java.util.*;
/**
* 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 {
private static TextManager instancia = null;
String nombreDeArchivo=null;
Reader lector =null;
JTabbedPane hojas =null;
Writer escritor =null;
Compuesto tabs;
StringBuffer buffer = new StringBuffer();
File fichero;
JFileChooser fileChooser= new JFileChooser();
private TextManager(JTabbedPane hojas){}
private synchronized static void crearInstancia(){
if(instancia == null){
instancia = new TextManager();
}
}
public static TextManager obtenerInstancia(JTabbedPane hojas){
this.hojas=hojas;
tabs = new Compuesto(hojas);
if(instancia == null)
crearInstancia();
return instancia;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
};
abstract class Componente extends JScrollPane
{
public File archivo;
public Sheet hoja ;
public String nombreArchivo;
public Componente(File ar, String nF, Sheet hoja){
super(hoja);
this.archivo = ar;
this.hoja = hoja;
this.nombreArchivo = nF;
}
public Componente(){}
abstract public void Agregar(Componente c);
};
class Compuesto extends Componente
{
private ArrayListhijo = new ArrayList ();
private JTabbedPane tabs;
public Compuesto (JTabbedPane tabs){
this.tabs=tabs;
}
@Override
public void Agregar(Componente comp)
{
hijo.add(comp);
tabs.addTab(comp.nombreArchivo,comp);
}
};
class Tab extends Componente
{
public Tab (File fl, String nF, Sheet hoja)
{
super(fl,nF, hoja);
}
public void Agregar(Componente c)
{
System.out.println("no se puede agregar la tab");
}
public void Remover(Componente c)
}
System.out.println("no es posible completar la petición");
public void Mostrar(int depth)
{
System.out.println('-' + "" + nombreArchivo);
}
};


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();
}*/
};
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.
Con esto umbrello me organizo automaticamente las clases de mi proyecto y me las mostro como un arbol en la parte izquierda, desde ahi se pueden editar los nombres, metodos y aributos de cada clase.
Umbrello automaticamente me crea el diagrama junto con las flechas que especifican la interacción entre los programas.
Para pasar el diagrama a código primero tenemos que especificar el lenguaje en el que trabajamos para esto vamos a code>Active Language y seleccionamos el lenguaje en el que trabajamos que en mi caso es java.
Esta es la carpeta con el proyecto que me creo Umbrello.
como puede verse en el código el programa me construye las clases, métodos, da nombre a algunas variables y me genera documentación.
package mxEdit;
/**
* Class MxText
*/
public class MxText {
//
// Fields
//
/**
*
* */
public String[] usuario;
//
// Constructors
//
public MxText () { };
//
// Methods
//
//
// Accessor methods
//
/**
* Set the value of usuario
*
*
* @param newVar the new value of usuario
*/
public void setUsuario ( String[] newVar ) {
usuario = newVar;
}
/**
* Get the value of usuario
*
*
* @return the value of usuario
*/
public String[] getUsuario ( ) {
return usuario;
}
//
// Other methods
//
/**
*/
public void opciones( )
{
}
/**
* @param args
*/
public static void main( String[] args )
{
}
}



package textedit;
/**
*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;
/**
* Es la clase que prepara todos los componentes para e imprime en la pantalla.
*/
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(){}
/**
* 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 textedit;
import java.nio.charset.Charset;
import java.io.*;
/**
* Clase que verifica la códificacion de un arcvhio y despues regresa el contenido de este.
* @author Max Hernandez
*/
public class Reader extends java.io.InputStreamReader {
// Atributos
private String[] nameFile;
private String[] extension;
//Constructor
public Reader(String[] name, String[] ext, File fl){
super(fl);
this.nameFile = name;
this.extension = ext;
}
/**
* prepara el texto para ser pedido por la clase Administradora de texto.
*/
void lector(){}
/**
* Revisa la codificación de caracteres del archivo.
*/
private void decodificador(){}
/**
* Devuelve el contenido de el documento en un estado con el cual es facil para un programa trabajar.
*/
private void devolverDocumento(){}
}
package textedit;
import java.io.*;
/**
* 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 extends java.io.OutputStreamWriter {
// atributos
private String[] nombreDelArchivo;
private String[] extension;
private int numeroDeLineas;
/**
* Constructor que ocupa la direccion del archivo con la informacion dada.
*/
public Writer (String []nombreDelArchivo, File fl){
super(fl);
}
/**
* Guarda en un archivo la informacion que se le es mandada caracter por caracter con su codificacion
* que le es mandada.
*/
private void guardar(String[] nombreDelarchivo, String[] extencion, String[] datos){}
}
package textedit;
/**
* Gestiona el editor de texto para que funcione correctamente y junta diferentes partes.
* @author Max Hernandez
*
*/
public class Main{
/**
*/
String[] usuario;
void Main(){};
/**
* Crea un archivo con las opciones de usuario.
*/
public void opciones(){}
public static void main(String[] args ){
System.out.println("Working...");
}
}
package textedit;
/**
* 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
*/
public class Sheet extends javax.swing.JTextArea { // Una pare de la interfaz grafica y sabe estructurar el texto en la pantalla
private int numeroLineas(){}
/**
* 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 textedit;
/**
* 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{
String[] nombreDeArchivos;
String[] extension;
/**
* Buscar elementos en un texto
*/
public void buscar();
/**
* Organiza el texto para mas sensilla modificación.
*/
public void acomodarTexto();
}
{ /** Esto es un ejemplo de como hacer una documentacion.
* @author Max Hernandez :D
* @version la version de este programa.
*/
public class ejemplo{
/**
Este es el método mas importante del codigo :p
@param args Este es el parametro de mi código pero seguro que el tuyo tendra mas
*/
public static void main(String[] args){
System.println("Soy un ejemplo");
}
}
package textedit;
import java.nio.charset.Charset;
public class Reader extends java.io.InputStreamReader {
// Atributos
private String[] nameFile;
private String[] extension;
//Constructor
public Reader(String name, String ext){
super(InputStream in, Charset cs);
this.nameFile = name;
this.extension = ext;
}
// Metodos
void lector(){} // prepara el texto para ser pedido por la clase Administradora de texto
private void decodificador(){} // esto podria dejarselo a la clase Charset
private void devolverLinea(){}
private void devolverDocumento(){}
}
package textedit;
public class Writer extends OutputStreamWriter{
// atributos
private String[] nameFile;
private String[] extension;
private int nlines;
//Contructor
public Writer(String[] name, String[] ext){
super();
this.nameFile = name;
this.extension = ext;
}
// Metodos
private void codificar(String extension){}// Charset espero que me salve aquí
private void guardar(string[] nombreDelarchivo, String[] extencion, String[] datos){} // guarda usando las clases de OutputStreamWriter
}
package textedit;
public class Sheet extends javax.swing.JTextArea { // Una pare de la interfaz grafica y sabe estructurar el texto en la pantalla
// atributos
private int numeroLineas(){}
// Metodos
void intermedioEscucha(){} // comunicacion con intermedia
void dibujar(); // lo que sea que le manden
}
package textedit;
public class GUI extends javax.swing.JFrame{
// atributos
private int numerodebotones;
// Metodos
private void dibujar(){}
}