Leopard ...

Respaldo rápido de un disco duro en UNIX con dd

2011-11-30T09:46:00.001-03:00

dd es un comando muy potente que realiza copias bit-a-bit de un archivo a otro. Gracias a que en UNIX, todos los dispositivos son un archivo, podemos aprovechar esta característica para hacer copias de seguridad.

El uso básico de dd es:

$dd if={archivo_de_entrada} of={archivo_de_salida} bs={tamaño_bloque}

El tamaño de bloque indica más o menos la cantidad de bytes que se copiaran a la vez. Un tamaño de bloques pequeño permite una mayor tolerancia a fallos en el origen, mientras que un tamaño más grande permite una mayor velocidad.

Por ejemplo, una copia de disco a disco podría ser:

$dd if=/dev/hda of=/dev/sda bs=4096

También es posible usar un archivo de imagen:

$dd if=/dev/hda of=./imagen.img bs=4096 conv=noerror

El parametro conv=noeeror indica que continúe si se presenta un error de lectura.
Especificamos un tamaño de bloque de 4k para hacerlo más tolerante a errores de lectura.

Otra forma es utilizarlo en conjunto con gzip para hacer copias de respaldo comprimidas:

$dd if=/dev/hda conv=noerror bs=4k | gzip -c ./imagen.img.gz

O con gunzip para restaurar las imágenes de respaldo

$gunzip -z ./imagen.img.gz | dd of=/dev/hda bs=4k conv=noerror

Obviamente hay muchas más opciones, que pueden ser investigadas en el manual de dd

$man dd

Recorriendo Vectores gigantes con multiples hilos

2011-08-30T10:42:00.000-03:00

Hay momentos en la vida en que inebitablemente nos enfrentamos a la busqueda de un valor dentro de una coleccion gigante. Hay veces en que el uso de un contains(Object o) aplicado a una Collection puede ser suficiente, pero hay ocasiones en las que incluso esto no es bastante.
Hace poco me vi enfrentado a un problema en que dado un dato y un gran vector, debía aplicar un algoritmo de comparación especial que me impedía recurrir al contains().
El problema fundamental en este caso era que la comparación no se hacía directamente con un metodo equals() o un == sino que ambos datos debían ser entregados a un tercer objeto que se encargaba de la verificación, por lo que me vi enfrentado a un punto en el que mi unica vía era iterar uno a uno los elementos del vector.
En las pruebas de desarrollo el modelo funcionaba perfectamente, pero al ponerlo en producción comenzó a mostrar falencias en el rendimiento. Pese a que el algoritmo de verificación es eficiente, el ciclo for utilizado podía ser realmente demoroso.
Lugo de pensarlo un poco, llegué a una solución bastante aceptable, aprovechando las características multi hilo de Java.
La solución en si es simple: divide y vencerás. Corté el vector en N trozos de pequeño tamaño e inmediatamente lanzo N hilos de verificación simultánea que realizán la búsqueda. El primero que encuentre el dato grita "gané" y detiene a los demas hilos.

Visto paso a paso:

Establezco un tamaño de bloque. Por ejemplo 100 unidades. Cada hilo hará la búsqueda sobre este número de datos.
Divido el tamaño de mi vector en el tamaño del bloque. Si el resultado es menor a uno, significa que mi vector es menor al bloque, por lo que el resultado debe ser 1.
Preparo un espacio para que cada hilo notifique que ha terminado sin encontrar resultados.
Preparo un boolean para indicar que el dato fue encontrado.
Lanzo hilos de busqueda.
Espero...

La implementacion mas simple de esta algoritmo, podria hacerse asi:

