NSArray, NSDictionary, NSString, NSNumber, NSData y otros

Hay dos métodos sencillos para almacenar un objeto en un archivo y poder recuperarlo cuando nos convenga. El primero no se puede aplicar a cualquier objeto, sino a objetos de algunas clases de Objective-C que responden a dos métodos llamados writeToFile:atomically: y writeToURL:atomically:. El uso de estos métodos es muy sencillo, basta con llamarlos en el momento en el que queramos que el objeto se guarde en un archivo.

A continuación teneís un ejemplo comentado. Básicamente creamos una matriz, le añadimos algo de contenido, la imprimimos, la guardamos en un archivo y nos deshacemos de ella. A continuación creamos otra matriz que lea el contenido del archivo y comprobamos que tiene el mismo contenido que la anterior. El resultado que obtendréis será similar al de la imagen de la derecha.

NSMutableArray *array = [[NSMutableArray alloc] init]; // Creamos una matriz
	[array addObject:@"¡Hola"]; // Añadimos un objeto
	[array addObject:@"mundo!"]; // Añadimos otro objeto
	NSLog(@"Matriz original: %@", array); // Imprimimos la matriz original
	[array writeToFile:@"filename" atomically:YES]; // Escribimos en el archivo filename el contenido de la matriz
	[array release]; // Liberamos memoria

	NSMutableArray *arrayFromFile = [[NSMutableArray alloc] initWithContentsOfFile:@"filename"]; // Esta matriz tiene el mismo contenido que tenía la matriz anterior
	NSLog(@"%@", arrayFromFile); // Imprimimos la matriz recuperada del archivo
	[arrayFromFile release]; // Liberamos memoria

Del mismo modo que se puede guardar en un archivo un objeto de la clase NSArray, también se puede usar con objetos NSDictionary, NSString, NSData y NSNumber, entre otros. Sin embargo no se puede usar con objetos de una clase creada por nosotros (en la mayoría de los casos).

Clases creadas por nosotros

Para guardar en un archivo un objeto de una clase creada por nosotros, tendremos que hacer que el objeto sigua el protocolo NSCoding. Tras esto, mediante las clases NSKeyedArchiver y NSKeyedUnarchiver podremos guardar en un archivo y leer de un archivo nuestro objeto. Este protocolo tiene dos métodos necesarios: initWithCoder: y encodeWithCoder:.

Vamos a suponer que hemos creado la clase Empleado, que tiene la siguiente interfaz:

@interface Empleado : NSObject

@property (nonatomic, retain)	NSString	*nombre, *apellidos;
@property						NSUInteger	edad;
@property						BOOL		esEmpleadoDelMes;

@end

Para poder almacenar este objeto en un archivo tendremos primero que hacer que siga el protocolo NSCoding. Modficaremos la interfaz y la dejaremos así:

#define kNombre				@"Nombre"
#define kApellidos			@"Apellidos"
#define kEdad				@"Edad"
#define kEsEmpleadoDelMes	@"esEmpleadoDelMes"

@interface Empleado : NSObject

@property (nonatomic, retain)	NSString	*nombre, *apellidos;
@property						NSUInteger	edad;
@property						BOOL		esEmpleadoDelMes;

@end

Básicamente hay dos cambios: hemos indicado que la clase sigue el protocolo NSCoding y hemos definido una serie de constantes que usaremos más adelante y que entenderéis en seguida su utilidad.

Ahora pasamos a la implementación. Esta es la implementación original de la clase Empleado, antes de seguir el protocolo NSCoding:

@implementation Empleado

@synthesize nombre, apellidos;
@synthesize edad;
@synthesize esEmpleadoDelMes;

- (void)dealloc
{
	[nombre release];
	[apellidos release];

	[super dealloc];
}

@end

Ahora vamos a añadir los dos métodos que necesitamos para seguir el protocolo NSCoding. Estos métodos nos permiten archivar nuestro objeto. El método encodeWithCoder: tiene por parámetro un objeto de la clase NSCoder. En este objeto archivaremos las propiedades del nuestro, asignándole a una serie de claves las propiedades del objeto.

Por ejemplo, si queremos hacer que la propiedad nombre se archive en la clave clave, el método tendría el siguiente aspecto:

- (void)encodeWithCoder:(NSCoder *)coder {

    [coder encodeObject:self.nombre forKey:@"clave"];

}

No todas las propiedades se archivan de la misma forma. Los objeto se archivan a través del método encodeObject:forKey:, los números enteros se archivan con encodeInteger:forKey: y los valores booleanos con encodeBool:forKey:. Las claves son muy importantes, ya que el método initWithCoder: va a desarchivar el objeto usando las mismas claves para acceder a las propiedades, por eso hemos definido una serie de constantes que serán las claves que usaremos para archivar y desarchivar las propiedades.

Nota: Tenéis una lista de todos los métodos para archivar objetos, así como una explicación del proceso de archivar y desarchivar objetos en la documentación de Apple (en inglés).

Nuestro método encodeWithCoder: quedará así:

- (void)encodeWithCoder:(NSCoder *)coder {

    [coder encodeObject:self.nombre forKey:kNombre];
	[coder encodeObject:self.apellidos forKey:kApellidos];
	[coder encodeInteger:self.edad forKey:kEdad];
	[coder encodeBool:self.esEmpleadoDelMes forKey:kEsEmpleadoDelMes];

}

El método initWithCoder: es muy similar al anterior, sólo que su funcionamiento es el contrario: a partir de un objeto archivado se obtienen las propiedades y se crea un objeto de la clase Empleado (en este caso) con las propiedades que tenía el objeto al archivarse. En este caso enviaremos el mensaje decodeObjectForKey:@”clave” a coder y asignaremos el valor devuelto a la propiedad de nuestro objeto. De nuevo, se usan métodos diferentes para decodificar número enteros, valores booleanos y otros tipos de variables. Nuestro método initWithCoder: quedará así:

- (id)initWithCoder:(NSCoder *)coder {

    if ((self = [super init])) {

		self.nombre = [coder decodeObjectForKey:kNombre];
		self.apellidos = [coder decodeObjectForKey:kApellidos];
		self.edad = [coder decodeIntForKey:kEdad];
		self.esEmpleadoDelMes = [coder decodeBoolForKey:kEsEmpleadoDelMes];

	}

    return self;
}

Ahora pasemos a crear un objeto Empleado, a guardarlo en un archivo y a comprobar que funciona correctamente. Primero incluímos la interfaz de la clase Empleado en el archivo en el que vamos a crear el objeto, en mi caso, y al tratarse de una “Command Line Tool“, lo incluiré en el archivo main.m. El siguiente código comentado crea un objeto de la clase Empleado, le asigna algunos valores sus propiedades, lo archiva y después crea un nuevo objeto con el contenido del archivo en el que se ha guardado antes el objeto:

Empleado *trabajador = [[Empleado alloc] init]; // Creamos el objeto
	trabajador.nombre = @"Juan"; // Le damos un nombre
	trabajador.apellidos = @"García López"; // Unos apellidos
	trabajador.edad = 26; // Una edad
	trabajador.esEmpleadoDelMes = YES; // Y lo hacemos empleado del mes

	NSLog(@"%@ %@ tiene %lu años", trabajador.nombre, trabajador.apellidos, trabajador.edad); // Imprimimos sus datos

	[NSKeyedArchiver archiveRootObject:trabajador toFile:@"empleado"]; // Lo guardamos en el archivo empleado

	[trabajador release]; // Liberamos memoria

	Empleado *trabajadorRecuperado = [NSKeyedUnarchiver unarchiveObjectWithFile:@"empleado"]; // Creamos un objeto a partir del archivo empleado

	NSLog(@"%@ %@ tiene %lu años", trabajadorRecuperado.nombre, trabajadorRecuperado.apellidos, trabajadorRecuperado.edad); // Imprimimos sus datos

