Botón de «Compartir en Facebook», «Compartir en Twitter» y «+1» de Google+

¿Deseas integrar un botón de «compartir en Facebook en tu página»? Es una opción muy útil para que tus lectores hagan publicidad de tu sitio en la popular red social. Y como por otra parte eso también es publicidad gratuita para ellos ya se han encargado de que la cosa sea facilita.

Antaño la cosa se hacía con un simple javascript, pero a día de hoy Facebook incluso te facilita la creación del botón con un formulario en su página de desarrolladores

Con Twitter, tres cuartos de lo mismo: un simple formulario y te genera botones para compartir, mencionar, like, etc en la popular red de microbloggin.

En cuanto a Google+, la cosa tampoco es compleja. En su API de Javascript no sólo te dan un formulario de creación sino que también te facilitan una explicación de todo el funcionamiento del botón.

En definitiva, cualquiera de las tres redes sociales más populares te facilita la vida a la hora de crear un botón de compartir que integrar en el código de tu página o blog.

Editores WYSIWYG para tu web

¿Necesitas un editor WYSIWYG para integrar en tu página web? ¿Quieres mandar e-mails con texto enriquecido? ¿Quieres que tus usuarios puedan generar código con texto formateado? Ok, pues estas son algunas de las mejores opciones libres a las que puedes recurrir:

  • TinyMCE: Usado por WordPress, Facebook, Oracle Beehive, IBM Web CMS, Joomla, Episerver… en fin, son nombres que deberían dar confianza al usuario. TinyMCE incluye una enorme variedad de opciones que tú puedes configurar y decidir cuales usar. Es fácil de integrar y tiene una amplia documentación.
  • NicEditDos motivos para plantearse el uso de NicEdit son su ligereza y su fácil integración (sólo requiere dos líneas de código y lo tendrás funcionando). No tiene tantas opciones como el anterior pero son suficientes para el uso habitual del usuario, lo que además hará que para este sea más fácil e intuitivo usarlo.
  • openWYSIWYG: Reconozco que no lo he probado, pero me han hablado de él. Por lo que me han comentado el proyecto está un poco abandonado, así que es posible tener problemas de compatibilidad con las últimas versiones de algunos navegadores.
  • CKEditor: A nivel de funcionalidades implementadas está en la misma liga que TinyMCE, y es el editor utilizado por Drupal. Muy potente y con gran cantidad de opciones. Cuando lo veas parecerá que estás ante el procesador de texto de una suite ofimática.
    CKEditor
    CKEditor

     

En fin, con estos cuatro más o menos ya vemos todo lo que hay en el mercado. ¿Y cómo los implementas? Pues mira la documentación de cada uno. ¿Y cómo recoges los datos? Tranquilo, al procesar el formulario te vendrá como el resultado de un textarea normal, al menos en PHP (las versiones para Java o ASP ya vendrán en su documentación explicadas, digo yo).

Convertir una respuesta xml en un objeto de PHP

Por defecto PHP, desde la versión 5.1.2, incorpora la extensión SimpleXML y la trae habilitada (en versiones anteriores es necesario usar –enable-simplexml para activar esta extensión en el momento de compilar). Dicha extensión incluye una serie de herramientas que nos permiten trabajar fácilmente con XML.

No es extraño que si tenemos que comunicarnos con un api externa esta nos devuelva una respuesta en XML, que es un formato universal que puede ser trabajado con casi cualquier lenguaje (otra posibilidad muy habitual es JSON). SimpleXML nos permite recoger esta respuesta, convertirla en un objeto y trabajar con el mismo sin mucha complicación.

En caso de querer recoger una respuesta de otra página, el método a usar sería simplexml_load_string():

$objetoxml = simplexml_load_string($respuestaApi);

Con esto ya tenemos un objeto fácil de recoger. Vamos a imaginar que el objeto que recibimos es tal que así:

<response>
   <requestid>A16</requestid>
   <requests>3</requests>
   <status>error</status>
   <error>
      <code>106</code>
      <message>Request expired</message>
   </error>
</response>

Una notificación de un error conectando con un servicio externo (de hecho, es una copia de un mensaje de error del api de Calameo). Ahora imaginemos que queremos recoger este mensaje de error y mostrárselo por pantalla al usuario. ¿Qué hacemos? Pues muy facilito:

//primero convertimos el xml a objeto
$objetoxml = simplexml_load_string($respuestaApi);