public class Buscador {

private static final int TAM_BLOQUE = 100; //Tamaño del bloque
private static Logger logger = Logger.getLogger(Buscador.class.getName());
private boolean encontrado; //Indica que el dato fue encontrado
private List datos; //Donde se hara la busqueda
private Map flags; //Donde cada hilo indica que termino
private Resultado resultado; //El dato que fue encontrado

public Buscador(List datos) {
this.datos = datos;
}

/**
* Este metodo debe ser lanzado desde un hilo, no desde el event-dispatch
* thread ya que si no bloqueara la GUI
*
*/
public Resultado buscar(Muestra muestra) {
if (datos == null || datos.isEmpty()) {
return null;
}
//Sincronizo los datos para buscar desde muchos hilos
List vector = Collections.synchronizedList(datos);
int bloques = datos.size() / TAM_BLOQUES;
if (bloques < 1) {
bloques = 1;
}
flags = Collections.synchronizedMap(new HashMap(bloques));
final int largoSegmento = t / bloques;
encontrado = false;
resultado = null;
/*
* Este es el punto donde se lanzan los hilos de busquedas. Aprovechamos
* las caractristicas de las clases anonimas y el metodo sleep() de la
* clase Thread. Por eso este metodo debe lanzarse desde un hilo en
* segundo plano.
*/
for (int hilo = 1; hilo <= bloques; hilo++) {
final int nHilo = hilo; //Lo hacemos final para usarlo en la clase anonima
flags.put(nHilo, false); //El hilo aun no termina
Runnable busqueda = new Runnable() {

public void run() {
//Desde donde y hasta donde debe buscar este hilo
int desde = desde = (nHilo - 1) * largoSegmento;
int hasta = largoSegmento * nHilo;
/*
* Instancia del verificador. Es propia de cada clase,
* para asi evitar colisiones entre los hilos
*/
Verificador v = Verificador.newInstance();
for (int k = desde; k < hasta; k++) {
if (encontrado) {
logger.debug("Hilo " + nHilo + ": Otro hilo encontro el registro :(");
marcarfin();
return;
}
Object dato = vector.get(k);
//Realiza la verificacion. . .. bla bla bla
v.verificar(dato, muestra);
if (v.esValido()) {
logger.debug("Hilo " + nHilo + ": Encontre el registro! :D");
encontrado = true;
resultado = v.getResultado();
marcarfin();
return;
}
}
logger.debug("Hilo " + nHilo + ": Finalizo sin encontrar registro :(");
marcarfin();
}

/**
* Coloca en el mapa la marca de que este hilo ya temino.
*/
private void marcarfin() {
flags.put(nHilo, true);
}
};
new Thread(busqueda, "Hilo de busqueda " + hilo).start();
}
while (!encontrado && !finalizado()) {
try {
Thread.sleep(500L);
} catch (InterruptedException ex) {
//algo con la excepcion
}
}
return resultado;
}

/**
* Verifica que todos los hilos hayan finalizado.
*/
private boolean finalizado() {
for (boolean hiloFinalizado : flags.values()) {
if (!hiloFinalizado) {
return false;
}
}
return true;
}

}

A simple vista puede verse algo confuso, pero si examina con detencion, puede verse que el truco se encuentra dentro del ciclo for. Aqui se lanzan tantos hilos como deban ser lanzados. Cada hilo comparte algunos atributos con los demas hilos: Un mapa para grabar su estado, la variable donde se graba el resultado, un boolean para indicar que el dato fue encontrado y un vector sincronizado que es copia del original.

Cada hilo realiza la búsqueda en su espacio asignado dentro del gran vector. Asi, por ejemplo si nuestro vector tiene 1000 unidades y cada bloque es de 100, el primer hilo hará la busqueda desde el 0 al 99, el segundo desde el 100 al 199, el tercero desde el 200 al 299 y asi sucesivamente.

Obviamente los valores aqui expresados son para ejemplo, quiza puedan modificarse los valores para ajustarse a un escenario más real. La clase Verificador y sus metodos son ficiticias y la idea es que sea reemplazado por lo que se necesite. Del mismo modo puede optimizarse el uso de Generics en el buscador y hacer otras mejoras como eliminar el boolean "encontrado".

También puede limitarse el número de hilos lanzados aplicando un mecanismo de pausa y espera para el control de los hilos y varias mejoras más que se me van ocurriendo.

Actualmente esta implementación está funcionando perfectamente y mis usuarios no han vuelto a quejarse por lentitud.

=)

Reflexión

2011-07-26T16:57:00.002-04:00

Un buen programador no hace la pega.... hace un programa que haga la pega por él . . . .

Controlar JSpinner con la rueda del mouse

2011-07-26T12:50:00.001-04:00

Una caracteristica de una buena aplicacion con interfaz gráfica es la capacidad de responder a eventos que el usuario supone debe realizar para una determinada acción.

