lunes, 31 de enero de 2011

Visualiza tus tipografías en la Web

Wordmark, previsualiza las fuentes que tenemos instaladas y nos permite probarlas para ver como quedan. Tiene diferentes formas para visualizarlas. Negro sobre blanco o invertido, también se puede ajustar el tamaño. La única pega es que el tamaño o color aun no está implementado en está versión, su pongo que posterior mente lo implementaran.

JPanel con JScrollPane

En uno de mis proyectos he tenido el inconveniente de cargar datos en un jpanel (por lo visto algo muy fuera de lo normal, ya que no había solución clara) teniéndolo dentro de un jscrollpane no se llegaba a visualizarse mas que lo que abarcaba el tamaño del panel, vamos que el scroll no aparecía y por mas que refrescaba con getGraphics(); no había manera.
Descubrí por ahí el siguiente método de los JPanel setPreferredSize(); una bendición ya que es la solución a mis problemas. Aquí os dejo como quedaría el código:

JPanel panel = new JPanel();
JScrollPane scroll = new JScrollPane();
scroll .setBounds(132, 155, 502, 311);
scroll .setViewportView(panel);
scroll .getViewport().setView(panel);
panel.setLayout(null);
Creamos el jpanel creamos el jscrollpane definimos un tamaño al scroll y metemos en el scroll el panel. Por último el proceso de carga de datos usamos incluiremos:
panel.setPreferredSize(new Dimension(480,600);
Vamos variando los valores X, Y dependiendo de cuanto necesitamos para mostrar. El código de arriba variara ya que se supone el el jscrollpane estará en un jFrame, jDialog...

NOTA: parecerá una tontería pero buscar en internet a ver si hay algo referenciando a esta solución, por que a mí me a costado. Espero que para la próxima el siguiente que lo necesite lo encuentre antes de perder los nervios ;)

un saludo

domingo, 30 de enero de 2011

Manejar colecciones ordenadas TreeSet y TreeMap

Pequeña explicación sobre los árboles en Java. (encontrado en toolboxnet)
TreeSet
¿Que necesitamos?
Modificar la clase Producto (clase que vamos a almacenar) implementando Comparable. 
Está interfaz necesita sobrescribir el método compareTo indica que atributos se usaran para comparar.