//luego comprobamos que sea un mensaje de error:
if (isset($objetoxml->error))
{
    //e imprimimos
    echo 'Error:'.$objetoxml->error->code.': '.$objetoxml->error->message;
}

Trabajar con el objeto SimpleXML es cosa fácil: Cuando quieres acceder a un elemento basta ir moviéndose como si accedieras a las propiedades o métodos de un objeto. Es decir abuelo->padre->hijo. ¿Que hay varios elementos con la misma etiqueta? Sin problema, las etiquestas se convierten en objetos iterables y accesibles, por lo que puedes recorrerlos recurriendo a los mecanismos básicos de iteración (bucle foreach, por ejemplo).

¿Y para acceder a los atributos? En el ejemplo del xml no hay, pero imaginemos que en lugar del anterior la cosa fuera así:

<response>
   <requestid>A16</requestid>
   <requests>3</requests>
   <status>error</status>
   <errors>
      <error>      
        <message code="106">Request expired</message>
      </error>
      <error>      
        <message code="401">File not found</message>
      </error>
   </error>
</response>

Ok, ahora tendrías que acceder a los atributos, y de paso podríamos ver un ejemplo de iteración. A los atributos se accede como si fuesen elementos de un array, usando como índice su nombre:


//primero convertimos el xml a objeto
$objetoxml = simplexml_load_string($respuestaApi);

//luego comprobamos que sea un mensaje de error:
if (isset($objetoxml->errors))
{
    foreach(objetoxml->errors->error as $error)
    {
        echo 'Error:'.$error['code'].': '.$error->message;
    }
}

Un par de notas más:

  • Para usar el texto de un elemento en una comparación o pasarlo a una función como string hay que forzar la conversión a cadena de texto haciendo un cast con (string)
  • Para acceder a un elemento cuyo nombre viole las convenciones para nombres de objeto de PHP hay que recurrir a encapsular el nombre del elemento dentro de un par de llaves y comillas simples.
  • En este caso hemos hablado de recoger una respuesta de un servicio externo, pero SimpleXML nos permite también recoger un xml desde un archivo con simplexml_load_file().

Y si necesitáis convertir el elemento en un array (en su momento me tocó) ya tratamos ese punto con anterioridad.

Procesar un formulario con PHPFox (operaciones CRUD)

En los últimos tiempos he estado trabajando con el CMS PHPFox para creación de redes sociales. He de decir que la documentación sobre el mismo es, en el mejor de los casos ambigua y en el peor insuficiente, teniendo que recurrir muchas veces al «voy a ver cómo está hecho aquí, y si se parece lo copio». Por cierto, si no sabes inglés date por jodido que la documentación está toda en la lengua de los inmortales bardos Poe, Shakespeare y Lemmy.

Podría empezar por lo básico, pero está más o menos bien explicado en su documentación (a la que sólo podrás acceder si tienes una cuenta de usuario… de pago, of course), donde te explican más o menos cómo crear tu primer módulo. Por desgracia, tras explicar lo más básico (lo más de lo más, porque esto no está explicado…) se quedan ahí, y no profundizan para acercarse al tema de la persistencia de datos ni a las operaciones CRUD (Create, Read, Update and Delete).

Para el acceso a la base de datos necesitarás al menos tres archivos, ya que PHPFox trabaja sobre la arquitectura MVC: un template (será la vista), un controller (controlador) y un service (el modelo).

Si habéis leído la documentación básica de phpfox ya sabréis en qué carpeta tenéis que meter cada archivo y cómo nombrarlo. Ahora os adjunto un ejemplo de como sería el código del template, seguido de su explicación:

<form method="post" action="{url link='phpfoxexperiment/form'}">
  <input type="number" name="val[orden]" id="orden" placeholder="orden"/>
  <br/>
  <input type="text" name="val[texto]" id="texto" placeholder="texto"/>
  <br/>
  <input type="submit" value="Add" class="button" name="val[add]" /> 
</form>

Por partes; en el action hemos usado esa variable porque así generará directamente un link a nuestra dirección seguido de ese directorio. En cuanto al nombre de los campos como «val[loquesea]» tiene también una explicación: se considera buena práctica no usar en PHPFox las variables de entorno $_GET y $_POST para recoger los datos de los formularios, en lugar de eso utilizamos el método getArray de la clase request, como verás en el ejemplo e abajo del php.

<?php 

