JDialog con imagen de fondo

Luego de varias preguntas relacionadas al tema (ubicar una imagen de fondo a un JDialog) me puse a trabajar en el tema y les presento una solución, la misma que sigue lo explicado en el post JFrame con Imagen de Fondo.

El proyecto está estructurado como muestra la imagen a continuación:

Imagen con la estructura del proyecto en NetBeans
Imagen con la estructura del proyecto en NetBeans

La descripción de la misma es la siguiente:

  • El JFrame – FrmPrincipal.java tiene un botón cuya función es mostrar el JDialog.
  • El JDialog – JDiFondo.java, muestra un JPanel
  • Un JPanel – PnlFondoJDialog.java, que muestra la imagen y un botón.

Veamos el código más importante de cada uno de los elementos, empecemos por el JFrame –  FrmPrincipal.java

public class FrmPrincipal extends javax.swing.JFrame {
   /** Creates new form FrmPrincipal */
   public FrmPrincipal() {
      initComponents();
   }

   private void btnMostrarActionPerformed(java.awt.event.ActionEvent evt) {
      int ancho = 300;
      int alto = 300;
      JDiFondo jdiFondo = new JDiFondo(this, true);
      jdiFondo.setSize(ancho, alto);
      jdiFondo.setPreferredSize(new Dimension(ancho, alto));
      jdiFondo.configurar();
      jdiFondo.setVisible(true);
   }
   ...
}

Usamos setSize y jdiFondo.setPreferredSize, el primero nos permite que la imagen y la ventana del JDialog tengan el mismo tamaño, también se invoca la método configurar del JDialog que lo explicaremos más adelante.

Ahora veremos el JDialog – JDiFondo.java

public class JDiFondo extends javax.swing.JDialog {
   /** Creates new form JDiFondo */
   public JDiFondo(java.awt.Frame parent, boolean modal) {
      super(parent, modal);
      initComponents();
   }

   public void configurar(){
      PnlFondoJDialog pnlFondo = new PnlFondoJDialog();
      pnlFondo.setSize(this.getSize());
      this.add(pnlFondo, BorderLayout.CENTER);
      this.pack();
   }
   ...
}

Lo que debemos destacar de está clase es el método configurar, que no existía cuando trabajamos en el post anterior (ubicar la imagen en un JFrame – JFrame con Imagen de Fondo) es necesario éste método por que si ubicamos sus líneas de código en el constructor el panel toma la medida por defecto del JDialog ya que hasta ese momento no le asignamos un tamaño al JDialog (Ver el método btnMostrarActionPerformed del JFrame).

Finalmente el JPanel – PnlFondoJDialog.java este no ha cambiado y sigue el mismo principio que se mencionó en el post: JFrame con Imagen de Fondo.

public class PnlFondoJDialog extends javax.swing.JPanel {
   /** Creates new form PnlFondo */
   public PnlFondoJDialog() {
      initComponents();
   }

   @Override
   public void paintComponent(Graphics g){
      Dimension tamanio = getSize();
      ImageIcon imagenFondo = new ImageIcon(getClass().
      getResource("/los/imagen/DSC00857.jpg"));
      g.drawImage(imagenFondo.getImage(), 0, 0,
      tamanio.width, tamanio.height, null);
      setOpaque(false);
      super.paintComponent(g);
   }
   ...
}

El resultado final lo pueden ver en la siguiente imagen:

Ejemplo de un JDialog con imagen de Fondo
El resultado final

El código completo lo pueden descargar aquí.

Espero que les ayude

Loxa Web Site Export – Plugin para Gephi

Un post luego de muchooooooo tiempo.

Hace algún tiempo ya conocí y trabajé con Gephi, una herramienta open source para realizar análisis de redes sociales o SNA por sus siglas en inglés. Gephi está construido sobre la plataforma de  NetBeans, lo que le permite que sea extensible agregando nuevos plugins, de hecho existen ya varios plugins y siguen creciendo.