Así se puede guardar un objeto de cualquier clase en un archivo, de forma que puede ser recuperado en cualquier momento. Los objetos más complejos pueden necesitar métodos más complejos a la hora de archivarlos. Del mismo modo no se tienen por qué archivar todas las propiedades si no se quiere.

Por último dejo a vuestra disposición los archivos del proyecto que he creado mientras escribía el tutorial, por si os atascáis y necesitáis un empujoncito.

Hay cerca de 800MB de archivos "borrados" en este pendrive

Hay veces que uno se sorprende al ver ciertos comportamientos de Mac OS X. Uno de los que menos me gustan es la forma de borrar archivos de un dispositivo extraíble (por ejemplo, un pendrive). En lugar de borrar el archivo, como sería de esperar, o moverlo a la papelera del Mac, lo almacena en una carpeta oculta dentro del propio pendrive que usa a modo de papelera. Si nos fijamos en la papelera de nuestro Mac, veremos que los archivos que hemos borrado del pendrive aparecen en ella, aunque no estén almacenados en el Mac.

El problema radica en que además de no borrar realmente los archivos y dejarlos en el pendrive (ocupando parte de su preciada capacidad), no hay forma de borrar los archivos individualmente de la papelera. Si usamos la combinación Función + Retroceso lo que hacemos es devolver el archivo eliminado a su carpeta de origen en lugar de borrarlo. Estamos pues obligados a vaciar la papelera y borrar definitivamente otros archivos que tal vez no queramos perder todavía.

Así que, algo mosqueado porque esto no haya cambiado ni en Snow Leopard ni en Lion (ni tiene pinta de que vaya a cambiar), he creado una simple aplicación en Automator para “limpiar” los pendrives de archivos supuestamente eliminados.

Cómo funciona

Esto lo aclara todo

Antes de dar los enlaces para descargar la aplicación, veamos cómo funciona. Como ya he dicho, Mac OS X mueve los archivos “borrados” a una carpeta oculta que funciona a modo de papelera. Esta carpeta se llama .Trashes (como de costumbre en OS X, al llevar un punto al principio del nombre, la carpeta es oculta). Si borramos la carpeta .Trashes, borramos todos los archivos que queríamos eliminar pero, ¿cómo la borramos sin pasar por la papelera de nuevo?

Aquí es donde entra en juego el potencial de un sistema basado en Unix. Gracias al comando rm (remove) podemos eliminar archivos o carpetas sin necesidad de pasar por la papelera. Combinando esto con un par de parámetros, concretamente -R (borrar de forma recursiva) -f (sin pedir confirmación) y -d (directorios y archivos) conseguimos vaciar el pendrive de archivos que queríamos borrar.

Obviamente tener que escribir todo esto en la terminal cada vez que queremos limpiar un pendrive de archivos “borrados” no es muy cómodo. Para hacer más cómoda la tarea recurriremos a Automator, ese pobre incomprendido que si bien es capaz de hacer maravillas, la mayoría de los usuarios desconoce incluso su existencia.

Para crear la aplicación abrimos Automator y elegimos crear una aplicación. A continuación arrastramos las acciones para formar el flujo que podéis ver en la imagen de la derecha. Básicamente el flujo es el siguiente:

1. Solicitamos una carpeta. El usuario deberá seleccionar un dispositivo extraíble.
2. Establecemos el valor de una variable con la ruta de la carpeta seleccionada.
3. Leemos el valor de esta variable y se lo pasamos a un script Shell como parámetro (este paso y el anterior supongo que se pueden omitir y usar el resultado del paso 1 como argumentos para el paso 4, pero por pereza no lo he comprobado – si alguien se anima que lo comente en los comentarios).
4. En el script Shell usamos el comando cd (change dir) para ir a la ruta del pendrive.
5. A continuación, en el mismo Shell y cambiada la ruta a la que nos interesa, borramos la carpeta .Trashes con los parámetros que he expuesto antes.

Descarga

Seguidos los pasos y entendido el funcionamiento, aquí tenéis a vuestra disposición la aplicación.

Google Reader antes de activar el nuevo estilo

Google Reader no destaca precisamente por tener el diseño más bonito del mundo. De hecho no ha recibido ningún rediseño desde hace bastante tiempo, a diferencia de otros servicios de como Calendar o Gmail. Si sois de los que utilizáis Google Reader directamente desde su web, sin recurrir a ninguna aplicación que se sincronice con él, agradeceréis este artículo.

Lo que veis en la imagen de arriba es Google Reader tras activar algo de CSS a través de Stylish. Si no tenéis instalado Stylish, podéis hacerlo en Firefox o Google Chrome (en otros navegadores, como Opera o Safari, hay formas diferentes de aplicar los estilos CSS).

Si ya tenéis instalado Stylish, ahora tendréis que instalar los estilos. Al ser un archivo demasiado grande, el autor (Mestiso) no ha podido insertarlo directamente en userstyles.org, pero comparte el código en su página web. Para instalarlo (a través de Stylish) primero accederemos a userstyles.org y haremos clic en el botón Install with Stylish, a continuación editaremos el estilo y reemplazaremos todo el código por el que nos ofrece su autor en su página web. Para ello, en Firefox, mostraremos el panel lateral de Stylish (Ver » Panel lateral » Stylish) y haremos doble clic sobre el estilo Google Reader – 3 Column Reader. Una vez reemplazado el código haremos clic en Guardar y cuando accedamos de nuevo a Google Reader, veremos un diseño mucho más limpio y elegante.

El único inconveniente es que algunas características dejan de ser accesibles, como los patrones. Sin embargo esta función sigue estando activa. Para poder acceder a ella simplemente desactivaremos temporalmente el nuevo estilo (siguiendo los mismos pasos que antes, sólo que en lugar de hacer doble clic en Google Reader – 3 Column Reader lo haremos sobre el icono con una S que aparece a la izquierda del nombre, que tras el doble clic perderá el color, indicando que el estilo está desactivado).

Estilo: userstyles.org
Estilo: kamilb.info
Stylish: Firefox | Google Chrome

En primero lugar hay que entender cómo funciona el Widget. Toma del objeto $bbp la matriz views, la recorre y genera una lista de vistas disponibles. Por defecto esta matriz sólo tiene una vista: la lista de temas sin respuesta, pero podemos añadir todas las que queramos. La estructura de la matriz views es la siguiente:

Array
(
    [no-replies] => Array
        (
            [title] => Topics with no replies
            [query] => Array
                (
                    [meta_key] => _bbp_reply_count
                    [meta_value] => 1
                    [meta_compare] => <
                    [orderby] =>
                    [show_stickies] =>
                )

            [feed] => 1
        )

    [IDENTIFICADOR] => Array
        (
            [title] =>Título
            [query] => Array
                ( /* Matriz con los parámetros de la consulta a realizar en dicha vista, equivale a query_vars en WP_Query */
                )

            [feed] => 1 /* Supongo que será si se quiere mostrar o no esta vista en el RSS Feed, pero no lo he comprobado, así que no sé realmente qué es lo que hace */
        )

)

Interesante, ¿verdad? Pues bien, jugando un poco con esta matriz no sólo podemos crear enlaces que lleven a páginas que muestren sólo determinados temas, sino que podemos hacer que redirijan a cualquier lugar.

function bbpress_add_rss_to_view_list()
	{
		global $bbp;

		$nombre_de_la_vista = 'sumolari_bbpress_rss_feed'; // Utilizo este nombre por si en un futuro añaden a bbPress una vista llamada rss_feed o algo similar

		$bbp->views[$nombre_de_la_vista] = array(
			'title' => __('RSS Feed', 'bbpress'),
			'query' => array(),
			'feed' => 1
		);

		if (bbp_get_view_id() == $nombre_de_la_vista)
		{
			header('Location: '.home_url().'/feed/?post_type='.$bbp->topic_post_type);
			exit;
		}

	}

	add_action('get_header', 'bbpress_add_rss_to_view_list');

