Creando un editor en Java

A traves de la pagina de chuidiang he visto que daba una guia de como montar nuestro propio editor de textos con Java, en este caso es un editor muy sencillo pero que en mi caso personal me abre todo un mundo ya que estoy más acostumbrado a utilizar Java unicamente como back-end y utilizo otros frameworks para el front-end, en estos momentos para ser exactos estoy usando Flex en mi día a día.

Lo primero es generar la ventana con todos sus elementos, pero como eso nos dejaria una función principal demasiado pesada lo que tenemos que hacer es generar un constructor que divida los problemas para que los separe y los trate de manera personal.
Y por eso nuestro constructor quedaria de la siguiente manera

    public LDEditor()
    {
        JMenuBar barraMenu = new JMenuBar();
        
        areaTexto = new JTextArea(30, 90);
        
        buildFileMenu(barraMenu);
        buildEditMenu(barraMenu);

        JFrame frame = buildEditorWindow(barraMenu);
        viewWindow(frame);
    }

JTextArea solicita dos parametros de tipo integer para poder definir cuanto tiene que medir, en mi caso quiero que se visualicen treinta lineas y noventa columnas "JTextArea(int rows, int columns)"

Ahora generaremos todo el codigo para crear el menu correspondiente a "Archivo".
En este menu incluiremos las tres opciones basicas: Salvar, cargar y Salir.

Para ello creamos los tres items del menu, despues creamos el menu propiamente dicho y le añadiremos los tres items.
Tras esto añadimos todo el menu a la barra de menu que hemos recibido por parametro.

    private void buildFileMenu(JMenuBar barraMenu)
    {
        JMenuItem salvar = new JMenuItem("Salvar");
        JMenuItem cargar = new JMenuItem("Cargar");
        JMenuItem salir = new JMenuItem("Salir");
        
        JMenu menuArchivo = new JMenu("Archivo");
        
        menuArchivo.add(salvar);
        menuArchivo.add(cargar);
        menuArchivo.add(salir);
        
        barraMenu.add(menuArchivo);
    }

Ahora haremos el mismo proceso para el menu de edicion.
En este caso hay una modificación, y es que para separar la opcion de buscar y de las que editan el texto hemos metido un separador, para ello se ha introducido " menuEditar.add(new JSeparator());" se añade como un item más y ya que no vamos a hacer nada más con él no hace falta crearlo como variable

    private void buildEditMenu(JMenuBar barraMenu)
    {
        JMenuItem buscar = new JMenuItem("Buscar");
        JMenuItem copiar = new JMenuItem("Copiar");
        JMenuItem cortar = new JMenuItem("Cortar");
        JMenuItem pegar  = new JMenuItem("Pegar");

        JMenu menuEditar = new JMenu("Editar");
        menuEditar.add(buscar);
        
        menuEditar.add(new JSeparator());
		
        menuEditar.add(cortar);
        menuEditar.add(copiar);
        menuEditar.add(pegar);
        
        barraMenu.add(menuEditar);
    }

Ahora vamos a juntar todo para crear un JFrame

    private JFrame buildEditorWindow(JMenuBar barraMenu)
    {
        JFrame frame = new JFrame("Test de editor de Liem Dazkun");
        
        //El menú va en la parte superior,
        frame.getContentPane().add(barraMenu, BorderLayout.NORTH);
        
        //El comando que activa / desactiva el ajuste de linea 
        areaTexto.setLineWrap(true);
        
        //El comando que hace que el ajuste de linea se haga donde haya un espacion en blanco.
        areaTexto.setWrapStyleWord(true);

        JScrollPane scroll = new JScrollPane(areaTexto);
        
        // El scroll con el JTextArea se añade por defecto en el centro del BorderLayout.
        frame.getContentPane().add(scroll);

        return frame;
    }

Finalmente cargamos y lanzamos toda la pantalla para que se pueda visualizar.

    private void viewWindow(JFrame frame)
    {
    	// Para salir del programa en caso de pulsar el aspa de la esquina superior derecha de la ventana.
    	frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        
        // La ventana coge el tamaño justo para que se vean completamente todos los componentes
    	frame.pack();

        // Se obtienen las dimensiones en pixels de la pantalla.
        Dimension pantalla = Toolkit.getDefaultToolkit().getScreenSize();
        
        // Se obtienen las dimensiones en pixels de la ventana.
        Dimension ventana = frame.getSize();
        
        // Una cuenta para situar la ventana en el centro de la pantalla.
        frame.setLocation(
            (pantalla.width - ventana.width) / 2,
            (pantalla.height - ventana.height) / 2);
        
        // Se visualiza la ventana.
        frame.setVisible(true);
    }

¿En que día de la semana vivimos? escrito en Java

Basándome en los datos extraídos de la Wikipedia  he confeccionado la función necesaria para saber si nos encontramos a martes o a miércoles.