Me explico: Si un usuario ve un botón, la acción natural es hacer clic en el, pero también sería válido hacer que el botón responda a la tecla 'enter'.

Del mismo modo, en los JSpinner la acción natural es utilizar las flechitas y hacer clic en ellas para modificar el valor, pero si el mouse tiene rueda probablemente el usuario girará la rueda esperando modificar el valor del JSpinner.

Para que esto ocurra, se debe agregar al JSpinner un listener que implemente la interfaz MouseWheelListener. Java tiene por defecto una implementación vacía llamada MouseAdapter que simplifica la creación de listener ya que debe sobrecargarse sólo el método que necesitamos.

Manos a la obra: Una vez instanciado nuestro JSpinner agregamos un MouseAdapter con un código similar a éste:

JSpinner spinner = new JSpinner();
SpinnerModel modelo = new SpinnerNumberModel(0, 0, 100, 1);
spinner.setModel(modelo);
spinner.addMouseWheelListener(new MouseAdapter() {

@Override
public void mouseWheelMoved(MouseWheelEvent e) {
try {
Object mov = null;
if (e.getWheelRotation() == 1) {
//la rueda baja
mov = modelo.getPreviousValue();
} else if (e.getWheelRotation() == -1) {
//la rueda sube
mov = modelo.getNextValue();
}
if (mov == null) {
return;
}
modelo.setValue(mov);
} catch (Exception ex) {
ex.printStackTrace();
}
}
});

Como puede observarse, se agrega una clase anónima que extiende a MouseAdapter y sobrecargamos el método mouseWheelMoved(). En este método leemos el evento y determinamos la dirección en que se giró la rueda. Para ello invocamos el método getWheelRotation() que retornará un entero: -1 si la rueda "sube" y 1 si la rueda "baja".

Luego, sabiendo la direccion en que el usuario giró la rueda, le solicitamos al modelo del JSpinner el valor siguiente o anterior según el caso. Cuando se ha llegado al tope de valores del modelo (0 o 100 en el ejemplo) el modelo retorna null.

Teniendo el valor que debemos aplicar, se lo entregamos al modelo. Fin del problema.

Se pueden hacer varias mejoras al ejemplo (por ejemplo usar un switch en lugar de un if, pero eso queda a gusto del programador)

Primeras Impresiones de Kubuntu Karmic Koala

2009-10-23T16:51:00.001-03:00

En cuanto me entere de que se habia liberado la primera RC de Kubuntu 9.10 Karmic Koala me hice el animo y decidi dar el salto.

La actualizacion desde los repositorios de Chile tomo solo un par de horas y pude continuar trabajando normalmente mientras se hacia la actualizacion.

La primera impresion fue notar la ausencia de parpadeos en la pantalla al conmutar entre el splash de inicio y el entorno X. Este beneficio se obtiene por el uso del Kernel Linux 2.6.31-14.

Luego de un par de problemas con mi cliente SVN que pude solucionar purgando y reinstalando el paquete, pude comenzar a operar en serio.

Uno de los cambios que me dejo gratamente sorprendido es la optimizacion en el uso de memoria que tambien viene gracias al uso del Kernel 2.6.31. El plasmoide de uso de memoria y la luz de actividad del disco duro acusan un menor uso de memoria virtual para la misma cantidad de aplicaciones abiertas.

El rendimiento general tambien se vio incrementado. El comportamiento de Kwin por fin ha alcanzado un punto en el que no tiene nada que envidiar a otros sistemas de composicion. En mi caso particular me he visto beneficiado por las mejoras en el driver de la tarjeta Intel.

El aspecto grafico esta muy bien cuidado. Por ejemplo al instalar un programa con KPackageKit no utiliza una ventana GTK para pedir la contraseña de usuario sino que la aplicacion es "100% KDE". La integracion grafica de OpenOffice tambien agrega uniformidad al escritorio lo mismo que K3b (que por fin se integra visualmente con el tema de escritorio de KDE), auque no puedo decir lo mismo de otras aplicaciones que utilizan bindings GTK como Eclipse.

En resumen general, Karmic Koala cumple lo que promete: Un incremento en el rendimiento que el usuario notará y mejoras visuales que se agradecen.

La necesidad de inversion en TI en Chile