class Phpfoxexperiment_Component_Block_Form extends Phpfox_Component 
{     
    public function process() 
    {         	
	if (($aVal = $this->request()->getArray('val'))) // getArray() nos permite recoger indistintamente valores $_GET y $_POST 
	{  
		  		 
		if(isset($aVal['add']) && !empty($aVal['add'])) // miramos si se ha pulsado el botón enviar 
		{  
		    if(isset($aVal['orden']) && !preg_match("/^[[:digit:]]+$/", $aVal['orden'])) //esto es una validación de los datos por expresión regular
		    {
			$this->url()->send('phpfoxexperiment.basic', null, 'Error'); //en caso de que los datos no sean correctos avisa a una página de error
		    }
		    else{
			if (Phpfox::getService('phpfoxexperiment')->add($aVal)) // llamamos al servicio para guardar los datos
			{ 				 
			    $this->url()->send('phpfoxexperiment.basic', null, 'Added with success');	//en caso de éxito lo comunicamos			 
			}else{
     			     $this->url()->send('phpfoxexperiment.basic', null, 'Error'); //en caso de error también
			}
		    }
		  }
		}         		 
	} 
}
?>

Como ves en el ejemplo se invoca al método add del servicio phpfoxexperiment. Ese método es el que hará la inserción en la base de datos. No se trata de un método del sistema, sino de uno creado por mi dentro del servicio. Aquí el código del mismo

<?php 
  
class Phpfoxexperiment_Service_Phpfoxexperiment extends Phpfox_Service  
{ 
    public function getData($iUser)
	
    { 
        return $this->database()->select('e.aescrypt') 
            ->from(Phpfox::getT('experiment'), 'e')
	    ->where('e.orden < 60 and user = '.$iUser)             
            ->execute('getRows'); 
    }
	public function add($aVal){ 
     
        $this->database()->insert( 
          Phpfox::getT('experiment'), 
          array(
            'user'=>Phpfox::getUserId(),
            'orden'=>$aVal['orden'], 
            'aescrypt'=>$aVal['texto'] 			
          ) 
        ); 
	return true;

    } 
} 
  
?>

En cambos casos accedo a la base de datos (MySQL) a través de los métodos de la clase database() de phpfox, que teóricamente ya implementa seguridad contra inyección sql y otros posbiles ataques. El return del final servirá para confirmar que la transacción se ha realizado. En el primer ejemplo se recuperar unos datos (teniendo en cuenta el id del usuario) y en el siguiente se insertan.

En fin, una explicación muy básica, pero que os ayudará a ir empezando a desarrollar módulos para este CMS.

FancyBox: Una alternativa a lightbox y otra opción para ventanas modales.

Seguimos con el mundo de los plugins de jQuery, el productivo framework libre de javascript que, con pocas líneas, te permite mejorar la experiencia del usuario, poner la página bonita y quedar como un Master del Universo delante de tu jefe.

Previamente en este blog hablamos de cómo hacer ventanas modales de forma sencilla con jQueryUI y de cómo trabajar con el plugin Lightbox. ¿Y si te dijera que hay un plugin que incorpora ambas funcionalidades? Sí, un plugin que te permite crear ventanas modales, mostrar galerías de fotos flotando sobre la web original, cargar iFrames (con todo lo que ello te puede proporcionar: vídeos de youtube, metacafe, vimeo, juegos o funcionalidades en flash…). Yo lo he utilizado para una ventana modal y para un flash. Podéis ver varias demos en esta página y descargarlo desde esta.

Como supongo que estáis deseando una explicación, allá voy: Lo primero, tras descargar es copiar en vuestro servidor el archivo .js (para entornos de producción mejor la versión «pack», que está comprimida, para experimentar usad la versión normal con el código legible), las imágenes, el .css (ojo, importante, si las imágenes y el .css no van a estar guardadas en la misma carpeta revisad las url de las mismas en el css, porque este viene pensado para que estén así) e incluirlos en la cabecera de la página donde queréis cargarlas. Para su correcto funcionamiento requiere que incluyáis una versión de jQuery superior a la 1.6, así que echad un ojo que todavía hay mucha gente funcionando por ahí con versiones viejas.

Una vez incluída la librería veamos dos ejemplos. Si quisiéramos usarlo para ampliar una imágen tipo facebook (como haría el lightbox) el código sería tal que así:
HTML:

<a class="ejemplo" href="../image/foto1.jpg" title="EjemploImagen"><img src="../image/foto1thumb.jpg"  /></a>