Lo primero que se tiene que hacer es cargar unas contantes, la primera fila corresponde a los días de la semana, se coloca como primer día el domingo por que es el séptimo día de la semana y lógicamente cuando se calcula el resto dividiendolo entre siete da cero.
La segunda fila es un array de arrays de integer, estos campos son calculables, pero son unos datos constantes de manera que no los meto en la función por la carga de proceso, que no seria muy grande, pero si el código lo llevamos a un proyecto más grande este se puede resentir por tanto calculo. De todos modos el calculo es muy sencillo, es el modulo de la suma de los módulos del máximo de días de los meses, o lo que es lo mismo si hablamos de marzo seria (31%7 + 28%7 + 31%7)%7, en año bisiesto seria (31%7 + 29%7 + 31%7)%7, siempre es lo mismo por eso no vale la pena y lo cargo en un método estático.

//Se cargan los datos que seran constantes durante todo el proceso.
public static final String[] diaSemana = {"Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado"};
public static final int[][]modulos = {{0,3,3,6,1,4,6,2,5,0,3,5},{0,3,4,0,2,5,0,3,6,1,4,6}};

Despues el metodo que hace falta para hacer el caculo seria:

public int calculoDia(Calendar fecha){
	//Generamos las variables necesarias
	AnnoBisiesto annoBisiesto = new AnnoBisiesto();//La clase que nos calculara si el año es bisiesto o no.
	Calendar c = new GregorianCalendar();//necesario para convertir los datos a fecha actual
	int diaSemana; //sera el dia que devolvemos 0 = Domingo
	int mM; // es el modulo del mes, es un dato calculable pero al ser constante lo pongo como estatico.
	int year = c.get(fecha.YEAR);//El año
	int dia = c.get(fecha.DAY_OF_MONTH);//El dia al que estamos
	int sum1, sum2, sum3, temp1, temp2, temp3;//creamos tres de las cuatro sumas. Los temporales hacen falta ya que no se cuenta el resto de las divisiones
	//miramos si el año es bisiesto para asignar 0 o 1, necesario para la seleccion del array
	int bisiesto = annoBisiesto.AnnoBisiestoGood(fecha)?1:0;
	//extraemos el modulo que se utilizara para la suma total
	mM = modulos[bisiesto][c.get(fecha.MONTH)];
	//El tratamiento son cuatro sumas de cuatro modulos de 7
	//la formula seria
	//((A-1)%7+((A-1/4)-(3*((A-1/100)+1)/4))%7+DM%7+D%7)%7
	//donde A=año, DM=Dias transcurridos hasta antes del primer dia del mes, D=dia, % = Modulo y en todas las divisiones solo se consideran las cifras enteras.
	sum1 = (year-1)%7;
	temp1 = (year - 1)/4;
	temp2 = (year - 1)/100;
	temp3 = ((temp2+1)*3)/4;
	sum2 = (temp1 - temp3)%7;
	sum3 = dia%7;
	diaSemana = (sum1 + sum2 + mM + sum3)%7;
	return diaSemana;
}

Recordemos que la división de dos enteros da como resultado un long, por eso utilizo los temporales, para que se eliminen los restos y trabaje solamente con enteros tras una división. Recordemos también que la función "annoBisiesto.AnnoBisiestoGood" esta escrita en la anterior publicación de este blog, por si alguno no sabe como calcular el año bisiesto.

Y con este código tenemos el calculo completo de en que día vivimos.

Año bisiesto en Java

Hay un problema muy simple de solucionar que es prácticamente uno de los primeros que se pide cuando estas estudiando programación, la gente normal, entre la que me incluyo, suele hacerlo paso a paso dando como resultado el "AnnoBisiestoBad" el cual es correcto al 100%, no nos engañemos, pero como se puede observar en "AnnoBisiestoGood" es que no es para nada optimo ya que con una sola linea podríamos haber resuelto el problema.

package LFR.Liem.Dazkun.Test.Java.Fecha.AnnoBisiesto;

import java.util.Calendar;

public class AnnoBisiesto{
	public boolean AnnoBisiestoBad(Calendar fecha){
	{
		int anno = fecha.YEAR;
	   //Si el año es divisible por 4, puede ser bisiesto
	   if (anno % 4 == 0){
	      if ((anno % 100 == 0) &&  //Si es divisible por 100
	           (anno % 400 != 0)){    //y no por 400
	             return false; //entonces no es bisiesto
	         }else{
	            return true; //En caso contrario sí lo es.
	         }
	      }else {//Si el año no es divisible entre 4 no es bisiesto.
	         return false;
	      }
		}
	}
	public boolean AnnoBisiestoGood(Calendar fecha){
		return (fecha.YEAR % 4 == 0) && !(fecha.YEAR % 100 == 0 && fecha.YEAR % 400 != 0);
	}
}

Esta es una parte del problema que intentare tener terminado a lo largo de la semana. La otra semana un compañero me planteo un problema que en un principio parece sencillo y es saber si estamos a lunes o a martes, algunos me dirán que eso ya lo hace de manera automática las librerías, pero que pasa si lo que quieres es extrapolarlo a otros entornos que no disponen de estas librerías, ¿alguno sabría hacerlo?, por eso me lo he planteado.