import java.util.*; 
public class Producto implements Comparable { 

public String nombre; 
public int cantidad; 

public Producto(String s, int i) {
nombre = s;
cantidad = i;
} 

public String toString(){
return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public int compareTo( Object objeto ) {
// Indica en base a que atributos se compara el objeto
// Devuelve +1 si this es > que objeto
// Devuelve -1 si this es < que objeto
// Devuelve 0 si son iguales

Producto producto = (Producto)objeto;
String nombreObjeto = producto.nombre.toLowerCase();
String nombreThis = this.nombre.toLowerCase();

return( nombreThis.compareTo( nombreObjeto ) );
}
} 

TreeSet no permite elementos duplicados, mantiene la lista ordenada y el elemento a comparar debe contar con métodos equals, hashCode o compareTo. 

MercadoTreeSet.java 
import java.util.*; 
public class MercadoTreeSet 
{ 
public static void main(String args[])
{
// Definir 5 instancias de la Clase Producto 
Producto pan = new Producto("Pan", 6); 
Producto leche = new Producto("Leche", 2); 
Producto manzanas = new Producto("Manzanas", 5); 
Producto brocoli = new Producto("Brocoli", 2); 
Producto carne = new Producto("Carne", 2); 
Producto res = new Producto("Carne", 3); 

// Definir un TreeSet 
TreeSet lista = new TreeSet(); 
lista.add(pan); 
lista.add(leche); 
lista.add(manzanas); 
lista.add(brocoli); 
lista.add(carne); 
lista.add(res); 

// Imprimir contenido de TreeSet 
// Aunque se agregan 6 elementos, el TreeSet solo contiene 5 
// TreeSet no permite elementos duplicados, 
// TreeSet detecta que el elemento "Carne" esta duplicado 
// Notese que el orden del TreeSet refleja un orden ascendente 
mostrarLista(lista); 

// No es posible eliminar elementos por indice 
// Un TreeSet solo elimina por valor de Objeto 
lista.remove(manzanas); 
mostrarLista(lista); 

// Eliminar todos los valores del TreeSet 
lista.clear(); 
mostrarLista(lista);
}

public static void mostrarLista(Collection lista) {
System.out.println(" Lista del mercado con " + lista.size() +
" productos");
for( Iterator it = lista.iterator(); it.hasNext();) {
Producto producto = (Producto)it.next();
System.out.println(producto);
}
}
}


TreeMap
¿Que necesitamos?
Elementos están ordenados por la clave, se definen dos referencias de la interfaz SortedMap. En la primera se colocan las claves que se encuentran entre A y O. Método submap("A", "O") La segunda almacena las claves desde la P hacia el final. 
Estas comparaciones se han hecho con la clase String. Otras clases deberán definir sus propios métodos compareTo, equals o hashCode. 

AgendaTreeMap.java 
import java.util.*; 
public class AgendaTreeMap 
{ 
public static void main(String args[]) 
{ 
// Definir un TreeMap 
TreeMap agenda = new TreeMap(); 

// Agregar pares "clave"-"valor" al HashMap 
agenda.put("Doctor", "(+52)-4000-5000"); 
agenda.put("Casa", "(888)-4500-3400"); 
agenda.put("Hermano", "(575)-2042-3233"); 
agenda.put("Tio", "(421)-1010-0020"); 
agenda.put("Suegros", "(334)-6105-4334"); 
agenda.put("Oficina", "(304)-5205-8454"); 
agenda.put("Abogado", "(756)-1205-3454"); 
agenda.put("Papa", "(55)-9555-3270"); 
agenda.put("Tienda", "(874)-2400-8600"); 

// Notese que el orden del TreeMap refleja un orden ascendente 
// en sus elementos independientemente del orden de insercion. 
// Debido al uso de String se refleja un orden alfabetico 
mostrarMapa(agenda); 

// Definir dos TreeMap nuevos 
SortedMap agendaAO = agenda.subMap("A", "O"); 
SortedMap agendaPZ = agenda.tailMap("P"); 

System.out.println("---- Agenda A-O ----"); 
mostrarMapa(agendaAO); 

System.out.println("---- Agenda P-Z ----"); 
mostrarMapa(agendaPZ);
} 

public static void mostrarMapa(Map agenda) {
System.out.println(" Agenda con " + agenda.size() +
" telefonos");
for( Iterator it = agenda.keySet().iterator(); it.hasNext();) {
String clave = (String)it.next();
String valor = (String)agenda.get(clave);
System.out.println(clave + " : " + valor);
}
}
} 

Prefetch en HTML5

Prefetching permite descargar las URL indicadas antes de que se vayan a visitar… y el HTML 5 incluye un sistema para alisarlo, ya de forma estándar (hasta ahora sólo Firefox le daba soporte).

El sistema es tan sencillo como poner en el <head> algo como:
<link rel="prefetch" href="http://sitio.web/url-siguiente/">
o algo como:
<link rel="prefetch" href="http://sitio.web/imagen-siguiente.png">
Otra posibilidad es la de acelerar la carga pero en URL concretas que se vayan cargando dentro del sitio… de forma que cualquier enlace interno quedaría de la siguiente forma:
<a rel="prefetch" href="http://sitio.web/url-siguiente/">
Un saludo

sábado, 29 de enero de 2011

El Abecedario

geolocaliza con HTML 5


Aunque se asocia el lanzamiento de las funciones de geolocalización al HTML 5, lo cierto es que la Geolocation API son unas funciones en JavaScript independientes de esta forma de mostrar las páginas web.

Básicamente el navegador, dependiendo de la conexión a Internet, será capaz de saber qué latitud, longitud y otros datos tienes en ese momento. Os dejo con un par de ejemplos de código que, dependiendo del navegador, deberían funcionar.

El código más sencillo tiene una pinta tal que esta:

<script type="text/javascript">
     if (navigator.geolocation) {
          navigator.geolocation.getCurrentPosition(successFunction, errorFunction);
     } else {
          alert('Tu navegador no soporta la geolocalizacion.');
     }
     function successFunction(position) {
          var lat = position.coords.latitude;
          var long = position.coords.longitude;
          alert('Tu localizacion es -- latitud : '+lat+' longitud : '+long);
     }
     function errorFunction(position) {
          alert('No se ha podido recuperar la geolocalizacion.');
     }
</script>

Si queréis un ejemplo completo os paso el código HTML5 de una página  que te localiza y te lo posiciona en el Mapa
<!doctype html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="language" content="es">
    <title>Prueba de Geolocalizaci&oacute;n</title>
    <script src="http://maps.google.com/maps/api/js?sensor=false"></script>
    <style type="text/css">
        html, body {
            width: 100%;
            height: 100%;
    }
    #map_canvas {
            height: 85%;
            width: 100%;
    }
    </style>
</head>

