Capturar webcam con VB.NET

¿Que haremos? Crearemos una aplicación en Visual Studio, la cual hará uso de una webcam para capturar el video en frames independientes y depositarlos en memoria para despues mostralos al usuario a través de un picturebox y un Timer para crear la ilusión de movimiento. ¿Porque lo haremos? Porque es justo y necesario ¿Que necesitamos? [...]

Envío de correo con JavaMail/Netbeans

JavaMail es una expansión de Java que facilita el envío y recepción de e-mail desde código java. JavaMail implementa el protocolo SMTP (Simple Mail Transfer Protocol) así como los distintos tipos de conexión con servidores de correo -TLS, SSL, autentificación con usuario y password, etc [Según SantaWikipedia] ¿Qué necesitamos? JavaMail 1.4.5 Java y Netbeans 6.9 [...]

Proyecto de base de datos Firebird VB

En este proyecto realizaremos una aplicación de base de datos Firebird con el lenguaje de programación de Visual Basic de Microsoft, este proyecto tendrá las funciones básicas de gestión INSERT, DELETE, UPDATE y una interfaz de usuario para utilizarlas. ¿Que necesitamos? Visual Studio 2008 o superior Firebird última versión Firebird ADO.NET Data Provider. Conocimientos básicos [...]

Imprimir imagen con Print

La siguiente clase hace uso de PRINT para imprimir una imagen que se encuentra en un variable de tipo FileInputStream, esta clase a su vez es implementada desde una interfaz que hace fácil su uso, la clase así como todo el proyecto esta comentado. import java.io.File; import javax.print.Doc; import java.io.IOException; import javax.print.DocFlavor; import javax.print.SimpleDoc; import java.io.FileInputStream; [...]

29/6/10

Guardar/Cargar configuración en una aplicacion

JAN29

Muchas veces cuando hacemos un programa y queremos que las modificaciones que realizamos en nuestra aplicacion a modo de personalización en tiempo de ejecucion , como colores, tipo de letra, tamaño de la letra, color de la letra, etc, queremos que estas se guarden para no tener que realizar los mismos cambios una y otra vez.
Maneras de realizar esto creo que hay muchas, la mas sencilla que se me ocurre es utilizar un archivo de texto donde guardar nuestros cambios y cargarlos desde ahi a la aplicacion cada vez que iniciemos el programa.

Que necesitas
  • Netbeans 6.0 o  sup
  • Un editor de texto
  • imaginacion

Proyecto
Lo que haremos sera crear una aplicacion en netbeans, el cual contara con dos interfaces, la primera, la principal, donde se colocaran los cambios que hagamos, la segunda interfaz, nos servira como un panel de configuracion, esta aplicacion, al momento de iniciar, cargara un archivo de texto donde se encontraran las configuraciones de color de los paneles (FONDO, PANEL1, PANEL2, PANEL3), y tipo, tamaño, estilo y color de fuente de letra, haciendo un total de 8 configuraciones que podremos guardar y cargar en el programa.
Si el archivo de configuracion que llamaremos "miconfiguracion.txt" no existe, el programa creara uno con una configuracion por defecto y cargara este en la aplicacion. este archivo se encuentra o se creara junto al JAR de la aplicacion, en el mismo directorio de este.

Manos a la obra

1. Nuestro proyecto se llamara "configuracion", crea este en netbeans y añade dos JFrames "Aplicacion.java" y "Configurar.java", añade una tercera clase "miconfiguracion.java".


2. Ahora diseña la interfaz para "aplicacion.java" como la imagen de abajo, recuerda los nombres en rojo son importantes, colocalos como estan:
3. Diseña la interfaz para "configurar,java", esta interfaz nos servira como un panel de configuracion donde podremos realizar nuestros cambios.