Es así como iniciamos la construcción de un plugin que nos permita visualizar el resultado de los análisis que se realizan en Gephi. El plugin lo denominamos Loxa Web Site Export y es un plugin que exporta el análisis realizado a un sitio Web, que es fácil de personalizar (a través de hojas de estilos) y enriquecer con descripciones de cada uno de los gráficos (editando un archivo JSON). Una imagen que muestra un sitio publicado con nuestro plugin:

Loxa Web Site Export una demostración
Un ejemplo del uso de nuestro plugin

Usámos Gephi para realizar un meta-análisis del proyecto TAEE aplicando análisis de redes sociales, y lo resultados los publicamos usando el plugin y lo publicamos aquí.

Obviamente el plugin fue desarrollado en JAVA usando las siguientes tecnologías:

  • JSOUP: para armar la página principal del sitio Web
  • GSON: para transformar un objeto a un archivo json
  • Seadragon: que nos permite crear imágenes con nivel de zoom-in bastante alto. Si bien no es tecnología Java, existe una implementación Java.
  • PDF-Renderer: que permite crear un documento pdf en memoria y luego usarlo para crear la imágenes que se usaran Seadragon
En el sitio Web generado se usan varios plugins de jQuery, json, etc.
En próximas entradas iré explicando como se usó algunas de las tecnologías para construir el plugin. Empezaremos explicando cómo generar una imagen que sirve de leyenda para explicar el significado de los colores que se usaron en un análisis.
Fue mi primera experiencia con la plataforma de NetBeans y me pareció una experiencia enriquecedora como programador

Códigos QR con Java – Aplicados vía Linked Data para dispositivos móviles

Hace algunos meses ya que me enteré de la existencia de los códigos QR (aquí una explicación vía Wikipedia) y pensando en una alguna aplicación llegué a formular una, no sé si sea innovadora. Se las explico a continuación.

Mensualmente recibimos el estado de cuenta de las tarjetas de crédito y tenemos una fecha máxima de pago, mi rutina es: registrar una nota con alarma en la agenda de mi celular, en el último día de pago; en la nota registro el nombre del banco, de la tarjeta de crédito y el monto a pagar.

Ahora, desde mi punto de vista, sería ideal que de alguna manera pudiera leer esa información a través de mi celular y registrarla como una nota en mi agenda. Si leen la entrada de la Wikipedia comprenderán que el código de barras no es suficiente y de ahí la necesidad de códigos QR en donde puedo almacenar mayor información.

Para que la información sea expresada en algún «formato universal» he pensado que debería crear un vocabulario en RDF y siguiendo los principios de Linked Data para vincular la información y de esa manera enriquecerla. Hace tiempo leí de alguna propuesta de usar RDF como un medio para almacenar la información de un celular (cuando encuentre el link lo coloco). También es posible leer archivos RDF/XML en un dispositivo móvil usando NanoXML for J2ME (+RDF/OWL).

Conozco de algunas aplicaciones para Symbian que usando la cámara del celular pueden leer el código QR y abrir el navegador o copiar la información que ahí existe, pero siendo una aplicación específica se debería desarrollar algo así y ese desarrollo tendría que ser en Java. Buscando en internet conseguí una librería que permite generar y leer códigos QR, el proyecto se llama QR Code Library, además encontré un ejemplo en dónde se usa esta librería en una aplicación móvil llamada QRMidlet

Creo que la aplicación puede extenderse a cualquier documento, por ejemplo (recuerdo de la ferretería de mis abuelos) ellos trabajan con cheques y giran un cheque cuando reciben la factura sería ideal que la factura contenga la información del pago (fecha, monto, datos del proveedor), si esta información la pudiera leer de manera automática y almacenarla en algún sistema llevaría el control de las cuentas por pagar. 🙂

Bueno la idea está propuesta, espero poder hacer algo aunque sea desarrollar el vocabulario, ya cada vez estoy más lejos de la programación para móviles, pero bueno la idea está propuesta si alguien se anima a colaborar será bienvenid@. Los mantendré informados.