2009-10-21T15:46:00.002-03:00

Les contare una experiencia personal

Años atras participe en un proyecto de empresa con unos amigos en el que desarrollamos tecnologia para garantizar la trazabilidad de productos agricolas. El software era muy bueno, combinabamos lo mejor de la tecnologia móvil, software libre y un desarrollo innovador, creando un producto nacional que tenía un gran potencial para dotar a la industria agricola Chilena con una excelente herramienta de apoyo.

Intetamos infructuosamente de obtener algun apoyo estatal ya que los ciclos de venta de este tipo de proyectos son largos, lo que no genera ingresos a corto plazo y por otro lado la mano de obra altamente calificada requiere pagar buenos salarios y contar con una oficina medianamente decente para reunirse con los clientes. Pese a que contamos con el apoyo de algunos empresarios y logramos cerrar algunos proyectos, se necesitaba una inyeccion de recursos importante en los primeros años de funcionamiento.

Golpeamos las puertas de todos los bancos, recurrimos a varios ministerios, postulamos a varios proyectos y al final tuvimos que bajar la cortina. Me quedo una muy mala sensacion de la importancia que se le da a la industria nacional, sobre todo en el sector TI. Hasta el momento no existe una politica clara del gobierno para entregar apoyo al emprededor (en todas las areas) y mas aun en el área de TI.

Con mucha tristeza he visto grandes acuerdos que cierra el gobierno con empresas extranjeras, entregando recursos preciosos que podrian ser invertidos en la industria nacional obtieniendo los mismos resultados a corto plazo, pero generando a largo plazo una plataforma de conocimento y experiencia que potencialmente se puede transformar en un producto de exportacion que generaria mucha riqueza.

Solo basta imaginar que hubiera pasado si hubieramos conseguido el apoyo necesario en el moento necesario. Probablemente hoy en dia seriamos lider en sistemas de trazabilidad agrícola y quiza ya estariamos exportando nuestro conocimiento generando riqueza y puestos de trabajo que tan necesarios son hoy en dia.

Tambien imagino una distribucion Linux desarrollada en conjunto por muchas universidades, institutos y liceos con patrocinio del estado. Imagino empresas recibiendo regalias tributarias en la medida que implementan esta distribucion. Imagino computadores ensamblados aqui en Chile con software nacional a bajo costo para todo ciudadano. Imagino muchas empresas utilizando estas herramientas y contratando a los profesionales surgidos de estas universidades e institutos prestando servicios aca y exportando su know-how a otros paises.

He visto nacer y morir muchas empresas TI aca en Chile por falta de apoyo estatal. Por lo mismo creo que se hace necesario un rol mas activo del estado que vaya en apoyo del pequeño y mediano empresario que quiera innovar en tecnologia. Tal como dicen muchos, tecnologia no es lo mismo que internet. No estamos en condiciones de desarrollar una industria pesada o una industria de alta tecnologia (hardware) que sea competitiva con los estandares internacionales, pero si estamos en condiciones de desarroollar una industria basada en el software que puede potenciar y revolucionar el modelo economico nacional. Las herramientas estan al alcance de la mano, hay mucha innovacion aca, hay mucha gente inteligente, trabajadora y emprendedora. Solo hace falta darles una mano.

Horas extras

2009-10-14T12:20:00.000-03:00

2 horas extras diarias.. de 18:00 a 20:00 hrs, justo cuando comienza el horario de verano. Que lindo!!!

Hay que ganarse el pan, asi que es mejor dedicarse de cabeza a eso, debemos establilizar una version del programa que cariñosamente llamamos 'incompilable' mientras que debemos hacer mejoras de ultimo minuto a la version estable.

Makepkg version PI

2009-09-08T08:45:00.000-04:00

En Slackware 13:

Slackware package maker, version 3.14159

:-P

Slackware 13 a la carta

2009-09-03T08:54:00.003-04:00

Acabo de enterarme del lanzamiento de la version 13 de la veterana distribucion Slackware Linux.

Ha pasado mucha agua bajo el puente desde que probe linux por primera vez en 1998. Y dado que Slackware (version 3.3) fue lo primero que conoci, paso a ser mi distribucion favorita durante muchos años, llegando incluso a escribir un libro con algunos consejos para la utilizacion y aprendizaje.