Explicación rápida: creamos un link, le damos una clase (que en el javascript utilizaremos para acceder al mismo, también podría usarse un id, pero suponiendo un caso real lo habitual son clases porque suele trabajarse con varias imágenes) y hacemos que la referencia apunte a la imagen que queremos cargar. Luego, para mostrar en el menú de la página, cargamos una versión minimizada de la imagen.

<script type="text/javascript">  
  $(document).ready(function(){  
      $(".ejemplo").fancybox({ });  
  });  
</script>  

Y sólo con esa línea de javascript ya tienes el efecto logrado.

Ahora imaginemos que queremos abrir una ventana modal con un aviso (por ejemplo, unas condiciones de uso, que es lo que tuve que hacer yo). La cosa empezaría con un HTML tal que así:

<!-- Aquí el link a la ventana modal -->
<a class="ejemplo" href="#inline1" title="Lorem ipsum dolor sit amet">Inline</a>
<!-- Aquí lo que queremos que se muestre en la ventana modal -->
<div id="inline1" style="display: none;">
   <h3>Etiam quis mi eu elit</h3>
   <p>
   Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam quis mi eu elit tempor facilisis id et neque. Nulla sit amet sem sapien. Vestibulum imperdiet porta ante ac ornare. Nulla et lorem eu nibh adipiscing ultricies nec at lacus. Cras laoreet ultricies sem, at blandit mi eleifend aliquam. Nunc enim ipsum, vehicula non pretium varius, cursus ac tortor. Vivamus fringilla congue laoreet. Quisque ultrices sodales orci, quis rhoncus justo auctor in. Phasellus dui eros, bibendum eu feugiat ornare, faucibus eu mi. Nunc aliquet tempus sem, id aliquam diam varius ac. Maecenas nisl nunc, molestie vitae eleifend vel, iaculis sed magna. Aenean tempus lacus vitae orci posuere porttitor eget non felis. Donec lectus elit, aliquam nec eleifend sit amet, vestibulum sed nunc.
   </p>
</div>

Y con un javascript tal que

$(document).ready(function(){			
	$(".ejemplo").fancybox({
		maxWidth	: 400,
		maxHeight	: 300,
		fitToView	: false,
		width		: '70%',
		height		: '70%',
		autoSize	: false,
		closeClick	: true,
		openEffect	: 'none',
		closeEffect	: 'none'
	});		
})

En este caso definimos varios efectos. Las opciones son múltiples y variadas, por lo que si quieres sacar el 100% del jugo de este plugin lo que te recomiendo es que le pegues un ojo a la documentación del proyecto en su página oficinal.

Diseño responsivo con media queries de CSS3

Siguiendo con los artículos de Web Designer wall, continuamos con el tema de las media queries de CSS3, en este caso con otra traducción/explicación de uno de sus artículos.

En este artículo comienza repitiendo lo que ya hablamos en la otra entrada sobre media queries, que el diseño responsivo a día de hoy cobra mayor imortancia por la variedad de resoluciones que pueden usar los usuarios, y que por tanto el aspecto tiene que adaptarse a la ventana. El ejemplo del resultado que se busca conseguir es este.

El conceto, como diría Manquiña (el conceto es el conceto), es el siguiente: La página tiene un contenedor de tamaño fijo (980px) optimizado par una resolución mayor de 1024 px. La media query se utiliza para saber si el tamaño es menor de 980px, en cuyo caso se pasa a un diseño fluido. Y si el caso es que es menor de 650px entonces, directamente se convierte en un diseño con una sola columna.

El marcado HTML es el siguiente, donde se ha creado un contenedor pagewrapper que envuelve cabecera, cuerpo y pie:

<div id="pagewrap">

	<header id="header">

		<hgroup>
			<h1 id="site-logo">Demo</h1>
			<h2 id="site-description">Site Description</h2>
		</hgroup>

		<nav>
			<ul id="main-nav">
				<li><a href="#">Home</a></li>
			</ul>
		</nav>

		<form id="searchform">
			<input type="search">
		</form>

	</header>
	
	<div id="content">

		<article class="post">
			blog post
		</article>

	</div>
	
	<aside id="sidebar">

		<section class="widget">
			 widget
		</section>
						
	</aside>

	<footer id="footer">
		footer
	</footer>
	
</div>