4. Si llegaste hasta aqui, ahora toca escribir el codigo que nos permita manejar nuestro archivo de configuracion "miconfiguracion.txt", este archivo de texto, esta compuesto de 8 campos separados por el caracter "/", estos 8 campos corresponden a las 8 modificaciones que podemos realizar en la aplicacion, /Color de fondo/ Color de panel 1/ Color de panel 2/ Color de Panel 3/ Tipo de fuente/ Estilo de la fuente (normal, negrilla, cursiva, cursiva negrilla)/ Color de la fuente/ Tamaño de la fuente
No necesitas crear este archivo, lo creara el mismo programa que estamos haciendo, la clase para controlar las modificaciones se llama "miconfiguracion.java", el codigo es:


package configuracion;
import java.awt.Color;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JButton;
import javax.swing.JColorChooser;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class miconfiguracion {
    //configuracion por defecto
    private String default_configuracion = "/-1118482/-1118482/-1118482/-1118482/Arial/1/-16777063/12/";
    //direccion del archivo de texto
    private String archivo_de_configuracion=System.getProperty("user.dir") + "/miconfiguracion.txt";
    //Para leer archivo de texto
    private File archivo = null;
    private FileReader fr = null;
    private BufferedReader br = null;
    // para escribir en archivo
    private FileWriter fichero = null;
    private PrintWriter pw = null;
    //almacena los valores leidos del archivo de miconfiguracion.txt
    // donde los valores del vector:
    // 0 a 3 -> son los colores de fondo, panel1, panel2 y panel3
    // 4     -> Tipo de fuente
    // 5     -> Estilo de fuente
    // 6     -> Color de fuente
    // 7     -> Tamaño de fuente
    private Vector<String> vector = new Vector<String>(10,2);
    
    public miconfiguracion() {      
        try {
            Configuracion();
        } catch (FileNotFoundException ex) {
            Logger.getLogger(miconfiguracion.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(miconfiguracion.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    /* abre un archivo de texto y lee el contenido  */
    private void Configuracion() throws FileNotFoundException, IOException{
        String configuracion="";//contenido del archivo         
        //el archivo se encuentra en el mismo directorio que la aplicacion         
        archivo = new File(archivo_de_configuracion);
        //si el archivo existe leemos la configuracion
        if(archivo.exists()){          
            configuracion = Leer_configuracion();
        }
        else{//sino existe lo creamos
           Guardar_Configuracion(default_configuracion);
           configuracion = Leer_configuracion();
        } 
        // el string que se retorno en "configuracion", lo separa mediante tokens y lo almacena
        // en una variable de tipo vector
        token(configuracion);
    }
    
    /* ABRE UN ARCHIVO DE TEXTO Y LEE EL CONENIDO EL CUAL RETORNA EN UN STRING */
    private String  Leer_configuracion() throws FileNotFoundException, IOException{
     String tmp_c="";
     fr = new FileReader(archivo);
     br = new BufferedReader(fr);
     // Lectura del fichero de texto
     String linea = null;
     while ((linea = br.readLine()) != null) {
         tmp_c = tmp_c + linea;
     }   
     fr.close();
     return tmp_c;
    }
    
    /* separa la configuracion y los añade al vector */
    private void token(String s){
     //separamos los valores leidos en tokens     
     StringTokenizer tokens = new StringTokenizer(s,"/");
     while(tokens.hasMoreTokens()){
        vector.addElement(tokens.nextToken());
     }           
    }
    
    /* MUESTRA LA VENTA DE DIALOGO [ESCOGER COLOR]*/
    public Color Escoger_Color(java.awt.event.ActionEvent evt){
        Color color = JColorChooser.showDialog(null,"Escoja un color",((JButton)evt.getSource()).getBackground());
        if(color!=null){return color;}else{return new Color(-1118482);}
    }
    
 //guarda las configuracion en el archivo de texto "miconfiguracion.txt"
 public boolean Guardar_Configuracion(String t){   
     boolean ok = false;
        try {
            fichero = new FileWriter(archivo_de_configuracion);
            pw = new PrintWriter(fichero);
            pw.println(t);
            ok = true;     
            fichero.close();
        } catch (IOException ex) {
            Logger.getLogger(miconfiguracion.class.getName()).log(Level.SEVERE, null, ex);
        }
        return ok;
  }
    
   /* DEVUELVE LOS VALORES ALMACENADOS EN EL VECTOR */ 
   /*  inicio */
   public int Color_de_Fondo(){
        return Integer.valueOf(vector.get(0).toString());
    }
    
    public int Color_Panel1(){
        return Integer.valueOf(vector.get(1).toString());
    }
    
    public int Color_Panel2(){
        return Integer.valueOf(vector.get(2).toString());
    }
    
    public int Color_Panel3(){
        return Integer.valueOf(vector.get(3).toString());
    }
    
    public String Tipo_Fuente(){
        return vector.get(4).toString();
    }  
    
    public int Tipo_Estilo_Fuente(){
        return Integer.valueOf(vector.get(5).toString());
    }  
    
    public int Color_Fuente(){
        return Integer.valueOf(vector.get(6).toString());
    }
    
    public int Size_Fuente(){
        return Integer.valueOf(vector.get(7).toString());
    }
    /*  fin */
}

Un poco largo el codigo, pero es sencillo, consiste, en metodos para leer el archivo de texto, si no existe lo crea, despues utilizar el StringTokenizer para separar las configuraciones y cargarlos en un vector, para que estas esten disponibles en cualquier momento. Asi mismo el metodo Guardar_Configuracion(String t), recibe un string con la cadena que formaremos con las modificaciones hechas para salvar en el archivo de texto.

5. En la clase interfaz aplicacion.java, añade el siguiente codigo:


public void inicializar(){
        /* CONFIGURACION*/
        miconfiguracion mc = new miconfiguracion();
        //se carga la configuracion en los objetos
        this.setBackground(new Color(mc.Color_de_Fondo()));
        FONDO.setBackground(new Color(mc.Color_de_Fondo()));
        PANEL1.setBackground(new Color(mc.Color_Panel1()));
        PANEL2.setBackground(new Color(mc.Color_Panel2()));
        PANEL3.setBackground(new Color(mc.Color_Panel3()));
        Font f = new Font( mc.Tipo_Fuente(),mc.Tipo_Estilo_Fuente(),mc.Size_Fuente() );
        TEXTO.setFont(f);
        TEXTO.setForeground(new Color(mc.Color_Fuente()));
        /* -- */
    }
despues añade este en el constructor de la clase, para terminar, escribe en el evento de smConfigurar el siguiente codigo:

private void smConfigurarActionPerformed(java.awt.event.ActionEvent evt) {
    configurar c = new configurar();
    c.show();
}


6. Para terminar la aplicacion, en la clase interfaz configurar.java, declara


 private miconfiguracion mc = new miconfiguracion();
 private ButtonGroup buttongroup = new ButtonGroup();
 private int OpcionSel;

Despues añade en el constructor de la clase:


 public configurar() {
        initComponents();
        this.setLocationRelativeTo(null);  
        this.setTitle("Opciones de configuración...");
        buttongroup.add(opcion1);
        buttongroup.add(opcion2);
        buttongroup.add(opcion3);
        buttongroup.add(opcion4);
        
        /* carga la configuracion en los objetos*/
        //carga los colores en los jbutton
        cmd0.setBackground(new Color(mc.Color_de_Fondo()));
        cmd1.setBackground(new Color(mc.Color_Panel1()));
        cmd2.setBackground(new Color(mc.Color_Panel2()));
        cmd3.setBackground(new Color(mc.Color_Panel3()));
        //carga el tipo de letra
        for(int i=0;i<=cboTipo.getItemCount()-1;i++){
            if(mc.Tipo_Fuente().equals(cboTipo.getItemAt(i).toString())){
                cboTipo.setSelectedIndex(i);break;
            }
        }
        //carga el tamaño de la fuente
        for(int i=0;i<=cboSize.getItemCount()-1;i++){
            if(mc.Size_Fuente()==Integer.valueOf(cboSize.getItemAt(i).toString())){
                cboSize.setSelectedIndex(i);break;
            }
        }
        //carga el estilo en el JRadioButton correspondiente
        if(mc.Tipo_Estilo_Fuente()==0){opcion1.setSelected(true);}
        if(mc.Tipo_Estilo_Fuente()==1){opcion2.setSelected(true);}
        if(mc.Tipo_Estilo_Fuente()==2){opcion3.setSelected(true);}
        if(mc.Tipo_Estilo_Fuente()==3){opcion4.setSelected(true);}
        //carga el color de fondo
        cmdFuente.setBackground(new Color(mc.Color_Fuente()));
        /* fin configurar */
    }

Ahora el el JButton: cmdCambios, escribe el siguiente codigo:


private void cmdCambiosActionPerformed(java.awt.event.ActionEvent evt) {       
  /* SE GUARDA LA NUEVA CONFIGURACION */
  //color fondo/color panel1/color panel2/color panel3/Tipo fuente/estilo fuente/color fuente/tamaño fuente
  if(
     mc.Guardar_Configuracion("/"+cmd0.getBackground().getRGB()+"/"+
                                  cmd1.getBackground().getRGB()+"/"+
                                  cmd2.getBackground().getRGB()+"/"+
                                  cmd3.getBackground().getRGB()+"/"+
                                  cboTipo.getSelectedItem().toString()+"/"+
                                  OpcionSel+"/"+
                                  cmdFuente.getBackground().getRGB()+"/"+
                                  cboSize.getSelectedItem().toString()+"/"
                               ))
    {
        JOptionPane.showMessageDialog(this,"La nueva configuracion se guardo correctamente \nLos cambios se veran la proxima ves que inicie la aplicacion...");
     }        
}

finalmente, debes añadir los eventos en los objetos que declaramos mas arriba, este codigo no lo copies y pegues, sino fijate bien, donde debe ir cada instruccion


private void cmd3ActionPerformed(java.awt.event.ActionEvent evt) {
        cmd3.setBackground(mc.Escoger_Color(evt));
}

private void cmd2ActionPerformed(java.awt.event.ActionEvent evt) {
        cmd2.setBackground(mc.Escoger_Color(evt));
}

private void cmd1ActionPerformed(java.awt.event.ActionEvent evt) {
        cmd1.setBackground(mc.Escoger_Color(evt));
}

private void cmdFuenteActionPerformed(java.awt.event.ActionEvent evt) {
        cmdFuente.setBackground(mc.Escoger_Color(evt));
}

private void opcion1ActionPerformed(java.awt.event.ActionEvent evt) {
        OpcionSel =0;
}

private void opcion2ActionPerformed(java.awt.event.ActionEvent evt) {
        OpcionSel =1;
}

private void opcion3ActionPerformed(java.awt.event.ActionEvent evt) {
        OpcionSel =2;
}

private void opcion4ActionPerformed(java.awt.event.ActionEvent evt) {
        OpcionSel =3;
}

private void cmd0ActionPerformed(java.awt.event.ActionEvent evt) {
        cmd0.setBackground(mc.Escoger_Color(evt));  
}

ejecuta el proyecto, si no tienes ningun error debes tener algo como esto

Finalmente el codigo fuente para los mas vagos :)
Click para descargar

continue reading

6/6/10

jCalendar - Fechas conJava

JAN29


jCalendar es una libreria OpenSource que te permite manejar fechas en un entorno grafico. Esta libreria dispone de varias herramientas que facilitan el trabajo con la menor cantidad de codigo escrito por nosotros.

La web oficial del proyecto es http://www.toedter.com/en/jcalendar/index.html, se encuentra en la version 1.3.3 con solo 600kb de tamaño

Para instalar nuevas librerias en netbeans, leete este "tutorial Añadir/Instalar nuevas librerias en netbeans", una ves que tenemos instalado las librerias, debemos añadir las herramientas de jCalendar a la interfaz grafica de Netbeans, para esto sigue los sieguientes pasos:

1. Situate en la barra de herramientas Palette y realiza un clic derecho sobre esta, se despliega un menu y entonces escoge la opcion Palette Manager
2. En la ventana que aparece "Palette Manager", clic en el boton New Category... , te aparece otra pequeña ventanita "New Palette Category" y colocas nombre a la nueva paleta, en este caso jCalendar. y le dices OK

3. Esto te creara una nueva categoria en Palette, seleccionala y presiona el boton Add from JAR..., entonces busca donde instalaste la libreria JAR y seleciona el archivo jCalendar-1.3.3 y le dices NEXT
4.  Despues tienes que seleccionar todos los componentes, como se ve en la imagen y le dices NEXT, te volvera a preguntar donde quieres añadir estos nuevos objetos, entonces seleccionas nuestra paleta que creamos en el paso 2 y para terminar le dices FINISH.

5. Si seguiste todos los pasos, te debe aparecer una nueva paletta en la barra de herramientas Palette
Ya tenemos instalado y configurado nuestro componente jCalendar

Proyecto de prueba.

1. crea un nuevo proyecto en netbeans y añade un jFrame, despues a la interfaz añade el componente jDateChooser como se ve en la imagen
2. para personalizar un poco la fecha de jDateChooser, ingresa a sus propiedades (clic derecho -> properties) y busca la opcion dateFormatString, es ahi donde puedes colocar el formato de salida, por ejemplo yyyy/MM/dd.
3. Ejecuta la aplicacion

Eso es todo, ya podemos seleccionar una fecha graficamente con jCalendar sin escribir una sola linea de codigo.

Puedes encontrar mas informacion (en ingles) asi como ejemplo, en esta direccion http://flib.sourceforge.net/JCalendar/doc/tutorial.html


“Una imagen vale mil palabras”, pero consume mil veces mas memoria.

continue reading

3/6/10

Notepad+- con java

JAN29

En este feriado de corpus christi que ya se acaba, aprenderemos a crear un sencillo notepad al estilo de mouse, tendra  funciones basicas (abrir/guardar) y la capacidad de trabajar con varios documentos a la vez, a traves de pestañas como se ve en la imagen.

Se necesita:
  • Java
  • Netbeans 6.0
  • 15 minutos de su tiempo
Proyecto
El proyecto comprende:

Comencemos:

1. Cree un nuevo proyecto "texto" en netbeas, añada un JFrame: textoform.java y añade un menu (JMenubar) y sus respectivos Items, ademas añada un contendor JPanel y dentro de el un JTabbedPane:JTP, debe tener algo como esto:

OJO: Fijese en los nombres de los objetos y coloquelos como en la imagen

2. crea una nueva clase textoclass.java, esta clase nos permitira manipular archivos de texto (abrir/guardar) mediante una comoca ventana de dialogo (JFileChooser), el codigo que debes colocar dentro es el siguiente:


package texto;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
import javax.swing.filechooser.FileNameExtensionFilter;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class textoclass {    
//para leer
File archivo = null;
FileReader fr = null;
BufferedReader br = null;
//para escribir
FileWriter fichero = null;
PrintWriter pw = null;
//ruta absoluta del archivo a manipular
String ruta = "";
//filtro
private static FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo TXT","txt","TXT");

    public textoclass(){
    } 
    
    //abre un archivo de texto y lee el contenido linea por linea
    private String OpenFile(String ruta){
        String t="";//contenido del archivo
        try {         
            archivo = new File (ruta);
            fr = new FileReader (archivo);
            br = new BufferedReader(fr);
            // Lectura del fichero linea por linea
            String linea;
            while((linea=br.readLine())!=null)
                t = t + linea + "\n";
        }
      catch(Exception e){
         e.printStackTrace();
      }finally{         
         try{
            if( null != fr ){
               fr.close();
            }
         }catch (Exception e2){ 
            e2.printStackTrace();
         }
      }
        return t;
    }
    
    private void SaveFile(String t, String ruta){
    //se separa el texto cada salto de linea
    StringTokenizer st = new StringTokenizer(t,"\n");
    try
        {
            fichero = new FileWriter(ruta);
            pw = new PrintWriter(fichero);
            //se guarda linea por linea en el archivo
            while(st.hasMoreTokens()){
                String line = st.nextToken();
                pw.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
           try {
           if (null != fichero)
              fichero.close();
           } catch (Exception e2) {
              e2.printStackTrace();
           }
        }       
    }
    
    //segun la opcion muestra en pantalla una ventana de dialogo
    //para "abrir" o "guardar" un archivo
    public String  Dialog(String Opcion, JTextArea tArea){
        String nombre_archivo="";
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.setFileFilter(filter);
        //ventana para "abrir un archivo", retorna FALSE si se abre
        if (Opcion.equals("Open")){
                int result = fileChooser.showOpenDialog(null);  
                if ( result == JFileChooser.APPROVE_OPTION ){
                    ruta = fileChooser.getSelectedFile().getAbsolutePath(); 
                    nombre_archivo = fileChooser.getSelectedFile().getName();
                    tArea.setText(OpenFile(ruta));
                }
        }
        //ventana para guardar un archivo
        else if (Opcion.equals("Save As")){                
                int result = fileChooser.showSaveDialog(null);
                if ( result == JFileChooser.APPROVE_OPTION ){
                    ruta = fileChooser.getSelectedFile().getAbsolutePath();
                    ruta = ruta + ".txt";
                    nombre_archivo = fileChooser.getSelectedFile().getName();
                    SaveFile(tArea.getText() ,ruta);
                    JOptionPane.showMessageDialog(null,"archivo guardado correctamente.");
                }
        }
        //aqui no muestra ninguna ventana, guarda automaticamente el archivo
        //respecto a un archivo previamente abierto
        else if(Opcion.equals("Save")){
            SaveFile(tArea.getText() ,ruta);
            JOptionPane.showMessageDialog(null,"archivo actualizado.");
        }       
        return nombre_archivo;
    }
}

3. ahora cree una nueva clase JTabbedPane_op.java, esta clase es la encargada de crear nuevas pestañas TABS en el JTabbedPane, asi como su respectivo jTextArea, asi mismo esta clase hace uso de la clase file.java que crearemos mas tarde, esta clase JTabbedPane_op, utiliza vectores para controlar y almacenar las diferenntes pestañas que se crearan, el codigo es:

package texto;
import java.util.Vector;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTextArea;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class JTabbedPane_op {    
//vector para almacenar objetos jtextarea
private Vector vjta = new Vector(10,2);    
//vector para almacenar objetos tipo file
private Vector vfile = new Vector(10,2);
//objetos
JTextArea jta; 
JScrollPane scrollPane;
     
public JTabbedPane_op(){}
    
//crea un nuevo TAB en el JTabbedPane junto a un textarea
public void nuevo(JTabbedPane jtp){
    //se crea una nueva instancia de jTextArea
    jta  = new JTextArea(8,25);
    //se crean las barras de desplazamiento y se añade el jtextarea
    scrollPane = new JScrollPane(jta, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
    //se añade el objeto jtextarea al vector
    vjta.add(jta);            
    vfile.add(new file());        
    //se optiene la cantidad de tabs que existen
    int i = jtp.getComponentCount();        
    jta.setText("http://jc-mouse.blogspot.com/");
    //se añade los objetos al tabs        
    jtp.add(scrollPane, i);         
    jtp.setTitleAt(i, "nuevo documento");
}
    //obtiene los datos de un jtextarea del tabs actual
public String getdatos(JTabbedPane jtp){
    int i = jtp.getSelectedIndex();
    JTextArea t = (JTextArea) vjta.elementAt(i);
    return t.getText();
}
    //retorna un jtextarea del TABS actual
public  JTextArea getjTextArea(JTabbedPane jtp){
   int i = jtp.getSelectedIndex();
   JTextArea t = (JTextArea) vjta.elementAt(i);
   return t;
}
    //elimina un TABS junto a los demas objetos que le pertenecen
public void eliminar(JTabbedPane jtp){        
    int i = jtp.getSelectedIndex();
    jtp.remove(i);
    vjta.remove(i);
    vfile.remove(i);
}
    //retorna un boolean (true|false) si el contenido de una jtextarea ya 
    //fue guardado
public boolean fileisnew(JTabbedPane jtp){      
    file f = (file) vfile.elementAt(jtp.getSelectedIndex());
    return f.isnew;
}
    //cambia el estado isnew=false despues de que el archivo a sido
    //guardado por primera vez
public void guardado(JTabbedPane jtp, String t){
    file f = (file) vfile.elementAt(jtp.getSelectedIndex());  
    jtp.setTitleAt(jtp.getSelectedIndex(), t);  
    f.isnew=false;
 }  
}

4. por ultimo cree una nueva clase file.java, esta pequeña clase nos ayuda con la gestion de los archivos


package texto;
public class file {
boolean isnew=true;//condicion boolean
String ruta = "";//ruta del archivo
    public file(){}    
}

5. para terminar, tenemos que implementar las clases en la interfaz, esto no lo copies y pegues, sino observa la forma de inplementacion:


/* se crean los objetos */
textoclass tc = new textoclass();
JTabbedPane_op op = new JTabbedPane_op();    
String title = "Notepad+- by Mouse - file:["; 


/* esto en el initComponents */
public textoform() {
   initComponents();
   this.setTitle(title + "]");
   //crea un nuevo tabs junto a una hoja en blanco
   op.nuevo(JTP);
}

/* implementacion de las acciones del menu */
private void smOpenActionPerformed(java.awt.event.ActionEvent evt) {
   // Abre archivo de texto OPEN FILE
   String n = tc.Dialog("Open",op.getjTextArea(JTP));
   this.setTitle(title + tc.ruta + "]");
   op.guardado(JTP,n);
}     

private void smSaveAsActionPerformed(java.awt.event.ActionEvent evt) {
   // Guarda en un nuevo archivo   GUARDAR COMO...    
   String n = tc.Dialog("Save As",  op.getjTextArea(JTP)); 
   this.setTitle(title + tc.ruta+"]");       
   if (!n.equals("")){op.guardado(JTP,n);}
}

private void smSaveActionPerformed(java.awt.event.ActionEvent evt) {
  // Guarda modificaciones echas a un archivo 
  //si es nuevo guarda como
  if (op.fileisnew(JTP)) {
      String n = tc.Dialog("Save As", op.getjTextArea(JTP));
      this.setTitle(title + tc.ruta + "]");
      if (!n.equals("")){op.guardado(JTP,n);}
   }
   else
   { //sino actualiza el archivo abierto
      String n = tc.Dialog("Save", op.getjTextArea(JTP));   
      this.setTitle(title + tc.ruta+"]");
   }        
}

private void smNewActionPerformed(java.awt.event.ActionEvent evt) {
   //crea un nuevo tabs junto a una hoja en blanco
   op.nuevo(JTP);
}     

private void smClosetabActionPerformed(java.awt.event.ActionEvent evt) {
   //elimina un tabs
   op.eliminar(JTP);
}

Ya tenemos nuestro notepad+- en java
Como siempre los codigos estan extracomentados y tambien te dejo el codigo fuente, cualquier duda  o bugs que se encuentre, preguntar y avisar
Click para descargar

Mi software nunca tiene fallos. Simplemente desarrolla caracteristicas aleatorias

continue reading

Post recomendado