<body>
    <div id="map_canvas"></div>
    <div id="locationinfo"></div>
    <script type="text/javascript">
    if (navigator.geolocation) {
    navigator.geolocation.getCurrentPosition(displayPosition, errorFunction);
    } else {
        alert('Tu navegador no soporta la geolocalizacon de HTML 5.');
    }
    function displayPosition(pos) {
        var mylat = pos.coords.latitude;
        var mylong = pos.coords.longitude;
        var thediv = document.getElementById('locationinfo');
        thediv.innerHTML = '<p>Tu localizacion es -- latitud : ' + mylong + ' longitud : ' + mylat + '</p>';
        var latlng = new google.maps.LatLng(mylat, mylong);
        var myOptions = {
            zoom: 15,
            center: latlng,
            mapTypeId: google.maps.MapTypeId.HYBRID
        };
        var map = new google.maps.Map(document.getElementById("map_canvas"), myOptions);
        var marker = new google.maps.Marker({
            position: latlng,
            map: map,
            title:"Aqui estas"
        });
    }
    function errorFunction(pos) {
        alert('o se ha podido recuperar la localizacion');
    }
    </script>
</body>
</html>

viernes, 28 de enero de 2011

Como mejorar la velocidad de una página

Google ya anunció que la velocidad de descarga es un parámetro o señal en el algoritmo del buscador, muchos SEOs recién ya tienen estrategias de usabilidad y velocidad en sus webs.

Os presento el vídeo de Maile de Google Webmaster nos presento hace un tiempo el vídeo con ideas y herramientas para analizar y mejorar la velocidad de descarga de tu web.

Después de que Google anunciaba que la velocidad de descarga es un paramento o señal en el algoritmo del buscador, muchos SEOs recien han comenzado a pensar en la usabilidad y la velocidad de sus páginas web.

Maile, de Google Webmaster nos presenta un vídeo con algunas ideas y herramientas para analizar y mejorar la velocidad de descarga de una página web




Articulo completo

jueves, 27 de enero de 2011

Automatizar la precarga de las imagenes

Filament Group presentó un código muy cómodo a la hora de cargar todas las imágenes de nuestras CSS. 

¿Que hace el código?
Se recorre todas las hojas CSS que esten vinculadas e importadas y crea una matriz con todas las URLs de imágenes. Posteriormente se recorre todo ese conjunto de direcciones y crea un objeto imagen para cada uno de ellos. De tal forma, que quedaran almacenados en la caché y preparados para su uso posterior.

¿Cómo se utiliza?
Simplemente tienes que tener la famosa librería de jQuery y preloadCssImages.jQuery_v5.js este último es el código creado por dicho grupo.
Teniendo eso solo tienes que llamar a $.preloadCssImages(); cuando el DOM este listo. De la siguiente manera:
$(document).ready(function(){
     $.preloadCssImages();
});

Esto comenzará a analizar todos los archivos CSS y comenzará la precarga de las imágenes.
Otra pequeña idea es poder conocer el estado de la precarga, así podríamos incluir una barra o algo parecido que indique al usuario el tiempo de carga de la página. Para ello podemos pasar una extensión que reciba el estado de está con tatusTextEl y statusBarEl. Un ejemplo:
$.preloadCssImages({statusTextEl: '#textStatus', statusBarEl: '#status'});
Un detalle a tener en cuenta sería que en las imágenes de fondo, aseguraos en colocar el atributo 'no-repeat'.

Por ultimo si queremos ejecutar este código mientras otros elementos se están ejecutando, modificar el valor simultaneousCacheLoading a 1 ya que por defecto está a 2. Esto te permite especificar el numero de imágenes simultaneas a descargar. Recordar que los navegadores tienen limite para ejecutar peticiones HTTP.

HTML5 estructura de las cabeceras

Como estructurar las cabeceras también hablaré, claro está de las etiquetas que ya existen, y si han cambiado o no con respecto a las versiones anteriores.

doctype
Para empezar cualquier página toca el doctype. La verdad es que históricamente este elemento nunca ha tenido un buen acompañamiento, ya que había que indicarle algunos parámetros y versiones que normalmente nunca se ajustaban a la realidad. Ahora, con el HTML 5 esto queda reducido a una única opción muy simple:
<!DOCTYPE HTML>
Y ya está… no hay que indicar si es HTML 4, XHTML, si es estricto, ni versión ni nada de nada… simple. Este elemento no hay que cerrarlo ni nada, simplemente será la primera línea de cada una de nuestras páginas.

