html, body, div, span, applet, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, big, cite, code,
del, dfn, em, font, img, ins, kbd, q, s, samp,
small, strike, strong, sub, sup, tt, var,
b, u, i, center,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td {
margin: 0;
padding: 0;
border: 0;
outline: 0;
font-size: 100%;
vertical-align: baseline;
background: transparent;
}
body {
line-height: 1;
}
ol, ul {
list-style: none;
}
blockquote, q {
quotes: none;
}
blockquote:before, blockquote:after,
q:before, q:after {
content: '';
content: none;
}

/* remember to define focus styles! */
:focus {
outline: 0;
}

/* remember to highlight inserts somehow! */
ins {
text-decoration: none;
}
del {
text-decoration: line-through;
}

/* tables still need 'cellspacing="0"' in the markup */
table {
border-collapse: collapse;
border-spacing: 0;
}

Vía | http://www.webspeaks.in

Relacionados:

1. AJAX: Convertir HTML a objeto DOM
2. Slider con CSS3 puro y funcionalidad de Back Button
3. CSS: crear reflejos en navegadores con soporte WebKit

El código para crear un elemento iframe sería:

$('<iframe />');

También podemos crearlo con atributos:

$('<iframe id="myFrame" name="myFrame">');

Para terminar, podemos insertarlo en el DOM:

$('<iframe id="myFrame" name="myFrame">')
   .appendTo('body');

El contenido del iframe se fija a través de su atributo “source”:

$('<iframe />')
   .attr('src', 'http://www.google.com');

En los comentarios del mismo artículo, alguien sugiere, además, esta otra manera de hacerlo:

$('<iframe />', {
   name: 'myFrame',
   id:   'myFrame',
   ...
}).appendTo('body');

Personalmente, prefiero la segunda…

Vía | http://www.itrickz.co.cc

Relacionados:

1. AJAX + jQuery: elementos HTML dinámicos
2. Cómo realizar una petición AJAX usando jQuery
3. AJAX: Convertir HTML a objeto DOM

De manera que podemos utilizar el código:

$("#id").length

…

para determinar si existe algún elemento con el identificador “id” en el DOM.

Ejemplo de código:

if ($("#id").length) {
   $("#id").text("Hello!");
}

Vía | http://eisabainyo.net

Relacionados:

1. AJAX + jQuery: elementos HTML dinámicos
2. Cómo realizar una petición AJAX usando jQuery
3. Crear elementos DOM – HTML dinámicamente usando jQuery

Este es el código que necesitamos para hacer un GET:

$.get("profile.php", { username: "rob" },
   function(response){
      // put the HTML content of profile.php into a div with id = "profile_page"
      $("#profile_page").html(response);
   }
);

Este código realiza una petición de tipo “GET” al mismo servidor en que se encuentra la página cargada, con un único parámetro “uername”, y utiliza el HTML devuelto para construir el contenido de un elemento cuyo identificador es “profile_page”.

De la misma manera podemos hacer una petición “POST”:

$.post("login.php", { username: "rob", password: "secret" },
   function(response){
      if (response == "good"){
         alert("You have logged in successfully.");
      }else{
         alert("Invalid username/password");
      }
   }
);

En este caso, la respuesta será “good” si el login se ejecutó correctamente.

Vía | http://lovehateubuntu.blogspot.com

Relacionados:

1. AJAX + jQuery: elementos HTML dinámicos
2. Crear elementos DOM – HTML dinámicamente usando jQuery
3. AJAX: Convertir HTML a objeto DOM

El plugin se llama “live query“. Veamos un ejemplo sencillo.

Supongamos que partimos del siguiente código:

$(document).ready(function() {
   $(".content").hover(
      function() {
         $(this).stop().animate({paddingLeft: '+100px'}, 1000);
      }
     ,function() {
         $(this).stop().animate({paddingLeft: '10px'}, 1000);
      });
   });

Para aplicarlo a elementos añadidos dinámicamente tendríamos que ejecutar el código:

function callWheneverTheElementsAreLoaded() {
   $(".content").livequery(function() {
      $(this).hover(
         function() {
            $(this).stop().animate({paddingLeft: '+100px'}, 1000);
         }
        ,function() {
            $(this).stop().animate({paddingLeft: '10px'}, 1000);
         });
      },
      function() {
         // unbind the mouseover and mouseout events
         $(this)
            .unbind('mouseover')
            .unbind('mouseout');
      });
}

tras la adición de los mismos al HTML.

Nótese que la llamada a livequery admite dos parámetros:

1. función callback que queremos añadir a los elementos nuevos
2. función callback a ejecutar cuando los elementos sean eliminados

Nota: por supuesto, es necesario añadir la librería live query al html después de la librería jQuery:

<!doctype html>
<html>
<head>
<script type="text/javascript" src="scripts/jquery-1.4.2.min.js">
</script>
<script type="text/javascript" src="scripts/jquery.livequery-1.1.1/jquery.livequery.min.js">
</script>
etc...

personalizando para cada caso los paths y/o nombres de ficheros, etc.

Relacionados:

1. Cómo realizar una petición AJAX usando jQuery
2. Crear elementos DOM – HTML dinámicamente usando jQuery
3. AJAX: Convertir HTML a objeto DOM

<!doctype html>
<html>
   <head>
   </head>
   <body onload="init();">
      <script language="JavaScript">

/**
 * ilikeblues.com (C)
 */

var req = new XMLHttpRequest();

function loaded() {
      var text = req.responseText;

      var domObject = (new DOMParser()).parseFromString(text, "text/xml");
      /* do with DOM object whatever you want... */
      domObject.getElementsByTagName("loquesea");
      ...
}

function init() {
   var url = "http://loquesea.com";

   req.open("GET", url, true);

   req.onload = loaded;
   req.send(null);
}

      </script>
   </body>
</html>

Relacionados:

1. AJAX + jQuery: elementos HTML dinámicos
2. Crear elementos DOM – HTML dinámicamente usando jQuery
3. Cómo realizar una petición AJAX usando jQuery

El tema es que, es imprescindible configurar correctamente el servidor en que está colgada la aplicación para que, al cargarla en el iPhone, éste la “cachee” adecuadamente.

El “quid”: el fichero declarado como manifest debe ser interpretado por el servidor con el MIME type “text/cache-manifest”. En otro caso, por ejemplo “text/plain”, al intentar abrir la aplicación en ausencia de conexión, obtendremos un error.

Si el servidor es Apache (no conozco ninguno más, al fin y al cabo, soy desarrollador, no administrador) es relativamente sencillo. Necesitamos un fichero .htaccess en la misma carpeta en que se encuentre la aplicación, con el sigueinte contenido:

AddType text/cache-manifest .manifest

Por supuesto el fichero manifest deberá tener la extensión “.manifest”, en otro caso la directiva no sirve para nada.

Además, el servidor Apache debe estar correctamente configurado para que interprete nuestro fichero .htaccess.

Relacionados:

1. iPhone SDK: Registrar una clase como observador de un evento
2. Utilización de gprof/gcov para obtención de datos de cobertura (I)
3. Aplicación RCP en pantalla completa

try {
   if (!window.openDatabase) {
      alert('not supported');
   } else {
      var shortName = 'mydatabase';
      var version = '1.0';
      var displayName = 'My Important Database';
      var maxSize = 65536; // in bytes
      var mydb = openDatabase(shortName, version, displayName, maxSize);

      // You should have a database instance in mydb.
   }
} catch(e) {
   // Error handling code goes here.
   if (e == 2) {
      // Version number mismatch.
      alert("Invalid database version.");
   } else {
      alert("Unknown error "+e+".");
   }
   return;
}

alert("Database is: "+mydb);

Con esto, sin más que implementar las transacciones necesarias, podemos hacer persistente la información cargada durante la sesión para su uso posterior.

Estas bases de datos se pueden utilizar para la implementación de aplicaciones Offline mediante Safari.

Para eliminar estas bases de datos creadas por aplicaciones web, basta con ir a la sección “Safari” de los ajustes del iPhone.

Vía: Safari Client-Side Storage and Offline Applications Programming Guide

Relacionados:

1. Javascript: comprobar si navegador soporta WebKit
2. Utilización de gprof/gcov para obtención de datos de cobertura (I)
3. AsistenteJeVWeb v1.0 released

La clase que contiene este código:

1. Recibirá notificaciones de disparo del evento “dataChangeEvent”.
2. Debe implementar el método “onDataChagneEvent”.

Cuando algún otro objeto dispare el evento, las instancias de esta clase recibirán la notificación y ejecutarán el método especificado.

Relacionados:

1. Aplicación Offline para iPhone
2. C++: excepción en construtor o destructor

Si una función se ha declarado estática para restringir el acceso a la misma, para no incluirla en el API del módulo, ¿por qué “bypassear” la funcionalidad y acceder a ella?

En mi caso, la respuesta es sencilla: pruebas unitarias. ¿Cómo hacer pruebas unitarias de estas rutinas?

La respuesta es, creando punteros a estas rutinas, accesibles desde otros módulos. Y puesto que cualquier solución implica cambios en los módulos a probar, en el ejemplo a continuación trataré de ser lo menos “intrusivo” posible.

Supongamos el módulo stfunc.c:

#include <stdio.h>
static int funcprintf(const char* str) {
   return printf(str);
}

Para probar esta rutina, tenemos esta otra, en otro fichero diferente (main.c):

int main() {
   int a = funcprintf("Loquesea");
   return a;
}