Cambios en mi enfoque de usuario, insatisfaccion con el ritmo de desarrollo y software disponible y otras cosas que no viene al cabo mencionar me hicieron abandonar el uso de esta distribucion cuando se encontraba en la version 11 (creo). Aun asi siempre tuve el DVD a mano ya que hasta el momento no he conocido otra distribucion que funcione en modo Live sin tratar de iniciar X, lo que se agradece cuando la tarjeta de video no esta soportada (lease ATI).

Hace un par de meses atras tuve que descargar el DVD de la version 12.2 para probar un servidor con tarjeta RAID que era imposoble de hacer funcionar con otras distros (Centos, Ubuntu y Suse no se la pudieron). Al comprobar que Slackware arrancaba sin problemas y felizmente reconociendo de inmediato la controladora e ignorando cualquier otro error, retumbaron en mi mente las palabras 'Keep it simple, stupid'.

Y bien, hoy me disponia a instalar Slackware 12 en una maquina virtual cuando solo por curiosidad visito la pagina oficial. Asi es como me encuentro con la agradable noticia de una nueva version de la que fue mi primer amor. Una lectura del anuncio oficial hizo que me pusiera a descargarla de inmediato y ahora solo espero que termine pronto la descarga para probarla en una maquina REAL y no virtual:

Por primera vez Slackware tiene un port oficial a 64 bits. Era algo de realmente necesario y que de hecho me tenia desencantado.

Entornos de escritorio XFCE 4.6.1 y KDE 4.2.4. Personalmente creo que habria sido mejor incoporar KDE 4.3.0 pero considerando que fue lanzado hace poco... quiza en la version current....

Kernel 2.6.29. Debo agregar que Slackware es la unica distribucion de todas las que he probado que nunca me ha dado problemas con los drivers propietarios de ATI y Nvidia

GNU Lib C 2.9

GCC 4.3.3

Una coleccion de paquetes de X 'remasterizada' que en muchos casos presciende del archivo de configuracion

Un nuevo formato de paquetes 'txz' con mayor compresion y otras mejoras

Ahora solo espero que termine de bajar para probarlo... espero reencantarme.

bytes!!!

Eclipse v/s Netbeans . . . Introduccion

2009-08-28T11:29:00.002-04:00

Una disputa de nunca acabar. Una guerra santa mas
en el universo del software.

Cuando no es Windows v/s Linux, Kde v/s Gnome, GTK v/s QT. Siempre hay un buen motivo para pelear. Y como no se puede ser menos, tambien hay bandos que luchan a muerte por imponer al bando contrario la idea de que su IDE favorito es el mejor.

No pretendo aqui decantarme por un bando en particular. He usado ambos IDE en los ultimos 6
meses, lo suficiente como para dar una opinion objetiva y sin cegueras causadas por el fanatismo. Cada IDE tiene sus pro y sus contra, y la decision final dependera de las necesidades y el gusto personal de cada uno.

Preparando el terreno:

Antes de comenzar, quiero poner mis piezas sobre el tablero
para que asi se entienda en cierta manera mi perspectiva:

Llevo casi 3 años programando en Java, 11 años usando Linux, y trabaje 5 años como administrador de redes antes de programar.

Cuando aprendi Java (hice un curso), fue con Eclipse. Mis primeros pasos en Java fueron con Eclipse.

Durante 1 año y medio aprox trabaje exclusivamente con NetBeans, desarrollando en J2EE, Struts y Swing.

Los ultimos 6 meses han sido simultaneamente en Eclipse y Netbeans dependiendo del problema a enfrentar. Ha sido trabajando en una aplicacion Swing con base de datos Postgres

Durate los proximos meses ire escribiendo acerca de mis impresiones, las cuales emanan desde una prespectiva de usuario de la aplicacion, el cual debe lidiar con factores como la configuracion, ayuda, herramientas disponibles, extensiones, bugs, etc. Factores que finalmente influyen en algo tan trascendental como es la productividad de quien utiliza estas herramientas.

No pretendo hacer una comparación demasiado acuciosa, sino más bien que estas líneas y sus futuras extensiones sirvan de orientación al usuario neófito que debe decidir por cual herramienta decantarse.

Let's dance!

AudioCopy 0.1