¿Qué hace este código? En primer lugar obtiene el objeto $bbp. A continuación definimos un identificador para nuestra nueva vista. Después añadimos a la matriz views un nuevo índice con nuestro identificador y como valor una matriz que tiene por valor del title, “RSS Feed“, por valor del índice query una matriz vacía y por valor del índice feed el número 1. Tras esto verificamos que no nos encontramos en nuestra vista, ya que si así fuera, tendríamos que redirigir la página hacia el RSS Feed de los temas del foro. Por último añadimos esta nueva función a las acciones que se ejecutarán al obtener la cabecera del theme.

¿Cómo generamos el RSS Feed? WordPress lo hace de forma automática, y al ser los foros de bbPress 2.0 artículos de WordPress con post_type personalizados, basta con cargar el RSS Feed indicando el tipo de artículos que queremos ver, a través del parámetro de URL post_type.

Obviamente esta es sólo una de las cosas que se pueden hacer modificando la lista de vistas. El único límite es nuestra imaginación.

Esta tarde me he tomado la molestia de crear yo uno y quiero compartirlo con todo aquel al que le parezca interesante. Básicamente se copia el siguiente código en el archivo functions.php de nuestro theme de WordPress o en un archivo .php en la carpeta de plugins de WordPress.

class bbPress_Widget_Tag_Cloud extends WP_Widget {

		function bbPress_Widget_Tag_Cloud() {
			$widget_ops = array( 'description' => __( "Your most used tags in cloud format") );
			$this->WP_Widget('bbpress_tag_cloud', __('bbPress Tag Cloud'), $widget_ops);
		}

		function widget( $args, $instance ) {
			extract($args);
			$current_taxonomy = $this->_get_current_taxonomy($instance);
			if ( !empty($instance['title']) ) {
				$title = $instance['title'];
			} else {
				if ( 'post_tag' == $current_taxonomy ) {
					$title = __('Tags');
				} else {
					$tax = get_taxonomy($current_taxonomy);
					$title = $tax->labels->name;
				}
			}
			$title = apply_filters('widget_title', $title, $instance, $this->id_base);

			echo $before_widget;
			if ( $title )
				echo $before_title . $title . $after_title;
			echo '
<div class="tagcloud">';
			wp_tag_cloud( apply_filters('widget_tag_cloud_args', array('taxonomy' => $current_taxonomy) ) );
			echo "</div>
\n";
			echo $after_widget;
		}

		function update( $new_instance, $old_instance ) {
			$instance['title'] = strip_tags(stripslashes($new_instance['title']));
			$instance['taxonomy'] = stripslashes($new_instance['taxonomy']);
			return $instance;
		}

		function form( $instance ) {

			global $bbp;

			$current_taxonomy = $this->_get_current_taxonomy($instance);
	?>

<label for="<?php echo $this->get_field_id('title'); ?>"><!--?php _e('Title:') ?--></label>
		<input id="<?php echo $this->get_field_id('title'); ?>" class="widefat" name="<?php echo $this->get_field_name('title'); ?>" type="text" value="<?php if (isset ( $instance['title'])) {echo esc_attr( $instance['title'] );} ?>" />

<label for="<?php echo $this->get_field_id('taxonomy'); ?>"><!--?php _e('Taxonomy:') ?--></label>
<select id="<?php echo $this->get_field_id('taxonomy'); ?>" class="widefat" name="<?php echo $this->get_field_name('taxonomy'); ?>">		<!--?php foreach ( get_object_taxonomies($bbp--->forum_post_type) as $taxonomy ) :					$tax = get_taxonomy($taxonomy);					if ( !$tax->show_tagcloud || empty($tax->labels->name) )						continue;		?>			<option value="<?php echo esc_attr($taxonomy) ?>">><!--?php echo $tax--->labels->name; ?></option>		<!--?php endforeach; ?-->		<!--?php foreach ( get_object_taxonomies($bbp--->topic_post_type) as $taxonomy ) :					$tax = get_taxonomy($taxonomy);					if ( !$tax->show_tagcloud || empty($tax->labels->name) )						continue;		?>			<option value="<?php echo esc_attr($taxonomy) ?>">><!--?php echo $tax--->labels->name; ?></option>		<!--?php endforeach; ?-->		<!--?php foreach ( get_object_taxonomies($bbp--->reply_post_type) as $taxonomy ) :					$tax = get_taxonomy($taxonomy);					if ( !$tax->show_tagcloud || empty($tax->labels->name) )						continue;		?>			<option value="<?php echo esc_attr($taxonomy) ?>">><!--?php echo $tax--->labels->name; ?></option>		<!--?php endforeach; ?--></select>
<!--?php<br /-->		}

		function _get_current_taxonomy($instance) {
			if ( !empty($instance['taxonomy']) && taxonomy_exists($instance['taxonomy']) )
				return $instance['taxonomy'];

			return 'post_tag';
		}
	}

register_widget('bbPress_Widget_Tag_Cloud');

¿Cómo funciona? Pues lo que he hecho ha sido copiar el código del Widget de nube de etiquetas que viene por defecto en WordPress (sobre la línea 986 del archivo wp-includes/default-widgets.php) y modificarlo para que en la lista de posibles taxonomías a mostrar muestre todas las taxonomías que pertenezcan a alguno de los post_type que añade bbPress 2.0.

Lamentablemente hay un pequeño problema en esto y es que aparecerán también las etiquetas que se aplican a temas publicados en foros privados, comprometiendo la privacidad de dichos foros. La solución me ha costado bastante más de encontrar, pero la tenéis a continuación. Se trata básicamente de aplicar un filtro al Widget, que añade a la lista de etiquetas a excluir cualquier etiqueta que haya sido asignada a un tema de un foro privado. De nuevo, se puede añadir en el archivo functions.php de nuestro theme o en un archivo aparte en wp-content/plugins.

function parchear_bug_tag_cloud($content)
	{

		global $bbp;

		$private_forums = bbp_get_private_forum_ids();

		if (bbp_user_can_view_forum(array('forum_id' => $private_forums[1])))
		{
			return $content;
		}

		$tags_to_remove = array();
		foreach ($private_forums as $pf_id => $pf_forum)
		{

			if ($pf_forum == '') { continue; }

			$temp_query = new WP_Query(array('suppress_filters' => true, 'post_type' => $bbp->topic_post_type, 'meta_query' => array(array('key' => '_bbp_forum_id', 'value' => $pf_forum, 'compare' => '='))));

			while ( $temp_query->have_posts() ) : $temp_query->the_post();

				$tags = wp_get_object_terms(get_the_ID(), $bbp->topic_tag_id);

				foreach ($tags as $t_key => $t_value)
				{
					$tags_to_remove[] = $t_value->term_id;
				}

			endwhile;

			wp_reset_postdata();

		}

		$content['exclude'] = $tags_to_remove;

		return $content;
	}

	add_filter('widget_tag_cloud_args', 'parchear_bug_tag_cloud');

¿Cómo funciona? Primero se obtienen los foros privados y se comprueba que el usuario no puede verlos. A continuación se recorren todos los temas de todos los foros privados (sí, se que no está demasiado optimizado, pero no he encontrado una forma mejor de hacerlo) y se añaden todas sus etiquetas a la lista de etiquetas a excluir. Por último se devuelven los nuevos parámetros del Widget.

La lástima es que hay un segundo bug, y es que si un usuario accede a la URL de una etiqueta que está asignada a un tema publicado en un foro privado, el usuario puede ver la lista de temas que tienen asignada dicha etiqueta, y entre esos temas, aparecerá también el tema que debería estar oculto al ser publicado en un foro privado.