Consultas DBpedia con Java – Linked Data

Dentro de la Web semántica, una de las iniciativas que de a poco va ganando relevancia es la Web de datos o también conocida como Linked Data o también como Linked Open Data, aquí una presentación que explica Linked Data, que a través de 4 principios determina la forma en la que los datos deben ser descritos y publicados. Bajo estos preceptos se han generado varios Datasets, uno de ellos es DBpedia que es la versión semántica de la wikipedia. La mayoría de los Dataset poseen mecanismos de consulta que a través de SPARQL nos permiten tener acceso a la información que ahí se publica. Los mecanismos de consulta son servicios Web basados en REST.

En este post mostraremos como realizar consultas a la DBPedia a través de Java. Para ellos usaremos Jersey que es un API que no permite trabajar con servicios REST. Antes de pasar a realizar cualquier explicación les describiré brevemente la aplicación, el objetivo de la aplicación es encontrar el país al cual pertenece un punto cardinal expresado en latitud y longitud. Para ello vamos a realizar la siguiente consulta:

SELECT ?pais ?lat ?long WHERE {
?pais rdf:type <http://dbpedia.org/ontology/Country>.
?pais geo:lat ?lat FILTER (datatype(?lat) = xsd:float && (?lat-0.2273363048115043) < 0.005 && (-0.2273363048115043-?lat) < 0.005).
?pais geo:long ?long FILTER (datatype(?long) = xsd:float && (?long-78.892578125) < 0.005 && (-78.892578125-?long) < 0.005)
}