2009-08-21T08:44:00.005-04:00

AudioCopy es una sencilla herramienta para copiar y transferir archivos de audio
desde una carpeta a otra.

A diferencia de los complementos y plugins de algunos reproductores de musica,
AudioCopy tiene algunas ventajas:

Copia hasta 4 archivos simultaneamente (por defecto 2)

Permite pausar las copias

Es ligero y consume pocos recursos del computador.

100% Java. Puede ser ejecutado en cualquier computador con Java 6 o superior

Codigo Libre. Puedes modificar, contribuir o simplemente curiosear respetando
la licencia. Tambies puedes compartirlo con quien quieras.

Facil de usar. Su interfaz es simple y no tiene menus extravagantes o atajos
dificiles de aprender.

Caracteristicas de la version actual 0.1

Hasta 4 copias simultaneas

Pausado de copia.

Agregar nuevas pistas a la cola mientras copia.

Crea carpetas destino segun tags de archivos de audio

Licencia GPL V2

artista/año - album/pista - titulo.extension
Depeche Mode/1997 - Ultra/01 - Barrel of a Gun.mp3

Requisitos:

Java 1.6 o superior

Errores conocidos en la version actual.

Falla con carpetas de musica demasiado grande

Se puede cambiar la carpeta origen durante la exploracion, lo que da problemas

No manipula bien los errores durante la copia (disco lleno, etc.)

Mejoras proximas:

Corregir errores conocidos

Acelerar la exploracion.

Recordar carpetas origen (con contenido) y destino.

Cancelar la copia

Seleccionr codificacion (ISO/UTF) segun filesystem de carpeta destino

Posiblemente en un futuro distante:

Tooltips y ayudas contextuales

Informar progreso de copias individuales.

Editor de tags

Detectar automaticamente unidades USB

¿Reproductor? ... por ahora me quedo con Jajuk

La version actual puede obtenerse aqui

Control y pausa de ciclos for, do, while en Java

2009-08-19T09:16:00.005-04:00

Un problema que sucede a menudo cuando se necesita procesar gran cantidad de informacion en un ciclo for o do/while es el de pausar el ciclo, esperar alguna señal y continuar.

for (condicion) {
    ....hacer algo...
    ....esperar....
    ....continuar.....
}

Por ejemplo, un problema al que me vi enfrentado fue el de ingresar el precio para una gran cantidad de productos, teniendo los productos en un Collection, parecia facil iterar sobre este listado, mostrar una ventana para que el usuario ingresara el precio y continuar:

Collection productos;
for (Producto p : productos) {
    ingresarPrecio(p);
}

A primera vista se ve simple, pero si este codigo es ejecutado, su resultado sera abrir tantas ventanas de ingreso como productos tenga el Collection.

La forma de ir mostrando las ventanas de forma ordenada, es pausar el ciclo for hasta que la ventana genere algun evento. Para ello lo primero sera hacer correr el ciclo dentro de un Thread diferente del actual de forma que pueda ser controlado sin interrumpir la ejecucion del programa:

Runnable hiloFor = new Runnable() {

    public void run() {
        for (Producto p : productos) {
            ingresarPrecio(p);
        }
    }
}

new Thread(hiloFor).start;

Esto lanzara nuestro ciclo for en un hilo distinto del actual, abriendonos la posibilidad de control. Para ello utilizaremos los metodos proporcionados por la clase Thread.

Lo que haremos a continuacion sera sincronizar el Thread donde vive nuestro ciclo for con el Thread principal donde se enta ejecutando nuestra aplicacion (en el caso de una aplicacion Swing sera el Event dispatching thread

Collection productos;
Thread hilo;

Runnable hiloFor = new Runnable() {

    public void run() {
        Thread actual = Thread.currentThread();
            synchronized(actual) {
                for (Producto p: Productos) {
                    ingresarPrecio(p);
                    actual.wait();
                }
            }
        }
}

hilo = new Thread(hiloFor);
hilo.start();

Puede notarse de inmediato los cambios introducidos: Primero obtenemos el objeto Thread donde se ejecuta nuestro for y luego ejecutamos el ciclo dentro de un bloque sincronizado con este hilo, invocamos el metodo que abre la ventana y pausamos la ejecucion del hilo.

En este punto el hilo donde se ejecuta el ciclo for estara pausado de forma indefinida esperando la señal notify(). Luego el metodo ingresarPrecio(Producto p) debera:

Abrir la ventana para ingresar el precio en el event dispatching thread

Notificar al hilo que puede continuar una vez se haya hecho el ingreso

Para ello, bastara que el metodo ingresarPrecio(Producto p) incluya en su interior algo similar a:

ingresarPrecio(final Producto p) {
    Runnable abrir = new Runnable() {

        public void run() {
            VentanaIngreso v = new VentanaIngreso(p);
            v.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    continuar();
                }
            });

        }

        private void continuar() {
            synchronized (hilo) {
                hilo.notify();
            }
        }
    }

    SwingUtilities.invokeLater(abrir);
}