De nuevo para solucionar esto podemos recurrir a los filtros de bbPress y WordPress, en concreto arreglar el error se logra con el siguiente código:

function parchear_bug_foros_privados($content)
	{
		global $bbp;

		$private_forums = bbp_get_private_forum_ids();

		if (bbp_user_can_view_forum(array('forum_id' => $private_forums[1])))
		{
			return $bbp->topic_query->post_count;
		}

		$topics_to_remove = array();
		foreach ($bbp->topic_query->posts as $key => $post)
		{
			if (in_array(get_post_meta($post->ID, '_bbp_forum_id', true), $private_forums))
			{
				$topics_to_remove[] = $key;
			}
		}

		foreach ($topics_to_remove as $key => $topic_to_remove)
		{
			unset($bbp->topic_query->posts[$topic_to_remove]);
		}

		$bbp->topic_query->post_count = count($bbp->topic_query->posts);

		$bbp->topic_query->post = reset($bbp->topic_query->posts);

		return $bbp->topic_query->post_count;

	}

	add_filter('bbp_has_topics', 'parchear_bug_foros_privados');

Esto tiene un efecto secundario: a partir del momento de aplicar estos dos parches, cualquier tema que tenga asignada una etiqueta que esté a su vez asignada a un tema publicado en un foro privado, será invisible para los usuarios que no tengan permiso para ver dicho foro, es decir, se volverá tan privado como los temas publicados en un foro privado. Este efecto desaparece al eliminar el código de ambos parches, sin embargo si no usamos estas funciones, queda a la vista de cualquier usuario (incluso los no registrados) la lista de temas privados.

Sencillo y limpio, pues si queremos eliminar este parche o el Widget basta con borrar el código anterior. Además, en caso de que este error no se arreglara en futuras versiones, el parche y el Widget seguirán disponibles tras actualizar bbPress, manteniendo la sencillez característica de WordPress.

De todos modos, espero que en la versión final de bbPress 2.0 se incluya un Widget que reemplace al mío, y que los fallos sean arreglados.

bbPress no se caracteriza por ser uno de los sistemas de foros más completos, de hecho no es posible utilizar etiquetas tan comunes en otros foros como la de coloreado de código o la posibilidad de añadir un vídeo con tan sólo usar la etiqueta [youtube]. Sin embargo, al ser un plugin de WordPress, podemos extender las características de bbPress aprovechándonos de las de WordPress. ¿De qué estoy hablando? De aplicar los mismos filtros que aplica WordPress al contenido de los artículos a los mensajes del foro, haciendo que cada característica que añadamos a WordPress a través de plugins también esté disponible al instante en el foro.

Aplicar estos cambios es muy sencillo. Podemos crear un nuevo plugin o modificar el archivo functions.php de nuestro theme de WordPress. En primer lugar definiremos una función que devuelva el contenido que se le pasa como parámetro tras aplicarle los filtros que aplica WordPress. A continuación añadiremos esta función a los filtros que aplica bbPress al contenido de los mensajes. Aquí va el código en cuestión.

function aplicar_filtros($content)
{

	global $bbp;

	$author_id = $bbp->reply_query->posts[$bbp->reply_query->current_post]->post_author;
	$author_info = get_userdata($author_id);

	if ($author_info->wp_capabilities['administrator'] == 1)
	{
		return apply_filters('the_content', $content);
	}

	return apply_filters('comment_text', $content);
}

add_filter('bbp_get_reply_content', 'aplicar_filtros');

¿Cómo funciona esta función? En primer lugar obtenemos la variable $bbp, que contiene, entre otras cosas, la información relativa al mensaje que estamos mostrando. A continuación obtenemos la ID del usuario que ha publicado el mensaje, y con ésta, la información del usuario. Tras esto comprobamos que el autor del artículo tiene permisos de administrador. Si es así, el usuario puede utilizar cualquier filtro aplicado a los artículos del blog (es decir, cualquier filtro añadido a the_content); si por el contrario el autor no es un administrador, le dejaremos usar cualquier filtro que se pueda usar en los comentarios (es decir, que se añade a comment_text).

Por último añadimos la nueva función al filtro bbp_get_reply_content y ¡voilà! Ya tenemos nuevas características soportadas en nuestro foro. Ahora si queremos, por ejemplo, permitir el coloreado de código, basta con instalar un plugin como SyntaxHighlighter Evolved y activarlo desde el Panel de Administración de WordPress. También podremos usar otras características de WordPress, como embeber vídeos usando los shortcodes [video] o [youtube].

Del mismo modo, por ejemplo, se podrían añadir carruseles creados con WP Carousel 1.0 con utilizar el shortcode [wp_carousel].

Por medidas de seguridad, tan sólo los administradores gozarán de todos los filtros, ya que es posible que algún plugin añada un filtro a the_content que no queremos que los demás usuarios puedan usar públicamente, como por ejemplo añadir formularios de contacto o mostrar carruseles.

• Objeto: Los objetos son el pilar fundamental en la POO. Los objetos contienen variables, responden a métodos, tienen una dirección de memoria en la que están almacenados, pertenecen a una clase y pueden implementar protocolos.
• Clases: Un objeto pertecen a una clase, y sólo a una. Por el contrario varios objetos pueden pertenecer a la misma clase. En otros lenguajes de programación los objetos pueden heredar de varias clases, pero en Objective-C no. Cuando un objeto pertecene a una clase, el objeto contiene todas las variables de la clase, y responde a todos los métodos de instancia a los que responde la clase (veremos qué es esto más adelante). A su vez, una clase puede heredar de otra clase (de hecho lo más común es que las clases que creemos hereden de NSObject, al menos a nuestro nivel), cuando esto sucede, la nueva clase responde a todos los métodos a los que respondía la clase “padre” y los objetos de esta clase también tienen las variables de instancia de la clase “padre”.
• Variables de instancia: Los objetos, a pesar de ser por sí mismos variables, pueden contener a otras variables, que pueden ser variables simples como las de C (por ejemplo, números enteros o de coma flotantes) u objetos de cualquier clase. Las variables de instancia son diferentes en cada objeto, por lo que si tenemos dos objetos de la clase rueda y accedemos a la variable presiónDeLaRueda, cada uno devolverá un valor diferente de presión.
• Métodos de instancia: Los métodos de instancia son las funciones que puede ejecutar el objeto de una clase determinada. Cada clase define unos métodos de instancia diferente. Por ejemplo, la clase coche podría tener un método que fuese encenderMotor, al que se accedería desde un objeto determinado.
• Métodos de clase: Los métodos de clase son funciones a las que sólo se puede acceder desde la propia clase. Un método de clase típico es alloc, al que sólo se puede acceder desde una case, nunca desde un objeto.

Puede que no os hayan quedado claros del todo los conceptos con esta introducción, los explicaré mejor un poco más adelante.

Creando una nueva clase

Creando una nueva clase - Paso 2

En Objective-C las clases se definen mediante dos archivos: NOMBRECLASE.h y NOMBRECLASE.m. Los archivos .h contienen la interfaz de la clase y los archivos .m su implementación. La interfaz de la clase es una especie de índice: indica todas las varibles de instancia de la clase y todos los métodos a los que responde. La implementación es donde se desarrolla el código de las funciones. No es necesario dividir las clases en dos archivos, pero es altamente recomendable para hacer más claro el código.

Para añadir un nuevo archivo a nuestro proyecto basta con ir al menú File » New file… o pulsar Comando + N. En la ventana que nos aparecerá seleccionaremos Mac OS X » Cocoa Class » Objective-C Class (Subclass of NSObject). En  File Name introduciremos el nombre de nuestra nueva clase, en este caso Coche, acabado en .m. También marcaremos la casilla Also create “Coche.h”, para mantener más limpio el código.

En el archivo Coche.h encontraremos el siguiente código:

#import <Cocoa/Cocoa.h>