Como hemos comentado miles de veces, el marcado HTML5 no se lleva bien con las veriones de IE anteriores al 9, pero puedes solucionarlo introduciendo esta línea en la cabecera, que enlazan con una librería de javascript que subsanará el problema:

<!--[if lt IE 9]>
	<script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->

Tras esto toca comenzar con el css, y lo primero es resetar todos los elementos de HTML5 a elementos de bloque:

article, aside, details, figcaption, figure, footer, header, hgroup, menu, nav, section { 
    display: block;
}

Y tras esto toca la estructura principal del css. El contenedor principal ha sido fijado en 980px, el header tiene una altura fija de 160px, el contente un ancho de 600px flotado a la izquierda y el sidebar, flotado a la derecha, de 280px.:

#pagewrap {
	width: 980px;
	margin: 0 auto;
}

#header {
	height: 160px;
}

#content {
	width: 600px;
	float: left;
}

#sidebar {
	width: 280px;
	float: right;
}

#footer {
	clear: both;
}

Todo esto, así de momento, daría lugar a un diseño estático tal que el de esta demo. Ahora toca la parte divertida: CSS3 Media Queries. Como el HTML5, CSS3 tampoco es que furrule muy bien en IE pre-9, así que de nuevo habrá que tirar de una librería de .js para solventar el problema.

<!--[if lt IE 9]>
	<script src="http://css3-mediaqueries-js.googlecode.com/svn/trunk/css3-mediaqueries.js"></script>
<![endif]-->

La idea es hacer un css externo con las media queries, introduciéndolo en el documento tal que así

<link href="media-queries.css" rel="stylesheet" type="text/css">

Luego vendrán las siguientes líneas para cuando la ventana donde visualicemos sea menor de 980px se aplicarán las siguientes reglas:

  • El contenedor principal se resetea al 95%
  • El contenedor de contenido pasa al 60%
  • El contenedor lateral pasa al 30%

El usar el % hace los contenidos fluídos:

@media screen and (max-width: 980px) {

	#pagewrap {
		width: 95%;
	}

	#content {
		width: 60%;
		padding: 3% 4%;
	}

	#sidebar {
		width: 30%;
	}
	#sidebar .widget {
		padding: 8% 7%;
		margin-bottom: 10px;
	}

}

Luego tocará hacer el media query para tamaños menores de 650px, con una única columna:

  • header = resetear la altura a auto
  • searchform = lo mandamos a una posición absoluta, a 5px del borde superior
  • main-nav = se reseta su posición a estatic
  • site-logo = lo mismo
  • site-description = lo mismo también
  • content = devolvemos el ancho a auto
  • sidebar = ponemos el ancho al 100% y quitamos la propiedad de flotado
@media screen and (max-width: 650px) {

	#header {
		height: auto;
	}

	#searchform {
		position: absolute;
		top: 5px;
		right: 0;
	}

	#main-nav {
		position: static;
	}

	#site-logo {
		margin: 15px 100px 5px 0;
		position: static;
	}

	#site-description {
		margin: 0 0 15px;
		position: static;
	}

	#content {
		width: auto;
		float: none;
		margin: 20px 0;
	}

	#sidebar {
		width: 100%;
		float: none;
		margin: 0;
	}

}

Finalmente tenemos la versión para menos de 480px, pensada para el iPhone. Implica evitar el zoom que automáticamente hace Safari sobre el texto y toquetear el menú de navegación principal:

@media screen and (max-width: 480px) {

	html {
		-webkit-text-size-adjust: none;
	}

	#main-nav a {
		font-size: 90%;
		padding: 10px 8px;
	}

}

Ahora toca el truquito para imágenes flexibles, con un pequeño hack para que funcione en IE8 (el width: auto\9; de la línea final):

img {
	max-width: 100%;
	height: auto;
	width: auto\9; /* ie8 */
}

Con los vídeos va igual, menos para Safari, dode max-width no va con vídeos (con fotos sí, extraño). Finalmente, y siguiendo con el iPhone de los huevos, toca metar una meta-tag de escala inicial, ya que el iPhone tiende a modificar las páginas para adaptarlas a la pantalla del dispositivo:

<meta name="viewport" content="width=device-width; initial-scale=1.0">

Y con esto está el tutorial terminado, en el artículo citado podrás encontrar además todo el código y las imágenes de la página de ejemplo. Un placer el haberos traducido esto, y todavía me queda al menos una tercera entrada sobre diseño responsivo. Esta semana creo que la cosa va a andar chunga para conectarme mucho rato, así que igual tarda hasta el viernes o sábado. O igual lo puedo hacer mañana, a saber. En todo caso, un saludo.