La parte importante aca es el metodo continuar(). Aqui se le dice al hilo que continue ejecutandose. Como puede verse en este sencillo ejemplo, este metodo se llama desde un ActionListener que sera gatillado dentro de la ventana de ingreso ante ciertas acciones (cancelar, grabar el precio, etc).

El ejemplo puede mejorarse y extenderse a otras situaciones.

Bytes!

Control de Look and Feel en Swing

2009-08-13T09:19:00.003-04:00

Un problema recurrente de los usuarios de aplicaciones
creadas en Java es el del look an feel. "No se ve como
si fuera windows" es el tipico comentario de quien usa
una aplicacion Swing en este sistema operativo. Los
usuarios de *nix estan mas acostumbrados a las diferencias
de l&f segun el toolkit de la aplicacion (gtk+, qt, motif.. etc)
y no suelen quejarse tanto.

Personalmente encuentro horrible el l&f por defecto (metal)
asi que tengo a mano un codigo que selecciona automaticamente
el l&f dependiendo del sistema:

----------

String jVersion = System.getProperty("java.version");
String os = System.getProperty("os.name");
String[] ver = jVersion.split("_");
if (ver.length > 0) {
String vMajor = ver[0];
Double update = Double.parseDouble(ver[1]);
try {
if (vMajor.compareTo("1.6.0") > -1 && update >= 10) {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
} else {
if (os.toLowerCase().contains("windows")) {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
} else if (os.toLowerCase().contains("linux")) {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.gtk.GTKLookAndFeel");
}
}
} catch (ClassNotFoundException ex) {
Logger.getLogger(Main.class.getName()).log(Level.WARNING, bundle.getString("error.lf"), ex);
} catch (InstantiationException ex) {
Logger.getLogger(Main.class.getName()).log(Level.WARNING, bundle.getString("error.lf"), ex);
} catch (IllegalAccessException ex) {
Logger.getLogger(Main.class.getName()).log(Level.WARNING, bundle.getString("error.lf"), ex);
} catch (UnsupportedLookAndFeelException ex) {
Logger.getLogger(Main.class.getName()).log(Level.WARNING, bundle.getString("error.lf"), ex);
}
}

----------

El codigo en si es bastante simple:

- Obtengo la version de la VM de java.
- Obtengo el nombre del sistema operativo.
- Obtengo el numero de actualizacion de la VM.

Desde el update 10 de la JVM 1.6 se encuentra disponible
el l&f "Nimbus", asi que si nuestra version de JVM es
1.6_10 o superior se selecciona este L&F para la
aplicacion. En caso contrario si el sistema es Windows
se selecciona el L&F de Windows, si el OS es Linux
se selecciona el L&F GTK (como quisiera un l&f QT!!!).

Si no es posible seleccionar alguno de estos L&F se
mantendra el por defecto (metal).

Bastara con que este codigo se inserte en el main() de
nuestra aplicacion Swing, antes que se dibuje el primer
JFrame y lo demas sera coser y cantar.

Esta solucion es muy simple y utiliza las bibliotecas
estandar de la JVM. No obstante podemos extender
las capacidades de L&F de nuestra aplicacion utilizando
la completisima biblioteca substance.

bytes!!

Moviendo un JScrollPane de forma automatica

2009-08-12T17:46:00.002-04:00

Uno de los problemas clasicos al tener un JPanel dentro
de un JScrollPane es como mover automaticamente la
barra de Scroll del JScrollPane. Para ello existe el metodo
scrollRectToVisible(Rectangle r) que hara que el o los
ScrollBar se desplazen para hacer que el rectangulo indicado
sea visible.