@interface Coche : NSObject {

}

@end

La primera línea ya la vimos en la primera parte de los tutoriales, e importa el Framework Cocoa. En la siguiente línea comienza la interfaz de la clase. Veamos su sintaxis:

• @interface: Inicia la interfaz
• Coche: El nombre de la clase que estamos definiendo
• : : Separado entre el nombre de la clase y la clase de la que hereda.
• NSObject: La clase de la que hereda nuestra clase.
• { : Abre el bloque donde se definen las variables de instancia.
• } : Cierra este bloque.
• @end: Indica el fin de la implementación.

Como podéis ver, las clases pueden ser “hijas” de otras clases, y es algo realmente común. De hecho es muy conveniente que nuestras clases sean hijas de al menos NSObject. La clase NSObject es la clase básica e incluye las funciones esenciales de gestión de memoria (la veremos más tarde), entre otras cosas.

Si nuestra clase es hija de una clase que es hija de NSObject, esta nueva clase también tendrá acceso a los métodos de la clase NSObject.

Ahora bien, imaginemos que queremos que queremos que nuestra clase tenga alguna variable de instancia, como por ejemplo, el color del vehículo y el número de puertas. Definiremos dos variables: color y numPuertas. La primera, color, será un objeto de clase NSString (cadena de texto). La segunda, numPuertas, será una variable de tipo NSUInteger (a nuestro nivel, equivalente a un unsigned int de C, o en palabras llanas, un número entero sin signo).

#import <Cocoa/Cocoa.h>

@interface Coche : NSObject {
 NSString    *color;
 NSUInteger    numPuertas;
}

@end

Fijáos en la sintaxis para definir varibles de instancia:

NOMBRE_DE_LA_CLASE_DEL_OBJETO *NOMBRE_DEL_OBJETO;
NOMBRE_DEL_TIPO_DE_VARIABLE NOMBRE_DE_LA_VARIABLE;

Al defnir un objeto siempre antepondremos un asterisco (“*”) al nombre del objeto.

Y ahora, ¿cómo obtenemos el valor de estas variables? Pues bien, tendremos que crear un método de instancia para asignar este valor. Los métodos se definen entre el corchete de cierre (“}”) y el @end. Creemos dos métodos de instancia: getColor y getNumPuertas. Creemos otro más llamado imprimirDetalles que muestre en la consola los valores devueltos por getColor y getNumPuertas.

#import <Cocoa/Cocoa.h>

@interface Coche : NSObject {
 NSString    *color;
 NSUInteger    numPuertas;
}

- (NSString *)getColor;
- (NSUInteger)getNumPuertas;
- (void)imprimirDetalles;

@end

Fijáos de nuevo en la sintaxis:

- (CLASE_DEL_OBJETO_QUE_VAMOS_A_DEVOLVER *)NOMBRE_DE_LA_FUNCION;
- (TIPO_DE_LA_VARIABLE_QUE_SE_DEVOLVERA)NOMBRE_DE_LA_FUNCION;
- (VOID)NOMBRE_DE_LA_FUNCION_QUE_NO_DEVUELVE_NADA;

Como antes, cuando un método devuelve un objeto, se añade un asterisco al nombre de la clase del objeto que se devolverá. Cuando no es un objeto, no es necesario añadir el asterisco. Cuando una función no devuelve nada, se utiliza el valor void para indicárselo al compilador.

El guión (“-”) que precede a los métodos sirve para indicar que se trata de métodos de instancia. Si se tratase de métodos de clase (que veremos más adelante), estarían precedidos por un sigo +.

Pero aún nos faltan dos métodos para establecer el valor de las dos variables de instancias. Para ello definiremos dos métodos llamados setColor y setNumPuertas que acepten un parámetro que será el nuevo valor.

#import <Cocoa/Cocoa.h>

@interface Coche : NSObject {
 NSString    *color;
 NSUInteger    numPuertas;
}

- (NSString *)getColor;
- (NSUInteger)getNumPuertas;
- (void)imprimirDetalles;

- (void)setColor: (NSString *)nuevoColor;
- (void)setNumPuertas: (NSUInteger)nuevoNumPuertas;

@end

Analicemos la sintaxis de estas funciones. Como podéis ver, ninguna de las dos devuelve ningún valor, luego en el primer paréntesis escribiremos void. Los nombres están claros, pero al final de estos hay dos puntos (“:”). Esto indica que a continuación se encuentra un parámetro. Los parámetros tienen dos partes: la clase del objeto que es el parámetro o el tipo de la variable que es el parámetro y el nombre del mismo. La sintaxis es igual que la del tipo de valor que devuelve la función: El tipo de variable o la clase de objeto entre paréntesis (si es un objeto el parámetro se añade un asterisco) y a continuación el nombre del mismo. Las funciones pueden admitir varios parámetros, y pueden haber funciones con el mismo nombre pero diferentes parámetros. A continuación tenéis un ejemplo.

- (void)miFuncion;
- (void)miFuncionConUnParametro: (NSUInteger)miParametro;
- (NSString *)miFuncionConUnParametro: (NSUInteger)miParametro queAdemasDevuelveUnaCadenaDeTextoYRequiereOtroParametro: (NSUInteger)elSegundo;

Esto presenta un problema: ¿Cómo se llaman las funciones, si puede haber dos iguales hasta el primer parámetro? Pues bien, las funciones anteriores se llamarían así:

miFuncion
miFuncionConUnParametro:
miFuncionConUnParametro:queAdemasDevuelveUnaCadenaDeTextoYRequiereOtroParametro:

De este modo no son iguales los nombres a pesar de ser bastante parecidos (al menos en principio).

Con esto hemos creado la interfaz de nuestra clase: el índice de variables y métodos a los que responde. Sin embargo aún tenemos que escribir el código de estas funciones, así que vayamos al archivo Coche.m y comencemos a implementarlas. En el archivo .m veremos el siguiente código:

#import "Coche.h"

@implementation Coche

@end

Os suena, ¿verdad? Como en el caso anterior, vemos como se importa un archivo, en este caso la interfaz de nuestra clase. También vemos como se inicia la implementación con un código similar a la interfaz. Como podéis suponer, entre @implementation Coche y @end es donde escribiremos nuestras funciones.

Antes de implementar nuestras funciones, añadid el siguiente código después de @implementation Coche. Se trata de un método para la gestión de memoria que veremos en otro tutorial. Así de forma rápida, el método dealloc se llama cuando un objeto va a ser eliminado de la memoria. Los objetos tienen un contador interno que se aumenta con el método retain y se disminuye con el método release. Cuando el contador llega a 0, se llama automáticamente al método dealloc y se elimina el objeto de la memoria. De momento basta con que lo copiéis sin preguntar, ya lo explicaré más adelante.

- (void)dealloc
{
 [color release];

 [super dealloc];
}

Aprovechando este código os explicaré cómo se sobreescriben funciones ya existentes en la clase padre. Como he comentado, una clase que hereda de otra recibe las funciones de la clase padre, pero ¿qué sucede si queremos que en la clase hija la función heredada sea diferente? Pues nada, escribimos la nueva función como cualquier otra. La sintaxis es sencilla:

- (TIPO_DE_VALOR_QUE_SE_DEVUELVE)NOMBRE_DE_LA_FUNCION
{

// Código de la función

}

¿Qué ocurre si queremos que además de ejecutarse nuestro código se ejecute también el método (por si no os habéis dado cuenta, utilizo método y función para referirme a lo mismo, tal vez no es lo más correcto, pero estoy más acostumbrado a hablar de función y no de método, así que me sale sin pensar) de la clase padre que estamos sobreescribiendo? Pues añadimos [super NOMBRE_DE_LA_FUNCION]; en el lugar en el que queramos que se ejecute.