Si intentamos compilar, obtenemos el error “undefined reference to `funcprintf’”.

Así pues, vamos a crear un puntero a esta rutina para permitir el acceso a la misma desde el módulo de prueba. Creamos un fichero llamado ptrdefs.h:

#ifndef _PTRDEFS_H
#define _PTRDEFS_H
int (*fpointer)(const char*) = &funcprintf;
#endif

Y modificamos los ficheros anteriores de esta manera:
Fichero stfunc.c:

#include <stdio.h>

static int funcprintf(const char* str) {
   return printf(str);
}

#ifdef UNIT_TESTING
#include
<ptrdefs.h>
#endif

Fichero main.c:

int main() {
   int a = fpointer("Loquesea");

   return a;
}

Con esto, basta añadir la opción -DUNIT_TESTING para tener acceso a la rutina.

Por tro lado, el fichero ptrdefs.h sólo estará disponible para los tests unitarios. Esto evita el acceso indeseado.

[Código completo del ejemplo: static.tgz]

Relacionados:

1. Expresiones regulares C
2. Utilización de gprof/gcov para obtención de datos de cobertura (I)
3. Utilización de gprof/gcov: cobertura de ramas (y II)

Supongamos el siguiente fichero de código main.c:

En este caso, el script de compilación y ejecución será compexec.sh:

Nótese como la herramienta gcov ha sido ejecutada con las opciones -b y -c. Según “man gcov”:

1. -b
   –branch-probabilities
   Write branch frequencies to the output file, and write branch summary info to the standard output. This option allows you to see how often each branch in your program was taken. Unconditional branches will not be shown, unless the -u option is given.
2. -c
   –branch-counts
   Write branch frequencies as the number of branches taken, rather than the percentage of branches taken.

Es decir, pedimos a la herramienta que devuelva información sobre ejecución de las “ramas lógicas”, dando como resultado el fichero main.c.gcov:

Aquí podemos ver información, aunque un tanto críptica, sobre la ejecución de dos bloques if-else. Como puede verse, cada uno de ellos presenta cuatro ramas, numeradas de “branch 0″ a “branch 3″. Veamos a continuación la explicación de estos datos:

Supongamos la condición:

if (a || b) {
   x;
} else {
   y;
}

Esta condición (o combinación de condiciones) da lugar a 4 ramas, que se corresponden con las posibles combinaciones de valores booleanos de las dos variables:

a b
—-
0 0
0 1
1 0
1 1

Podemos reescribir esta condición como:

if (a == false) {
   // Branch 0
   if (b == false) {
      // Branch 2
      y;
   } else {
      // Branch 3;
      x;
   }
} else {
   // Branch 1
   x;
}

Supongamos ahora la condición:

if (a && b) {
   x;
} else {
   y;
}

Como antes, esta condición (o combinación de condiciones) da lugar a 4 ramas, que se corresponden con las posibles combinaciones de valores booleanos de las dos variables:

a b
—-
1 1
1 0
0 1
0 0

Podemos reescribir esta condición como:

if (a == true) {
   // Branch 0
   if (b == true) {
      // Branch 2
      x;
   } else {
      // Branch 3;
      y;
   }
} else {
   // Branch 1
   y;
}

En cualquiera de los casos anteriores, la herramienta gcov (con las opciones -bc) nos devuelve el número de veces que cada una de las ramas nombradas más arriba ha sido ejecutada.

Si se omite la opción -c, los resultados son porcentajes, de manera que la suma de las ejecuciones de todas las ramas deberá ser el 100 %.

Además, se puede deducir que, en cualquiera de los casos:

1.- (nº de ejecuciones de rama 0) + (nº ejecuciones rama 1) = (nº ejecuciones
del if

2.- (nº ejec rama 2) + (nº ejec rama 3) = (nº ejec rama 1)

En conclusión, podemos deducir qué líneas de código y ramas lógicas han sido ejecutadas y añadir/modificar los test cases necesarios para alcanzar la cobertura deseada.

[Código completo y resultados.]

Relacionados:

1. Utilización de gprof/gcov para obtención de datos de cobertura (I)

Para empezar el código fuente, main.c:

A continuación, las instrucciones de compilación y ejecución, compexec.sh:

Como se puede apreciar, son tres las opciones añadidas al compilador/linkador para obtener los resultados esperados:

1. -pgEsto es lo que dice “man gcc” acerca de esta opción:

   “Generate extra code to write profile information suitable for the analysis program gprof. You must use this option when compiling the source files you want data about, and you must also use it when linking.”

   Es decir, prepara el ejecutable para generar información suscpetible de ser utilizada por gprof para obtener información de “profiling”. Tras la ejecución de la aplicación generada con esta opción, se crea el fichero gmon.out.

2. -ftest-coverage
3. -fprofile-arcsEstas dos opciones son las que indican al compilador que, durante la ejecución de la aplicación, debe generarse información de cobertura.

   [La salida "man gcc" para estas opciones es demasiado larga para incluirla aquí, pero puede verse en este enlace.]

   El ejecutable compilado/linkado con estas opciones genera los ficheros main.gcno y main.gcda, que contienen los datos utilizados por gcov para generar información “legible” de cobertura.

Así pues, una vez ejecutada la aplicación y obtenidos estos ficheros, basta con ejecutar el comando gcov:

$ gcov main.c

(tal como se ha incluido en el fichero compexec.sh) y como resultado se obtiene el fichero main.c.gcov:

El fichero de resultados muestra el número de veces que un statement ha sido ejecutado.

Las instrucciones marcadas con “#####” son aquellas no cubiertas por la ejecución de la aplicación.

[Código completo y resultados.]

Relacionados:

1. Utilización de gprof/gcov: cobertura de ramas (y II)
2. AspectJ aplicado sobre una librería jar
3. Aplicación Offline para iPhone