Hasta aqui la cosa no es muy complicada, pero ¿que ocurre
si dentro de nuestro JPanel tenemos uno o mas JPanel
anidados? La cosa tiende a complicarse un poco ya
que la posicion final de nuestro componente es desconocida
para el JScrollPane.

Consideremos el siguiente ejemplo:

--------------------
JScrollPane scrPane = new JScrollPane();
JPanel panelPrincipal = new JPanel();
JPanel panelAnidado1 = new JPanel();
JPanel panelAnidado2 = new JPanel();

JLabel label = new JLabel("....");
JTextField txt = new JTextField("......")M

panelAnidado2.add(txt);
panelAnidado2.add(label)

panelAnidado1.add(panelAnidado2);
panelPrincipal.add(panelAnidado1)

scrPane.setViewportView(panelPrincipal);
----------------------

Si queremos desplazar el JScrollPane hasta la posicion del
label o el txt, la primera idea que se nos viene a la cabeza
seria:

-------
scrPane.scrollRectToVisible(label.getBounds());
-------

Lamentablemente esto no funcionara ya que scrPane solo
"sabe de la existencia" de panelPrincipal e ignora su contenido.
Por lo tanto lo que debemos hacer es calcular la posicion
relativa de label con respecto a panelPrincipal.

Para ello, el siguiente codigo de ejemplo puede ser util;

-------------

//obtengo el padre del label (panelAnidado2)
JPanel padre = (JPanel) label.getParent();
//Obtengo la posicion del padre
Point posPadre = padre.getLocation();
//Obtengo el 'padre del padre' (panelAnidado1) y su posicion
JPanel padre2 = (JPanel)
Point posPadre2 = padre2.getLocation();

//Conociendo las posiciones, puedo hacer el calculo
Double y = posPadre2.getY() + posPadre1.getY() + label.getLocation.getY();

/*
* la variable y contiene la distancia desde el borde del
* panelAnidado1 hasta el borde del label
*/
//Creo un punto en la posicon relativa del Label

Point relativo = new Point(new Double(posPadre2.getX()).intValue(), y.intValue());

//Con este punto relativo puedo crear un rectangulo y desplazar el JScrollPane

Rectangle moverA = new Rectangle(relativo, label.getPreferredSize());
scrPane.scrollRectToVisible(moverA);

---------------

Resumen:

Como 'panelPrincipal' desconoce la presencia y posicon
de label, calculamos la posicion relativa de label con
respecto a 'panelPrincipal' en base a la posicion de su padre
y cualquier panel previo. Una vez conocida esta posicion
relativa, basta desplazar el scrPane hasta un rectangulo
ubicado en esta posicion relativa con el tamaño del
componente que queremos enfocar.

Agregando este codigo a un FocusListener, es facil
hacer que el JScrollPane se desplace hasta la posicion
del componente que obtiene el foco:

Ejemplo:
--------------

scrollOpcional = new FocusAdapter() {

@Override
public void focusGained(FocusEvent e) {
Point posicionOpcional = panelOpcional.getLocation();
JPanel parent = (JPanel)e.getComponent().getParent();
Double y = posicionOpcional.getY() + parent.getLocation().getY();
Point relativo = new Point(new Double(posicionOpcional.getX()).intValue(), y.intValue() + parent.getHeight());
panelIngreso.scrollRectToVisible(new Rectangle(relativo, parent.getPreferredSize()));
}
};
--------------

bytes!

BLOG??

2009-01-22T15:06:00.002-03:00

Veo que por fin la interfaz de Blogspot ha mejorado un poco.

Lo suficiente para animarme a escribir de vez en cuando.

La vida ya tiene demasiadas interfaces: los mandos de un vehículo, las ventanas de windows, la consola de Linux, la interfaz del celular, el idioma de las mujeres... si a eso sumamos que para escribir idioteces que nadie lee debes entenderte con una interfaz maldita que apenas se entiend, poco ánimo queda de publicar entradas...

en fin.. a ver si me hago el animo

return

2007-06-05T16:07:00.000-04:00

volviendo a esto del blog....

espero escribir mas seguido, aunque nadie lo lea