- (TIPO_DE_VALOR_QUE_SE_DEVUELVE)NOMBRE_DE_LA_FUNCION
 {

// Podemos ejecutar el método de la clase padre antes que nuestro código

[super NOMBRE_DE_LA_FUNCION];

// Código de la función

// O después

[super NOMBRE_DE_LA_FUNCION];

}

Veamos ahora cómo quedaría la implementación de nuestra clase tras añadir todos los métodos que hemos definido en la interfaz:

#import "Coche.h"

@implementation Coche

- (void)dealloc
{
 [color release];

 [super dealloc];
}

- (NSString *)getColor
{
}

- (NSUInteger)getNumPuertas
{
}

- (void)imprimirDetalles
{
}

- (void)setColor: (NSString *)colorNuevo
{
}

- (void)setNumPuertas: (NSUInteger)nuevoNumeroDePuertas
{
}

@end

Fijáos en que he cambiado el nombre de las variables de los argumentos de las dos últimas funciones. Las variables de los argumentos no tienen por qué tener el mismo nombre en la interfaz y en la implementación, pero tampoco pasa nada porque tengan el mismo nombre.

La función getColor y getNumPuertas tan sólo devuelven el valor de las variables correspondientes, así que añadiremos return VARIABLE; para que el método devuelva el valor de la variable. return no requiere asterisco si se devuelven objetos, se usa exactamente igual con objetos que con variables sencillas.

En la función imprimirDetalles utilizaremos la función NSLog para imprimir en la consola los valores de las variables. La función NSLog admite varios parámetros. El primero siempre es una cadena de texto (@”"), pero esta cadena admite combinaciones de caracteres específicas que indican que se deben reemplazar por otro valor. Así un %d se reemplazará por un número entero, un %f por un número decimal y un %@ por otra cadena de texto (se puede usar tranquilamente un objeto también, lo veremos más adelante). Si usamos estas combinaciones, tras la cadena de caracteres, y separadas por comas (“,”) debemos introducir las variables o los objetos que reemplazarán las combinaciones. A continuación tenéis las tres funciones que hemos explicado:

- (NSString *)getColor
{
 return color;
}

- (NSUInteger)getNumPuertas
{
 return numPuertas;
}

- (void)imprimirDetalles
{
 NSLog(@"Este coche es de color %@ y tiene %d puertas", [self getColor], [self getNumPuertas]);
}

Fijáos en la última función, concretamente en [self getColor] y [self getNumPuertas]. Esta es la sintaxis para enviar mensajes a los objetos. Enviar un mensaje a un objeto es, básicamente, pedirle a un objeto que ejecute el método con ese nombre. Así, cuando escribimos [self funcion] le pedimos al objeto self que ejecute el método funcion. El objeto self es un objeto especial y hace referencia al objeto actual, de modo que lo que hacemos en esta última función es pedirle al objeto de clase Coche que ejecuta el método imprimirDetalles que ejecute el método getColor y getNumPuertas.

Las funciones setColor y setNumPuertas son bastante sencillas. Simplemente asignaremos (mediante “=”) el valor que se pasa como parámetro (o argumento) a la variable correspondiente. Aquí los tenéis completos:

- (void)setColor: (NSString *)colorNuevo
{
 color = colorNuevo;
}

- (void)setNumPuertas: (NSUInteger)nuevoNumeroDePuertas
{
 numPuertas = nuevoNumeroDePuertas;
}

Y este es el aspecto final de la implementación de nuestra clase Coche:

#import "Coche.h"

@implementation Coche

- (void)dealloc
{
 [color release];

 [super dealloc];
}

- (NSString *)getColor
{
 return color;
}

- (NSUInteger)getNumPuertas
{
 return numPuertas;
}

- (void)imprimirDetalles
{
 NSLog(@"Este coche es de color %@ y tiene %d puertas", [self getColor], [self getNumPuertas]);
}

- (void)setColor: (NSString *)colorNuevo
{
 color = colorNuevo;
}

- (void)setNumPuertas: (NSUInteger)nuevoNumeroDePuertas
{
 numPuertas = nuevoNumeroDePuertas;
}

@end

Ahora modificaremos nuestra aplicación para que cree un objeto de clase coche, establezca su color en azul y su número de puertas en 5 y que a continuación imprima en la consola la información sobre el mismo.

Vamos al archivo NOMBREPROYECTO.m, que debería tener el siguiente código:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

 // insert code here...
 NSLog(@"Hello, World!");
 [pool drain];
 return 0;
}

E importamos el archivo Coche.h justo después de importarse Foundation:

#import "Coche.h"

A continuación añadimos, entre NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; y [pool drain];:

Coche *miCoche = [[Coche alloc] init];

 [miCoche setColor:@"Azul"];
 [miCoche setNumPuertas:5];

 [miCoche imprimirDetalles];

 [miCoche release];

Vayamos línea a línea:

Coche *miCoche = [[Coche alloc] init];

En esta línea creamos el objeto miCoche, de clase Coche. Fijáos como se le envía a  la clase Coche el mensaje alloc y al objeto resultante de ese mensaje se le envía el mensaje init. Los mensajes se pueden encadenar tanto como se quiera, aunque esto hace más complicado de leer el código, así que no es muy recomendable.

[miCoche setColor:@"Azul"];
[miCoche setNumPuertas:5];

En estas dos líneas se envía el método setColor: y setNumPuertas: al objeto miCoche, con el parámetro @”Azul” como nuevo color y 5 como número de puertas.

[miCoche imprimirDetalles];

En esta línea se le manda al objeto el mensaje imprimirDetalles, lo que hará que muestre por terminal los valores de las variables.

 [miCoche release];

Por último esta línea elimina el objeto. En realidad es algo más complejo, y lo explicaré más adelante en otro tutorial. De momento con saber que se elimina el objeto nos vale.

El código resultante de MIPROYECTO.m será:

#import <Foundation/Foundation.h>
#import "Coche.h"

int main (int argc, const char * argv[]) {
 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

 // insert code here...
 NSLog(@"Hello, World!");

 Coche *miCoche = [[Coche alloc] init];

 [miCoche setColor:@"Azul"];
 [miCoche setNumPuertas:5];

 [miCoche imprimirDetalles];

 [miCoche release];

 [pool drain];
 return 0;
}

Y si compilamos y ejecutamos la aplicación veremos el siguiente resultado:

Esto no está mal, pero, ¿para qué llamar a dos métodos para establecer las variables y otro más para iniciar el objeto (init)? ¿No podríamos juntar esos tres métodos en uno? Sí, podemos. Vayamos al archivo Coche.h y añadamos el siguiente método:

- (Coche *)initWithColor: (NSString *)nuevoColor andNumPuertas: (NSUInteger)nuevoNumPuertas;

Quedando así la interfaz:

#import <Cocoa/Cocoa.h>

@interface Coche : NSObject {
 NSString    *color;
 NSUInteger    numPuertas;
}

- (Coche *)initWithColor: (NSString *)nuevoColor andNumPuertas: (NSUInteger)nuevoNumPuertas;

- (NSString *)getColor;
- (NSUInteger)getNumPuertas;
- (void)imprimirDetalles;

- (void)setColor: (NSString *)nuevoColor;
- (void)setNumPuertas: (NSUInteger)nuevoNumPuertas;

@end

En la implementación añadiremos lo siguiente:

- (Coche *)initWithColor: (NSString *)nuevoColor andNumPuertas: (NSUInteger)nuevoNumPuertas
{
 if (self = [super init])
 {
 [self setColor:nuevoColor];
 [self setNumPuertas:nuevoNumPuertas];
 }
 return self;
}

Analicemos este código. La primera línea de la función, if (self = [super init]) sirve para comprobar que el objeto se ha creado correctamente. Es posible (aunque raro) que por algún motivo el objeto no pueda crearse correctamente (por ejemplo, por falta de memoria), así que en caso de que no se cree correctamente, no estableceremos el valor de ninguna variable (pues de otra manera haríamos fallar la aplicación). Dentro de la condición se envía los mensajes que ya conocemos al objeto y finalmente se devuelve el objeto self. Como podéis ver, esta función devuelve un objeto de clase Coche.