html
El siguiente elemento que hay que revisar es el html. Este es el elemento que ha de mantener toda la página, y que tendrá dentro el resto de elementos.
<html> [...] </html>
head
El siguiente elemento es el del head. Este es el elemento que contiene meta-información de la página y es el primer elemento que debemos encontrar en la página.
<head> [...] </head>
Aunque en teoría no tiene porqué tener elementos dentro obligatoriamente, sí que es muy recomendable que siempre incluya el elemento title.

title
Para mi uno de los elementos más importante de cada una de las páginas de un sitio es el elemento title. Por un lado porque es un elemento único, es decir, sólo puede haber uno por página, y también, de cara a SEO, es muy importante que esté bien construido.

Este elemento sólo puede incorporar texto (es decir, no puede tener código HTML ni nada parecido). También se ve afectado por cualquiera de los elementos globales.

<title>Aquí va el título de la página</title>


base
Uno de los elementos que siempre me ha intrigado es precisamente el base. Mucha utilidad no acabo de verle, aunque si está y se ha mantenido por tantos años es por algo. La dirección a partir de la que se han de calcular el resto de enlaces relativos de la página.
<base href="http://www.example.com/news/index.html">
Al igual que el title, sólo puede haber uno por página, y también acepta los atributos globales además de dos más, que son el href y el target.


link
Uno de los elementos que puede dar mucho juego es el link, básicamente porque nos puede ofrecer elementos alternativos u otros recursos relacionados con esa misma página. El ejemplo más habitual es el autodiscover de los feeds o los ficheros CSS externos.
<link rel="alternate" href="/fr/html" hreflang="fr" type="text/html" title="French HTML">
Entre los elementos que puede incorporar está el href (que hace referencia a la dirección URL del otro elemento), el rel (que indica el tipo de relación hay un montón de posibilidades), el media (que indica el soporte donde se ha de mostrar esta dirección -hay varios soportes-), hreflang (que es el idioma de destino de la dirección alternativa), el type (que indica me MIME-type de la dirección final) y el sizes (que sólo se usa en caso de que la dirección sea un icono).

Otro elemento que se puede poner, en el caso de que sea un “stylesheet” (hoja de estilo) es disabled, que impediría acceder a través de sistemas externos (tipo JavaScript) a hacer cualquier cambio en los elementos de ese CSS. El title suele ser simplemente informativo, excepto en el caso de los CSS, donde el título define los distintos CSS alternativos.
meta
Quizá los meta necesiten un capítulo entero. Y es que históricamente la gente decide poner todos los que se encuentra en cualquier sitio web, aunque no son siempre válidos. Esta etiqueta ofrece información de elementos que puede leer la máquina y que no tiene porqué ser interesante para el usuario en sí mismo. Son meta-información que no encontramos en el resto de elementos del head.

Como en el resto de ocasiones, tienen los atributos globales y unos más que son: name (es el nombre del concepto a tratar), content (es el contenido que le damos a ese valor). También tenemos el http-equiv(que hace referencia a cabeceras HTTP) y el charset (que indica la codificación de caracteres del elemento).

Los valores habituales que puede tener un meta son:
  • application-name: se usa en el caso de que el contenido no sea una página web, por lo que, en general, no se usará.
  • author: es el nombre de la persona o empresa creadora del contenido.
  • description: sólo ha de haber uno por página y es una breve descripción de lo que encontraremos en ella; recomiendo que tenga entre 125 y 175 caracteres, que es lo que aparecerá en los resultados de los buscadores.
  • generator: es el programa que ha creado la página y que, personalmente, recomiendo no incluir.
  • keywords: una serie de conceptos separados por comas que indican qué tendría que encontrar un usuario en la página; personalmente recomiendo entre 4 y 6 conceptos.
A parte de estos, que son los que están definidos en el estándar, podríamos incluir meta-extensiones si encontramos alguna específica que cuadre con nuestro sitio. Algunos ejemplos pueden ser:
  • robots: es el que se utiliza para bloquear a los robots de búsqueda.
  • audience: una lista de palabras que definirían el tipo de personas que sí o no pueden ver los contenidos.
Como antes comentaba, está el http-equiv que hace referencia a algunas cabeceras…
  • content-language: define el idioma que tendrá la página en general.
  • content-type: es el tipo de contenido MIME que tendrá la página; habitualmente text/html.
  • default-style: establece cuál es la hoja de estilos CSS por defecto.
  • refresh: indica que esa página ha de refrescarse cada N segundos. Si se le indica después una URL se actualizará hacia esa dirección.
<meta http-equiv="refresh" content="20; URL=page4.html">
Además de estos, también se propone el PICS-Label que daría información para la protección de menores.
Para acabar, existe un meta especial (que antes se indicaba de una forma distinta y más compleja) que es la de la codificación de la página. Ahora existe el charset directamente que quedaría algo como:

<meta charset="utf-8">


style
Sin duda hoy en día es inconcebible el HTML sin los CSS u hojas de estilo. Y como tal es así, los CSS tienen su propio sistema de incorporarse al código HTML. He de reconocer que no recomiendo el uso del elemento style, ya que lo mejor es incluirlo de forma externa con un link y que de esa forma quede cacheado… pero es decisión de cada uno.

Este elemento tiene varias opciones a parte de las globales, que son type (habitualmente será “text/css”), media (como ya he comentado en el punto anterior) y scoped que es booleano y que si no se indica los estilos son para todo el documento, y si se indica sólo es aplicable al subárbol donde se encuentra. También se puede usar el disabled al igual que ya he explicado anteriormente, bloquea el acceso externo. Por defecto no hace falta poner el type ya que se da por hecho.

<style>
body { color: black; background: white; }
em { font-style: normal; color: red; }
</style>



script
Este es otro de los elementos que me ha sorprendido encontrar “incrustado” en el HTML 5. La verdad es que los script, y sobre todo el JavaScript siempre se había tratado como algo externo al HTML, pero en esta versión se podría decir que es básico que el JavaScript funcione como el CSS de una forma casi imprescindible.

Los script, al igual que los CSS, pueden encontrarse en el propio código o externo. Lo ideal es que la mayor parte de funciones se encuentren externalizadas, y que sólo el código que vaya cambiando se encuentre en el propio sitio.

De esta forma encontraremos la opción de cargar contenido externo simplemente indicando la dirección correspondiente mediante el atributo src (que indica una dirección URL):

<script src="game-engine.js"></script>

Además de este parámetro podemos encontrar unos cuantos más como el type que, si no se indica es el MIME-type “text/javascript”. De la misma forma que en otros elementos encontramos el charset que si no se indica es el general de la página.

A parte de estos, tenemos 2 atributos booleanos que son async y defer. Estos elementos sólo pueden aparecer siempre y cuando el src está presente. El elemento async indica que este proceso ha de ejecutarse de forma asíncrona, por lo que se cargará tan pronto como pueda, pero “sin prisas”… en el caso en el que se ponga este elemento, también ha de aparecer obligatoriamente el defer. En este caso, si sólo aparece el defer, el script se ejecutará una vez se haya parseado el resto de la página. En definitiva: si se pone defer, el script se ejecutará una vez se acabe de cargar la página, pero en serie, uno tras otro. En caso de estar el async, permitirá ejecutarlos en paralelo, varios a a la vez.

Como detalle a tener en cuenta, es que el language ya ha quedado en desuso, ya que el type marca el lenguaje de programación utilizado.

Y, además del script, tenemos el noscript. Este elemento tiene dos opciones, aunque se resumen en una: si el script anterior no se puede ejecutar, se ejecutará lo que se incluya en este bloque. Y es que los usuarios habitualmente tienen la posibilidad de desactivar lenguajes como JavaScript en su navegador por seguridad.

Y hasta aquí lo que corresponde a la cabecera de una página. Los cambios son bastante mínimos con respecto a las versiones anteriores, y hay que reconocer que el hecho de que en muchos casos se tome por defecto muchos de los parámetros hacen que se facilite mayoritariamente el uso.

miércoles, 26 de enero de 2011

Precargar elementos CSS, JS, JPG ...

Como utilizar la precarga de elementos en nuestra web. Este metodo se usa para ir cargando elementos de la web que todavia no se estan visualizando.
Por ejemplo en la página principal donde poner una bonita presentación antes de darle a ENTRAR podemos ir cargando en cache las CSS o JS u otras imágenes que utilizaremos pasado esa pequeña Introducción. Código:

window.onload = function () {
     var i = 0, max = 0, o = null,
     preload = [
          'http://example.com/imagen.png',
          'http://example.com/javascript.js',
          'http://example.com/estilos.css'
     ],
     isIE = navigator.appName.indexOf('Microsoft') === 0;
     for (i = 0, max = preload.length; i < max; i += 1) {
          if (isIE) {
               new Image().src = preload[i];
               continue;
          }
          o = document.createElement('object');
          o.data = preload[i];
          //o.width = 1;
          //o.height = 1;
          //o.style.visibility = "hidden";
          //o.type = "text/plain"; // IE
          o.width = 0;
          o.height = 0;
          document.body.appendChild(o);
     }
};

Cuidado con abusar en la carga de muchos elementos ya que ralentiza la web. Aunque en las páginas sucesivas puede aumentar considerablemente la velocidad.