CSS3 Media Queries

La verdad es que no hace mucho Web designer Wall me ha salvado el culo en el tema del diseño responsivo (hacer que una web se adapte al tamaño de la ventana). Tras mucho tiempo rompiéndome la cabeza, tirando de jQuery y Javascript con pirulas cosa mala para lograr modificar el tamaño del texto, las posiciones de las imágenes… un coñazo y además ineficiente y poco compatible entre navegadores (menos mal que para móviles jQueryMobile me safaba muchas veces), pues tras mucho tiempo, como te iba diciendo, me encuentro este artículo, que ya tiene un par de años y me quedo como «coño, así es más fácil«. La siguiente explicación es una medio traducción/adaptación/explicación del tema, ya que se que en muchos casos lo que buscáis en este blog es una explicación en castellano de algo que ya hay en inglés. Espero que os sirva de ayuda.

Bueno, empezando desde un principio ¿por qué es importante el diseño responsivo? Porque los tiempos en los que el usuario visualizaba webs en su ordenador, con un rango de pantallas que solía oscilar entre las 14 y las 20 pulgadas en el 90% de los casos, ya pasó, es una reliquia de la década pasada, como MySpace, las PDA’s o que en la liga de fútbol española pueda ganar algo un equipo que no sea Madrid o Barcelona. Ahora te puedes encontrar desde el que usa una tele con una definición de 2560px al que lo ve en su teléfono móvil con una de 320px. Los tamaños fijos son un coñazo, y el usar porcentajes para todo… no siempre funciona, porque el tamaño de la fuente o las imágenes no se adaptan, y a veces hay que usar posicionamientos absolutos y te da la risa. CSS2 permitía diferenciar entre una hoja de estilos para la impresión y otra para la presentación en pantalla. CSS3 nos permite ir más allá, nos permite conocer el tamaño de la ventana/pantalla del dispositivo y aplicar un estilo diferente para cada pantalla. Voy a aprovecharme del artículo antes citado y enlazarte aquí con un ejemplo donde verás cómo funciona esto.

Visto esto, aquí tienes la explicación del cómo se hace, sacada del mismo artículo:

Max Width
En este caso el css se aplicará si trabajamos con una resolución de un máximo de 600 pixeles:

@media screen and (max-width: 600px) {
  .class {
    background: #ccc;
  }
}

Si quieres enlazarlo a una archivo CSS distinto, puedes hacerlo poniendo esta línea en la cabecera del documento:

<link rel="stylesheet" media="screen and (max-width: 600px)" href="small.css" />

Min Width
Al contrario que en el ejemplo de arriba, en este caso se especificará un tamaño mínimo para utilizar este estilo (en este caso, se aplicará a toda las resoluciones mayores de 900px).

@media screen and (min-width: 900px) {
  .class {
    background: #666;
  }
}

Media Queries múltiples
Tienes también la opción de utilizar dos valores a la vez, máximo y mínimo, para que el estilo se aplique a los comprendidos entre esos valores. En este caso, entre 600 y 900 px.

@media screen and (min-width: 600px) and (max-width: 900px) {
  .class {
    background: #333;
  }
}

Max device
Finalmente está la opción de adaptarlo a la máxima resolución del dispositivo. Los ejemplos anteriores hacen referencia al tamaño de la ventana/area de visualización, mientras que este se referiría a la resolución máxima que pueda mostrar el teléfono/ordenador/tableta en cuestión.

@media screen and (max-device-width: 480px) {
  .class {
    background: #000;
  }
}

En el artículo original arriba referenciado podéis encontrar también código para adaptarlo específicamente para iPad y iPhone4. No tiene mucha ciencia, podréis ver los ejemplos de código pinchando allí, además hay páginas de ejemplo al final.

Lo interesante está en uno de los puntos finales, donde comentan que, como siempre, va a haber problemas con Explorer. Bueno, no hay que ser 100% injusto con Microsoft, en principio Explorer 9 va bien, pero en las versiones anteriores la cosa ya no va por ningún lado. Dan varias soluciones, pero yo recomiendo la del plugin de jQuery para hacer furrular las media queries, que está en este ejemplo. Hay varios artículos más sobre diseño responsivo en esta página, así que intentaré próximamente meter un par de estas medio traducciones.