El código final de nuestra implementación será:

#import "Coche.h"

@implementation Coche

- (Coche *)initWithColor: (NSString *)nuevoColor andNumPuertas: (NSUInteger)nuevoNumPuertas
{
 if (self = [super init])
 {
 [self setColor:nuevoColor];
 [self setNumPuertas:nuevoNumPuertas];
 }
 return self;
}

- (void)dealloc
{
 [color release];

 [super dealloc];
}

- (NSString *)getColor
{
 return color;
}

- (NSUInteger)getNumPuertas
{
 return numPuertas;
}

- (void)imprimirDetalles
{
 NSLog(@"Este coche es de color %@ y tiene %d puertas", [self getColor], [self getNumPuertas]);
}

- (void)setColor: (NSString *)colorNuevo
{
 color = colorNuevo;
}

- (void)setNumPuertas: (NSUInteger)nuevoNumeroDePuertas
{
 numPuertas = nuevoNumeroDePuertas;
}

@end

¿Cómo aplicamos estos cambios a nuestra aplicación? Vayamos al archivo NOMBREPROYECTO.m y reemplacemos el siguiente código:

Coche *miCoche = [[Coche alloc] init];

 [miCoche setColor:@"Azul"];
 [miCoche setNumPuertas:5];

Por este otro:

Coche *miCoche = [[Coche alloc] initWithColor:@"Azul" andNumPuertas:5];

Como veis, hemos convertido tres líneas de código en sólo una, y el resultado es idéntico.

Esto tan sólo es una breve introducción al paradigma de la programación orientada a objetos. Espero que os haya aclarado un poco los conceptos. En los próximos tutoriales iremos viendo más características de la POO en Objective-C.

En este serie de tutoriales voy a suponer que se tienen unos conocimientos básicos de programación, que se entiende el significado de términos como “código fuente”, “función” o “variable”. Cualquiera que haya programado antes en cualquier lenguaje de programación conocerá su significado. El único término nuevo que puede que no conozcan aquellos que sólo han programado en lenguajes interpretados (como PHP) es el de “compilar”. Para simplificar, podríamos decir que compilar un programa es traducir el código que nosotros escribimos en un código que la máquina pueda entender.

Ahora bien, queda diferenciar cuatro conceptos:

• Objective-C: Es el lenguaje de programación que se suele usar en Mac OS X. Digo se suele usar porque también se pueden programar aplicaciones en C, C++, Objective-C++, etc.
• Cocoa: Es un Framework, un conjunto de funciones que facilitan la tarea al programador. Tareas como modificar una cadena de caracteres, descargar archivos de Internet, gestionar matrices o la memoria se hacen mucho más sencillas con este Framework. De hecho programar en Objective-C sin usar Cocoa es algo poco usual y no lo veremos en este tutorial (yo, por ejemplo, no he programado nada en Objective-C sin tener vinculado Cocoa). Cocoa Touch es la versión de Cocoa para iPhone, iPod Touch y iPad.
• Programación Orientada a Objetos: Es un paradigma de programación del que hablaremos más adelante. Objective-C es un lenguaje de Programación Orientada a Objetos. En Objective-C prácticamente todo es un objeto, cosa que veremos más adelante.
• Modelo Vista y Controlador: Es una arquitectura en la que se separa la parte lógica de la aplicación de la interfaz y de los datos que se gestionan. Realmente no es imprescindible hacer uso de esta arquitectura, pero hacerlo es una buena idea, simplifica la tarea y hace las aplicación más fáciles de extender. En nuestros primeros pasos no haremos uso de esta arquitectura, pero a medida que vayamos avanzando iremos viendo en qué consiste y qué beneficios aporta.

Menú Archivo

Plantillas del proyecto de Xcode

Dicho esto, pasemos a presentar a los sospechosos habituales. Cuando programemos en Mac OS X trabajeros con Xcode, el Entorno de Desarrollo Integrado de Apple. Xcode viene en los discos de instalación de Mac OS X, y se puede descargar de forma gratuita (previo registro) desde la web de Apple. Durante estos tutoriales usaremos como plantilla del proyecto la plantilla de aplicación para la línea de comandos, ya que así evitamos tener que preocuparnos de elementos más complejos como la interfaz gráfica de la aplicación. Crear un nuevo proyecto es sencillo: Basta con ir al menú File » New project… . Aparecerá una ventana en la que podremos seleccionar la plantilla para el proyecto que vamos a crear. En estos tutoriales elegiremos la plantilla Mac OS X » Application » Command Line Tool.

Veremos una ventana como la que tenéis en la izquierda. En la parte izquierda de la ventana tenemos acceso a los archivos del proyecto. De los archivos que se pueden ver en la imagen, el que nos interesa ahora es NOMBREPROYECTO.m. Veréis un código como el siguiente:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

 // insert code here...
 NSLog(@"Hello, World!");
 [pool drain];
 return 0;
}