Para ejecutar la consulta y ver los resultados click aquí. Podemos ver en la consulta que estamos consultando los países (rdf:type <http://dbpedia.org/ontology/Country) que tenga sus valores de latitud y longitud como números tipos float (datatype(?lat) = xsd:float  y datatype(?long) = xsd:float) y ademas calculamos la diferencia en la latitud y longitud de cada país con los valores que los obtenemos de alguna manera (yo los obtuve con google maps). Si bien este método no es el mejor ha sido el que relativamente a funcionado mejor y según leí en algún lugar es una recomendación de la dbpedia.

Actualización 19/08/2010: La consulta anterior no dio buenos resultados por lo que busqué otras formas de consultar el país y encontré dos. La primera y que uso es invocando a un servicio, obviamente REST, CountryCode / reverse geocoding cuyo detalle lo pueden encontrar aquí – GeoNames. La segunda opción es usar Google Maps con su clase GClientGeoCoder y su método getLocations, detalles aquí. Que tiene su contraparte con la librería de Maps en GWT.

Con la consulta ya estructurada es hora de armar la URL del servicio que consumiremos. La URL tiene la siguiente forma: http://dbpedia.org/sparql?default-graph-uri=<valor>&query=<consulta>&output=<tipo_salida>

Para el ejemplo los valores son (para <consulta> el valor es la consulta SPARQL que les mostré anteriormente):

<valor> = http://dbpedia.org

<tipo_salida> = json

Veamos el código Java del programa


import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import javax.ws.rs.core.MediaType;
import org.codehaus.jettison.json.JSONArray;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
/**
*
* @author jorgaf
*/

public class ClienteDBpedia {
   public static final String WS_URL_DBPEDIA = "http://dbpedia.org/sparql";
   public static void main(String[] args) {
      String defaultGraph = "http://dbpedia.org";
      String qry = "SELECT ?nombre ?tGobierno ?capital ?area ?moneda "
                + "?imagen ?descripcion\n WHERE { \n"
                + "?pais rdf:type <http://dbpedia.org/ontology/Country>. \n"
                + "OPTIONAL{?pais dbpprop:areaKm ?area.\n"
                + "?pais dbpprop:currencyCode ?moneda.\n"
                + "?pais dbpedia-owl:capital ?capital}.\n"
                + "OPTIONAL{?gobierno rdf:type <http://dbpedia.org/class/yago/FormsOfGovernment>.\n"
                + "    ?pais dbpedia-owl:governmentType ?tipoGobierno FILTER (?tipoGobierno = ?gobierno)}.\n"
                + "?pais rdfs:label ?nombre FILTER langMatches( lang(?nombre), \"ES\" ).\n"
                + "OPTIONAL{?gobierno rdfs:label ?tGobierno FILTER langMatches(lang(?tGobierno), \"ES\")}.\n"
                + "?pais rdfs:label ?nombreEng FILTER (langMatches( lang(?nombreEng), \"EN\" ) && ?nombreEng = \"Ecuador\"@en).\n"
                + "?pais dbpedia-owl:abstract ?descripcion FILTER (langMatches( lang(?descripcion), \"ES\" )).\n"
                + "?pais dbpedia-owl:thumbnail ?imagen\n"
                + "}";
      String salida = "&output=json";
      String url = "";
      try {
         defaultGraph = URLEncoder.encode(defaultGraph, "UTF-8");
         qry = URLEncoder.encode(qry, "UTF-8");
      } catch (UnsupportedEncodingException ex) {}

      Client client = new Client();
      url = WS_URL_DBPEDIA + "?default-graph-uri=" + defaultGraph
         + "&query=" + qry + salida;
      WebResource resource = client.resource(url);
      String result = resource.accept("application/sparql-results+json").
         get(String.class);
   try {
      procesar(result);
   } catch (JSONException ex) {}
 }

 private static void procesar(String res) throws JSONException{
    JSONObject result = new JSONObject(res).getJSONObject("results");
    JSONArray bindings = result.getJSONArray("bindings");
    JSONObject pais;
    JSONObject lat, lon;

    for (int i = 0; i < bindings.length(); i++) {
       pais = bindings.getJSONObject(i).getJSONObject("pais");
       lat = bindings.getJSONObject(i).getJSONObject("lat");
       lon = bindings.getJSONObject(i).getJSONObject("long");
       System.out.printf("País: %s Lat: %s Lon: %s\n",
       pais.get("value"),
       lat.get("value"),
       lon.get("value"));
    }
  }
}

Podemos ver como es necesario codificar los valores de las default-graph-uri, query y output. El programa muestra también como trabajar con información en formato JSON que fue el valor que le asignamos para la salida, vea le método procesar para ver como se pueden obtener los datos. La salida que se obtiene son las siguientes:

{ "head": { "link": [], "vars": ["pais", "lat", "long"] },
"results": { "distinct": false, "ordered": true, "bindings": [
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Gabon" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "0.3833333253860474" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "9.449999809265137" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Kenya" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-1.266666650772095" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "36.79999923706055" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/S%C3%A3o_Tom%C3%A9_and_Pr%C3%ADncipe" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "0.3333333432674408" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "6.733333110809326" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Rwanda" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-1.943883299827576" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "30.05945014953613" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Royal_Audience_of_Quito" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-0.25" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-78.58333587646484" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Ecuador" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-0.1500000059604645" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-78.34999847412109" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Somalia" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "2.033333301544189" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "45.34999847412109" }} ] } }

Mientras que la salida ya procesada es la siguiente:


País: http://dbpedia.org/resource/Gabon Lat: 0.3833333253860474 Lon: 9.449999809265137
País: http://dbpedia.org/resource/Kenya Lat: -1.266666650772095 Lon: 36.79999923706055
País: http://dbpedia.org/resource/S%C3%A3o_Tom%C3%A9_and_Pr%C3%ADncipe Lat: 0.3333333432674408 Lon: 6.733333110809326
País: http://dbpedia.org/resource/Rwanda Lat: -1.943883299827576 Lon: 30.05945014953613
País: http://dbpedia.org/resource/Royal_Audience_of_Quito Lat: -0.25 Lon: -78.58333587646484
País: http://dbpedia.org/resource/Ecuador Lat: -0.1500000059604645 Lon: -78.34999847412109
País: http://dbpedia.org/resource/Somalia Lat: 2.033333301544189 Lon: 45.34999847412109

Hasta aquí no existe complicación alguna, pero lamentablemente y no sé porqué algunas veces el programa no funciona y presenta una excepción 406 Not Acceptable Actualización 19/08/2010: el problema anterior se resolvió cambiando la línea: resource.accept(MediaType.APPLICATION_JSON).get(String.class) por resource.accept(«application/sparql-results+json»).get(String.class); . La única forma de que trabaje es copiando la URL a la barra de dirección del navegador y luego de un par de intentos funciona en el navegador y luego en el programa Java. Si alguno de ustedes me puede ayudar con alguna solución se los agradeceré mucho.

Espero que les ayude y les sirva como base para futuros trabajos.

Educación eqaula: Curso virtual «Java, programación orientada a objetos»

El curso virtual esta dirigido a profesionales y estudiantes que han decidido ser más, aprendiendo con expertos de forma práctica y sin interferir en su tiempo de estudios y trabajo.
Durante el curso se desarrolla un aplicativo que va creciendo en complejidad, conforme avanzamos en los contenidos; estos comprenden:
  • Fundamentos de modelado de objetos UML
  • Clases y objetos
  • Herencia y Polimorfismo
  • Agregación, Composición
  • Manejo de TAD’s (Collecciones)
  • Manejo de archivos
  • Manejo de base de datos (JDBC)
  • El curso exige compromiso y se aprueba previo el cumplimiento de las actividades y tareas programadas.
Requisitos:
  • Fundamentos del lenguaje Java y programación
Recibes:
  • Certificado de aprobación Eqaula
  • Tutoria virtual personalizada y aprendizaje colaborativo
Inversión
USD 200 + IVA (pregunta por el descuento para estudiantes universitarios).
Pregunta como matricularte ahora jlgranda@eqaula.org
Iniciamos el 05 de Agosto, para matriculas anteriores al 01 de Agosto, aplica 25% de descuento.

Problemas con Jena y Google App Engine

A los tiempos un post.

Ahora no presento soluciones sino un problema.

Estamos desarrollando un proyecto en el cual trabajamos con Jena (para hacer unas consultas a una ontología). La aplicación es Web y estamos trabajando con GWT 2 (como la han mejorado a la esta herramienta, al fin pude hacer debbug desde la Mac!) la GUI full Ajax y RPC sin problemas. Necesitamos subirla a un servidor público y se me ocurrió subirla al Google App Engine, desde un principio tuve dudas relacionadas sobre las restricciones que impone Google (número de archivos y clases restringidas) y las dudas se convirtieron en problemas.

El problema se da en el método hasNext() de la clase ResultSet para versión 2.5.7 del Jena al parecer deriva de algunas clases no permitidas. Cambié los .jar del Jena a la versión 2.6.2 y el problema se dio en el método create(String) de la clase QueryFactory.

He encontrado los siguientes links que mencionan el algo el problema:

Aquí se detallan los Frameworks y APIs  soportados parcial, total o definitivamente por Google App Engine

Mientras que en éste link se habla sobre un problema que se presenta.

Finalmente aquí se presenta una solución (aunque no estoy seguro que sea para mi problema) trataré de implementar lo que se recomienda.

Por ahora el problema está sin solución, si alguien ha logrado solucionar o tienes más detalles del problema y quiere compartir sus ideas o soluciones, les pido su ayuda.

Un cliente Jersey que consume Google AJAX search API – Rest & Java

Uno de los API’s, dentro del mundo Java, que permiten trabajar con servicios Web basados en REST se denomina Jersey. Este API viene incluido con NetBeans desde ya hace algunas versiones atrás. Inclusive en el sitio de NetBeans existe documentación en donde se muestra como crear un servicio Web Rest basado en una tabla de una base de datos. Pero no existe ninguna documentación, al menos en sitio de NetBeans, que muestre como crear un cliente Jersey que consuma algún servicio Rest.

Buscando en la Web encontré un par de ejemplos. Uno de ellos Consuming RESTful Web Services With the Jersey Client API, desarrolla un cliente (en modo consola) de Twitter.

Otro ejemplo bastante sencillo, pero no menos ilustrativo se llama Yahoo Search Restful Client using Jersey, aquí se desarrolla un cliente que consume el servicio de búsqueda de Yahoo. Dicho servicio de búsqueda devuelve los resultados en XML así que es necesario usar JAXB Binding para obtener las clases que representaran la información.

No he encontrado un ejemplo en donde se trabaje con JSON, tomando en cuenta que ese formato es bastante popular hoy por hoy. Así que me decidí a elaborar un cliente Jersey que consuma el API de Google AJAX search que devuelve información en JSON. El código desarrollado es el siguiente:

package ecc.edu.utpl;

import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;
import java.util.Scanner;
import javax.ws.rs.core.MediaType;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

/**
 *
 * @author jorgaf
 */
public class ClienteGoogle {

    public static void main(String[] args) {
        Scanner lector = new Scanner(System.in);
        String consulta;
        char opc = 'S';
        String URI = "http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=";
        Client cliente = Client.create();
        do {
            do {
                System.out.print("Ingrese el texto a buscar: ");
                consulta = lector.nextLine();
                consulta = consulta.trim();
                consulta = consulta.replace(" ", "%20");
            } while (consulta == null || consulta.length() == 0);

            URI += consulta;
            WebResource recurso = cliente.resource(URI);
            String result = recurso.accept(MediaType.APPLICATION_JSON).get(String.class);
            try {
                System.out.printf("---RESULTADOS:%s---\n", consulta);
                mostarResultados(result);
                System.out.printf("---%d páginas aprox.---\n",
                        obtenerTotalResultados(result));
            } catch (JSONException ex) {
                ex.printStackTrace();
            }
            System.out.println("\n-------------------------------");
            System.out.println("¿Desea realizar otra búsqueda?");
            System.out.print("Presione S(Si) o N(No): ");
            opc = lector.next().charAt(0);
            System.out.println();
        } while (opc != 'N');

    }

    public static void mostarResultados(String respuesta) throws JSONException {
        JSONObject objJSON = new JSONObject(respuesta);
        JSONObject responseData = objJSON.getJSONObject("responseData");
        JSONArray results = responseData.getJSONArray("results");
        for (int i = 0; i < results.length(); i++) {
            JSONObject link = results.getJSONObject(i);
            System.out.printf("URL: %s\n", link.getString("url"));
            System.out.printf("Title: %s\n", link.getString("title"));
            System.out.printf("Contenido: %s\n", link.getString("content"));
            System.out.println();
        }
    }

    public static long obtenerTotalResultados(String respuesta){
        long total = 0;
        try {
            JSONObject objJSON = new JSONObject(respuesta);
            JSONObject responseData = objJSON.getJSONObject("responseData");
            JSONObject cursor = responseData.getJSONObject("cursor");
            total = cursor.getLong("estimatedResultCount");
        } catch (JSONException ex) {
            ex.printStackTrace();
        }
        return total;
    }
}

Para poder realizar este cliente tuve que agregar las siguientes librerías adicionales:

Las tres primeras librerías se pueden descargar desde la Web haciendo clic en cada uno de los enlaces. Pero el último lo agregué desde NetBeans. La siguientes imágenes les guiarán en ese proceso.

Menu a utilizar para agregar la librería
Librería que debe agregar

Los métodos mostrarResultados y obtenerTotalResultados, son los encargados de trabajar con JSON. Para conocer la estructura JSON de la información devuelta por Google hagan clic aquí y busquen el tema «Entornos Flash y otros entornos que no utilizan JavaScript» que casi se encuentra al final.

Espero que este post les ayude.

Slideshow de Imágenes con JavaFX

En ésta ocasión Scott Hommel nos muestra en 6 pasos (un tutorial corto pero bueno) como crear una aplicación JavaFX que muestra un grupo de fotografías con transición automática y efectos entre transición, al estilo diapositivas. En realidad resulta bastante sencillo el ver cómo se realiza la aplicación con pocas líneas de código.

La herramienta que ha utilizado en éste caso es NetBeans, y a propósito de NetBeans ya está disponible para la descarga la versión 6.8 Beta y en el blog de Avbravo pueden encontrar una entrada NetBeans 6.8 Beta JavaFX Ubuntu 9.10 el nombre es por demás descriptivo de lo que encontrarán. Sería interesante hacer el slideshow con las herramientas del post de Avbravo.

Los 6 pasos que se muestran en el post Creating an Image Slideshow:

  1. Crear el proyecto Slideshow
  2. Crear el Stage y Scene
  3. Configurar el color de fondo
  4. Cargar y mostrar las imágenes
  5. Agregar una línea de tiempo
  6. Agregar la transición

El post de Hommel es interesante porque al final se muestran otros recursos relacionadas con cada una de las actividades realizadas para crear el post.

Espero que sea de su interés.

JavaFX by Examples

Una de las formas de aprender es revisando aplicaciones de ejemplo desarrolladas por otras personas, siempre y cuando las estudiemos, las entendamos y muchas veces tomando prestadas algunas características de las mismas.

Cuando los ejemplos se encuentran clasificados según el nivel de conocimiento o el tipo de contenido que presenta la tarea de aprender se convierte una experiencia bastante agradable y motivadora. Esto sucede con una serie de ejemplos que se encuentra en JFXtras Commnuty Site. Como mencionan en su sitio «El objetivo del proyecto JFXtras Samples es suministrar programas JavaFX de ejemplo de calidad, para aprendices y exploradores del lenguaje. Por favor siéntase libre de navegar por los ejemplos y reutilizar cualquier código en tus aplicaciones (todas las licencias son comercialmente amistosas) y contribuye con la comunidad con cualquier ejemplo adicional».

De lo que entiendo algunos ejemplos son obtenidos desde algunos libros, tales como: JavaFX in Action, Essential JavaFX, JavaFX Developer’s Guide, etc. El link directo hacia los ejemplos es el siguiente JFXtras Samples.

Espero que sea de su ayuda.

Combinando JavaFX y Swing

Como ya lo mencionó Charles Ditzel en su post What’s Wrong With JavaFX and What Needs Fixing? una de las falencias de JavaFX es la ausencia de ciertos controles (ejemplo: árboles y tablas), ésta debilidad se acrecienta cuando lo comparamos con Swing que cuenta con muchos más. (Para ver una lista de los componentes JavaFX visiten: Top 5 most Important Features in JavaFX 1.2).

Para cubrir de cierta forma ésta debilidad, es posible utilizar dentro de una aplicación JavaFX componentes Swing; también se lo puede hacer en sentido contrario, en una aplicación Swing usar JavaFX, pero a través del hacking lo que no garantiza que siga funcionando en versiones posteriores. Para conocer más visiten: How to use JavaFX in Your Swing aplicaciones. Ésta característica, la capacidad de JavaFX de soportar componentes Swing, ha sido explotada en el JavaOne en las conocidas sesiones «Extreme GUI Make Over», en donde se hace un cambio extremo a una aplicación Swing, ésta vez, para las mejoras se ha utilizado JavaFX dando como resultado una aplicación hibrida entre JavaFX y Swing.

Amy Fowler ha colaborado en el cambio extremo de GUI y ha elaborado un post resumen, en el cual muestra una lista de 10 + 1 pasos necesarios para incluir controles Swing dentro de una aplicación JavaFX. Los 10 pasos son los siguientes:

  • Tocar las bases del lenguaje
  • Descargar el SDK JavaFX
  • Crear un proyecto en NetBeans
  • Crear el «Stage»
  • Definir el layout
  • Embeber los componentes Swing
  • Enganchar los Listeners
  • Agregar efectos
  • Agregar movimiento
  • Hacer tus conclusiones

Para leer el post completamente lee el post: Insider’s Guide to Mixing Swing and JavaFX