Creando un menú de navegación con jQueryMobile

Crear un menú de navegación con jQueryMobile, adaptando la web para una mayor usabiliad en dispositivos móviles, no es complicado.

El primer paso consiste en declarar el atributo data-role del div como navbar. Dentro de este metemos una lista desordenada (ul) y en cada elemento (li) de la misma añadimos un enlace, apuntando a la página a la que tiene que ir. A los enlaces no hay que definirles data-role.

Para cambiar el color de los botones usaremos el atributo data-theme (en el ejemplo data-theme=b para ponerlos de color azul), si no lo hacemos serán del mismo color que la cabecera. Una de las ventajas de jQueryMobile es que definiendo la clase ui-btn-active se un estilo más claro al botón seleccionado, sin que tengamos que currarnos un CSS para ello.

Recuerda también definir el data-icon para que el botón quede más bonito.

<header data-role="header"> 
    <h1>SJV Town Hall</h1>
    <div data-role="navbar">
        <ul>
             <li>
                 <a href="#inicio" class="ui-btn-active" data-icon="home" data-theme="b">Inicio</a>
             </li>

             <li>
                 <a href="#favourites" data-icon="star" data-theme="b">Favoritos</a>
             </li>

             <li>
                 <a href="#contactos data-icon="grid" data-theme="b">Contactos</a>
             </li>
         </ul>
       </div>
</header>

En el ejemplo puedes ver un poco de todo lo que hemos comentado arriba.

URI schemes en HTML 5

Al hablar de URI schemes hablamos de recursos que invocan aplicaciones ya instaladas en un dispositivo móvil y que nos permiten volcar ciertas funcionalidades en ellas, haciendo así más natural y fluída la navegación para el usuario. Aquí vamos a ver el uso de dos de las más básicas: hacer uso del sistema de SMS del teléfono y llamar a un número de teléfono.

  • SMS: Permite enviar rápidamente un mensaje de texto, indicando en el enlace un número e incluso el cuerpo del mensaje. Recuerda que debes poner el código del país antes del ńúmero, por aquello de la internacionalización. El marcado html sería:
    <a href="sms:666777888">Cuerpo del mensaje</a>
    
  • Teléfono: En este caso el enlace nos permitirá hacer una llamada a un número. Como en el anterior acuérdate del código del país antes del número. El marcado sería:
    <a href="tel:666777888">666777888</a>

Esto son ejemplos muy básicos, pero hay gran variedad de opciones: schemes para Facebook, Twitter, Pinterest… Existen múltiples schemes ya creados para iPhone, Android o HTML5 que podéis buscar en la web.

En fin, espero que os sirva de ayuda a los que como yo os estéis iniciando en la programación para dispositivos móviles

Ejemplos varios de canvas (html5)

Canvas es, probablemente, el elemento más potente de HTML5. Mayormente nos da una funcionalidad similar a las animaciones flash en una parte de la pantalla, pero utilizando javascript. En principio es para un contexto 2D pero ya hay una librería (three.js) que te permite utilizar gráficos 3D (de momento no soportada por todos los navegadores). En los primeros manuales de HTML5 que cayeron en mis manos este elemento venía muy mal explicado, te decían que se podía «dibujar» usando javascript… y ale, vía.

Para utilizar canvas en tu web debes incluir una etiqueta canvas, que por defecto será invisible y tendrá un tamaño de 300*150 px. Luego, en javascript, debes inicializar un contexto tal que así:

var ctx = document.querySelector('canvas').getContext('2d');

Tras haber definido un contexto bidimensional, podemos empezar a dibujar. El API da la posibilidad de utilizar rectángulos, arcos, círculos… El siguiente código dibujaría un rectángulo, con un reborde más oscuro:

ctx.fillStyle='rgb(0, 255, 0)';
ctx.fillRect(10,20,50,50);
ctx.strokeStyle='rgb(0,182,0)'
ctx.lineWidth=5;
ctx.strokeRect(9,19,52,52);

En fin, esto es lo más básico, pero tienes múltiples opciones: degradados, imágenes complejas, animaciones, interactividad… En lugar de currarme un tutorial más complejo te remito a varios enlaces para que veas la pontencia de Canvas:

Bueno, con estos ejemplos ya puedes ver más o menos la potencia de este elemento y tener varios tutoriales para iniciarte en la creación de aplicaciones con canvas.