Vayamos línea a línea. La primera línea importa el Framework Foundation en nuestra aplicación. El Framework Cocoa está compuesto por dos Frameworks diferentes: Foundation y Application Kit. Foundation incluye las funciones que trabajan en la trastienda sin que el usuario lo vea, pero que al desarrollador le vienen fenomenal. Por su parte, Application Kit se encarga de la parte visual de la aplicación (como comprenderéis, esto es una versión resumida de lo que realmente hacen, así que tampoco lo toméis al pie de la letra). Si os fijáis en la sintaxis, podéis ver tres partes: La almohadilla (#), los signos menor y mayor que (<>) y el nombre del Framework.

La almohadilla introduce instrucciones para el preprocesador. Las que más comúnmente se usan con #import y #define. #import incluye otros archivos y Frameworks en el archivo actual. #define permite declarar constantes. Las constantes sirven para definir un valor que es fijo en toda la aplicación, pero que si nos interesa cambiar, podemos hacerlo modificando una sóla línea. Imaginad, por ejemplo, que queremos definir nuestra edad. Si sólo la ponemos en una línea no hay ningún problema, pero ¿y si la incluímos en 5, 10, 200 ó 5000 líneas? Es una faena tener que ir buscando cada lugar en el que hemos puesto ese valor. Con las constantes basta con poner la constante en lugar de nuestra edad, y definir el valor de la constante con el valor de nuestra edad. Cuando queramos modificar el valor de nuestra edad, sólo lo cambiaremos una vez, en lugar de tantas veces como uso se haga de ella.

A la hora de importar archivos, hay dos tipos de archivos que podemos importar: Frameworks del sistema y otros archivos de nuestro proyecto. Cuando importamos Frameworks del sistema, usamos los signos mayor e igual que (<>). Si importamos archivos de nuestro proyecto, usamos comillas (“).

La siguiente línea define la función main. La función main es la función principal de la aplicación, la única función que siempre se ejecuta. La estructura de la función es la misma estructura que C, sin embargo en Objective-C la mayoría de las funciones (métodos) se definen con una sintaxis diferente, así que no me voy a parar a explicarla.

Centrémonos en el siguiente bloque:

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

 // insert code here...
 NSLog(@"Hello, World!");
 [pool drain];
 return 0;

En este bloque vemos unas cuantas líneas curiosas. Vayamos a la primera:

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

Esta es la sintaxis para crear un objeto en Objective-C. El primer NSAutoreleasePool es la clase del objeto que vamos a crear. El asterisco (“*”) indica que a continuación se presenta un objeto (lo veremos más adelante). pool es el nombre de la variable (objeto) que estamos creando. La segunda parte del código: [[NSAutoreselasePool alloc] init], se trata de un mensaje enviado a una clase, que es a su vez el valor del objeto que estamos creando. Los mensajes se pueden enviar tanto a clases como a objetos, lo veremos más adelante, no os preocupéis.

A continuación vemos una línea que comienza con dos barras (//). Cuando una línea va introducida por dos barras, se trata de un comentario. Los comentarios se eliminan de la aplicación al compilarla: son sólo una ayuda al programador durante la programación, para saber qué hace cada cosa o para qué se usa una variable. Los comentarios también se pueden introducir con /* Comentario */.

// Con dos barras el comentario ocupa toda la línea

/* Con barra y asterisco es necesario terminar el comentario con asterisco barra, así que el comentario

aún no ha acabado en esta línea,

sino que acaba en esta otra */

La siguiente línea es la llamada a una función.

NSLog(@"Hello, World!");

Objective-C es un superconjunto de C, con lo cual comparte algunas características con el anterior. Esta forma de llamar a la función es típica de C. Las funciones tienen dos partes: La primera (NSLog en este caso) es el nombre de la función. La segunda, que se encuentra entre paréntesis (“()”), son los argumentos de la función. En este caso, el argumento es: @”Hello, World!”. Cuando unas comillas están precedidas por un arroba (@), sabemos que se trata de una cadena de texto, un objeto de clase NSString (lo trataremos más adelante). Tras los paréntesis encontramos un punto y coma (;). Esto indica el final de una instrucción (todas las instrucciones en C y Objective-C van sucedidas por un punto y coma (;), a excepción de aquellas instrucciones que son argumentos de funciones (como el @”Hello, World!”)  o de mensajes (lo veremos más adelante).

La función NSLog() muestra el texto que se le envía como argumento en la terminal. Durante el desarrollo de la aplicaciones es una función muy útil, como veréis a medida que avancemos en los tutoriales, para saber el valor de una variable en cada momento o para recibir un aviso cuando se ejecuta un método.

[pool drain];

Esta línea le envía el mensaje drain al objeto pool, creado anteriormente. Veremos más adelante todo esto, en otro tutorial de esta serie. A continuación vemos:

return 0;

Esta línea le devuelve el valor 0 al Sistema Operativo. La función main tiene que devolver un valor que indica si la aplicación se ha ejecutado correctamente o si ha encontrado errores durante su ejecución. El valor 0 indica que todo ha ido bien.

Nuestra primera aplicación ejecutándose

Para probar la aplicación hay que pulsar el botón Build and Run, o pulsar Comando + Enter. La aplicación se compilará y se ejecutará. Como la aplicación no tiene interfaz, se ejecutará sin ver nosotros nada. Para poder ver el texto enviado por nuestra aplicación (Hello, World!), tenemos que mostrar la consola (Menú Run » Console o Comando + Mayus + R). Veremos algo como la imagen de la izquierda.

Y esto es todo por este primer tutorial. En los próximos comenzaré a tratar la Programación Orientada a Objetos en Objective-C e introduciré los conceptos de clase, objeto y método.

<a href="http://www.tuenti.com/share?url=[URL_DE_NUESTRO_ARTICULO]" target="_blank">
<img src="[IMAGEN_DEL_BOTON]" />
</a>

La URL del enlace apunta a la página de compartir de Tuenti, donde [URL_DE_NUESTRO_ARTICULO] debe ser reemplazado por la URL de nuestro artículo codificada, o bien mediante la función Javascript encodeURIComponent() o bien mediante la función PHP urlencode().

La imagen del botón podemos elegirla nosotros, lo recomendable es usar algunas de las que ofrece Tuenti para no confundir a los usuarios, aunque también podemos crear las nuestras. Por último, los desarrolladores de Tuenti recomiendan que el enlace se abra en una nueva ventana, aunque quizás sería mejor abrir la ventana dentro de una ventana modal en nuestro propio blog, para así evitar tener que abrir una nueva pestaña.

Para añadir el botón de compartir a todos nuestros artículos basta con editar el archivo single.php de nuestro theme de WordPress y añadir en el lugar que queramos mostrar el enlace:

<a href="http://www.tuenti.com/share?url=<?php echo urlencode(get_permalink()); ?>" target="_blank">
 <img src="http://estaticosak1.tuenti.com/layout/web2-Zero/images/corporate/3_share_es_dark.59917.png" />
 </a>

El código simplemente muestra el enlace con el permalink del artículo cofidicado. La URL de la imagen que aparece en el código anterior es la misma que aparece en la página de desarrolladores de Tuenti, así que podéis usar esa o cambiarla por otra. No os recomiendo usar la que hay en el código de ejemplo porque tal vez la ruta a esa imagen cambien en algún tiempo y entonces os dejen de funcionar los botones de compartir.

También podéis añadir el botón a vuestras páginas, no sólo a los artículos, mediante el mismo código.

Afortunadamente tenemos una alternativa: podemos convertir nuestros PDF en ePub. Hay muchas aplicaciones para hacer esto, tanto online como offline, pero en este artículo sólo me centraré en una aplicación. Calibre (así es como se llama la utilidad que nos permitirá convertir nuestros PDF en ePub) es totalmente gratutia y está disponible tanto para Windows como para Linux y Mac OS X.

Instalar Calibre es realmente fácil. El primer paso (imagen de la izquierda) nos dejará seleccionar el idioma de la aplicación y la carpeta en la que almacenaremos la colección de libros (no lo he comentado antes, pero Calibre permite gestionar toda nuestra biblioteca digital además de convertir nuestros archivos PDF en ePub – entre otros formatos). El siguiente paso (imagen de la derecha) consiste en seleccionar el lector de libros que usaremos, este tutorial está orientado al iPhone, iPod y iPad, así que seleccionaremos de la primera lista “Apple” y de la segunda “iPad or iPhone/iTouch + Stanza“.

El tercer paso es opcional (imagen de la izquierda) y permite crear un servidor para almacenar información acerca de nuestra lectura si usamos la aplicación Stanza, pero el objectivo del tutorial es leer los libros con iBooks, así que podemos dejar desmarcada esta opción. Con esto habremos terminado de configurar Calibre (imagen de la derecha).

Convertir un documento PDF a ePub no es tampoco nada complicado. Lo primero que tenemos que hacer es añadir el documento en cuestión a Calibre, en Mac OS X basta con arrastrar el archivo a su icono en el dock, aunque también podemos añadirlo haciendo clic en la imagen del libro rojo (la primera imagen del menú superior). Cuando tengamos añadido el libro veremos algo similar a la imagen de la izquierda. A continuación tenemos que seleccionar el libro que queramos convertir y hacer clic en la imagen del libro marrón (la tercera del menú superior, en la imagen de la izquierda está indicada). Nos aparecerá una ventana con opciones para configurar el nuevo documento (imagen de la derecha), como seleccionar la portada, la tabla de contenidos, metadatos, formato del nuevo documento, etc. Las opciones que vienen por defecto nos valen (a no ser que queramos personalizar más el documento), así que le damos a “Aceptar” y continuamos.

Ahora tendremos que esperar unos minutos (dependiendo del tamaño del archivo) hasta que esté listo el documento convertido (veréis una ventana como la de la imagen de la izquierda). Cuando acabe la exportación, veremos que en nuestra biblioteca de Calibre ahora hay dos archivos más: la portada del libro exportado y el libro en formato ePub. Ahora ya sólo nos queda importar el libro en iTunes (de nuevo en Mac OS X basta con arrastrar el archivo al icono de iTunes en el dock) y sincronizar nuestro iPhone/iPod/iPad.

Lamentablemente, el archivo que obtendremos no será idéntico al PDF, y puede que haya variaciones en el color y en la estructura en general. De hecho el documento que he convertido yo en el tutorial perdía los colores y la estructura del documento variaba ligeramente. A cambio ganaremos la posiblidad de poder aumentar el tamaño de la letra.