Adicionalmente a estos Live Tiles puedo agregarle notificaciones, o la posibilidad de “girar” y entregar más información.

Antes que todo es importante destacar que los live tiles son de 173px x 173px, y que los Live Tiles de mayor tamaño son únicamente para aplicaciones desarrolladas por Microsoft (sí, también digo ‘buuuuh’)

Programáticamente es muy simple realizarlo:

Lo primero es cargar la libreria Microsoft.Phone.Shell

using Microsoft.Phone.Shell;

Declaramos una variable del tipo ShellTile

ShellTile MiTile;

Dentro del constructor de nuestra aplicación lo declaramos

MiTile = ShellTile.ActiveTiles.First();

Para “llenarlo” es tan simple como:

//blah blah blah código antes

StandardTileData NewTileData = new StandardTileData
{
Title = "Indicadores Económicos",
BackContent = "Mi mensaje",
BackTitle = fecha
};
MiTile.Update(NewTileData);

//blah blah blah código después

Lo importante acá es:

Title: El título del “primer” lado del Live Tile

BackContent: Lo que va a mostrarse como texto “en grande” en el “segundo” lado

BackTitle: El titulo del “segundo” lado

Count: El número que aparecerá como notificación en la esquina superior derecha

BackgroundImage: La imagen de fondo del primer lado del Live Tile

BackBackgroundImage: La imagen del fondo del segundo lado.

En menos de 10 minutos puedes tener andando tu Live Tile con el código de arriba [otra razón más para desarrollar para Windows Phone ]

También aparece el maestro Chalalo con su app de Farmacias de Turno

• Webservice
• XML
• Dato “puro”
• JSON

Probablemente el más utilizado en el último tiempo es JSON, por la facilidad con que se pueden generar las respuestas desde cualquier lenguaje (especiamente desde PHP).

Una respuesta “común” de JSON se ve algo así:

{"respuestas":[{"nombre":"UF","fecha":"21\/03\/2012","valor":"22.504,51"},{"nombre":"Dolar","fecha":"21\/03\/2012","valor":"485,61"},{"nombre":"UTM","fecha":"01\/03\/2012","valor":"39.412"},{"nombre":"Euro","fecha":"21\/03\/2012","valor":"642,43"}]}

 

Para leerlo en Windows Phone 7 hay varias alternativas, desde leerlo tipo “pelo en pecho” (realizando divisiones con las comas, dos puntos, etc… lo que es complicado si traes números), hasta pasar los datos como un datacontract (que queda bonito).

Para ello dentro de nuestro proyecto (o dentro del mismo archivo xaml.cs que estamos utilizando), debemos generar las clases con los mismos datos.

En el caso del json que mostré más arriba un contrato sería de la siguiente forma:

[DataContract()]
public class InfoEconomica
{
[DataMember(Name = "respuestas")]
public Datos[] datos;
}
[DataContract]
public class Datos
{
[DataMember]
public string nombre { get; set; }
[DataMember]
public string fecha { get; set; }
[DataMember]
public string valor { get; set; }
}

Ahora, para convertir nuestro JSON a “objetos” en C# primero debemos incluir a System.Runtime.Serialization.Json; dentro de nuestro código con un using:

using System.Runtime.Serialization.Json;

lo siguiente es capturar este JSON desde un servidor remoto

public void ObtenerDatos()
{
try
{
WebClient client = new WebClient();
client.OpenReadCompleted += new OpenReadCompletedEventHandler(client_OpenReadCompleted);
client.OpenReadAsync(new Uri("http://bredebs.net/api/resp.json"), UriKind.Absolute);
}
catch (Exception ex)
{
MessageBox.Show("Error:"+ex.Message, "Error", MessageBoxButton.OK);
}
}

Acá explicaré un poquito más.

Cuando instanciamos un WebClient debemos declararle un evento que se disparará cuando termine de capturar los datos desde el servidor. En este caso usaremos client_OpenReadCompleted, para capturarlo declaramos el método void client_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e).

Primero creamos una variable del tipo DataContractJsonSerializer con nombre serializer, como parámetro le pasamos la clase que definiste.

var serializer = new DataContractJsonSerializer(typeof(InfoEconomica));

Luego creamos un objeto del tipo InfoEconomica (recuerda que este objeto es del tipo que tú creaste), y le asignamos el valor del “deserializado” (automáticamente tiene que “firmarte” el contrato de datos).

InfoEconomica ie = (InfoEconomica)serializer.ReadObject(e.Result);

ahora ya puedes utilizar la instancia como una colección de objetos.

void client_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
if (e.Error == null)
{
var serializer = new DataContractJsonSerializer(typeof(InfoEconomica));
InfoEconomica ie = (InfoEconomica)serializer.ReadObject(e.Result);
for (int i = 0; i <= ie.datos.Length - 1; i++)
{

System.Console.WriteLine("$" + ie.datos[i].valor.ToString()+" Fecha: " + ie.datos[i].fecha.ToString() + ".");
}
}
else
{
MessageBox.Show("Error en la conexión", "Error", MessageBoxButton.OK);

}
}

Con esta base desarrollé una actualizaciones a la app Indicadores Económicos Chile que tengo en el marketplace de Windows Phone 7

lo típico es realizarlo con imágenes y ajustarlo con position absolute con 2 divs y macramé extras, pero en css es algo un poquito más complejo [y también un poquitito más entretenido de armar]

La técnica si es que le podemos llamar así consiste en definir un div y sobre él aplicar otro con bordes redondeados, y además un box-shadow con el atributo inset para que sea “hacia dentro”, finalmente rotamos el div base para que la sombra quede arriba y dé la sensación que la curva continúa. Ojo, no es un ejemplo perfecto, y por el momento funciona sólo en Firefox [hay que aplicar las reglas CSS3 para los otros navegadores]

Puedes ver el ejemplo final acá.

[Probablemente tengas que modificarlo un poquito cuando lo apliques en tu sitio, pero al menos ya tienes la lógica de cómo aplicarlo.

Ene 10, 2002

Por favor diseñe y construya una casa para mí. No estoy totalmente seguro de lo que necesito así que deberá usar su intuición. Mi casa deberá tener entre dos y cuarenta y cinco habitaciones. Es muy importante que se asegure de que sea posible incluir o eliminar habitaciones con facilidad. Cuando me entregue los planos tomaré la decisión de lo que realmente quiero. Así mismo, necesitaré el costo de cada una de las configuraciones propuestas desglosado para poder tomar una decisión arbitraria.

Tengan en cuenta que la casa que elija deberá costar menos que mi casa actual. Asegúrese de corregir las deficiencias existentes (el piso de la cocina vibra cuando paso por ahí y las paredes no tienen el aislamiento suficiente, por ejemplo.)

Mientras diseñe, deberá tener en mente que deseo mantener los costos de mantenimiento anuales lo más bajo posibles. Esto significa la inclusión de detalles de costo extra como aluminio, vinyl, etc. (Si elige no incluir aluminio, prepare una explicación detallada.)

Es importante que las nuevas prácticas en diseño y los más nuevos materiales sean usados en la construcción de la casa, pues me gustaría usarla como ejemplo de las más recientes ideas y métodos de construcción. Aún así, la cocina deberá ser diseñada para poder acomodar, entre otras cosas, mi Refrigerador Gibson de 1952.

Para asegurarnos de que está construyendo la casa adecuada para nuestra familia es importante que se mantenga en contacto con cada uno de nuestros hijos así como con nuestra familia extendida. Mi suegra tendrá sus propias opiniones acerca de cómo la casa deberá ser diseñada, ya que nos visita, por lo menos, una vez al año.

Asegúrese de encontrar el balance perfecto entre todas las opciones recibidas para poder llegar a la decisión correcta. Sin embargo, me reservo el derecho de nulificar cualquier elección que usted haga.

Por favor, no es necesario que me moleste con pequeños detalles en este momento. Su trabajo es el de desarrollar los planes generales para la casa. Por ejemplo, ahora no es tan importante el color de la alfombra; sin embargo, tenga en mente que mi esposa prefiere el azúl.

Así mismo, no necesita preocuparse acerca de los recursos para construir la casa. La prioridad número uno es el desarrollo de los planes detallados y las especificaciones. Una vez que sean aprobados, esperaría que la casa estuviera terminada en 48 horas.

Mientras esté en la fase de diseño, contemple que eventualmente querré vender la casa a alguien más. Es por esto que el diseño deberá de ser lo suficientemente genérico como para gustarle a la mayoría de los futuros clientes potenciales.

Antes de finalizar con la fase de diseño, es importante que se asegure que le agrade a la gran mayoría de la población cercana a mi casa. Le aconsejo que vaya a ver la casa de mi vecino, la cual fue construída el año pasado. Nos gusta muchísimo. Esa casa tiene muchas opciones que nos gustaría ver en la nuestra, particularmente la alberca de 75 pies. Con un buen diseño e ingeniería, creo que es posible construir una alberca similar sin afectar el costo final.

Por favor prepare un set completo de planos. No es necesario hacer el diseño real en este momento ya que sólo serán usados para cotizaciones y ejemplos. Sin embargo, tenga en consideración que usted será responsable por los costos de construcción causados por cambios en el diseño.

Debe usted sentirse afortunado de trabajar en un proyecto tan interesante como este. Poder utilizar las más recientes técnicas y materiales y, al mismo tiempo, tener tanta libertad para diseñar, es algo que no pasa muy seguido.

Contácteme lo antes posible con todas sus ideas y planes.

PD: Mi esposa no está de acuerdo con muchas de las instrucciones que le he dado en esta carta. Como arquitecto, es su responsabilidad resolver estas diferencias. Yo lo he intentado antes y he fracasado. Si usted no es capáz de tener esta responsabilidad, me veré obligado a encontrar a otro arquitecto.

PD2: Quizás lo que necesito no sea una casa, sino una casa rodante. Por favor, dígame lo antes posible si esto es lo que necesito.

–

Traducido de If Architects Had to Work Like Web Designers

Obtenido desde http://www.paolavillarreal.name/2009/09/06/si-los-arquitectos-trabajaran-como-desarrolladores-de-software/

Error WordPress + Disqus

var disqus_shortname = 'bredebs';
var disqus_domain = 'disqus.com';
(function () {
var nodes = document.getElementsByTagName('span');
for (var i = 0, url; i < nodes.length; i++) {
if (nodes[i].className.indexOf('dsq-postid') != -1) {
nodes[i].parentNode.setAttribute('data-disqus-identifier', nodes[i].getAttribute('rel'));
url = nodes[i].parentNode.href.split('#', 1);
if (url.length == 1) { url = url[0]; }
else { url = url[1]; }
nodes[i].parentNode.href = url + '#disqus_thread';
}
}
var s = document.createElement('script'); s.async = true;
s.type = 'text/javascript';
s.src = 'http://' + disqus_domain + '/forums/' + disqus_shortname + '/count.js';
(document.getElementsByTagName('HEAD')[0] || document.getElementsByTagName('BODY')[0]).appendChild(s);
}());

Pueden solucionarlo de la siguiente manera:
En el archivo disqus.php [/{ruta a tu public_htm}/wp-content/plugins/disqus-comment-system/disqus.php]
línea 1063, agrega:

if(get_bloginfo("home")."/"==curPageURL())
return ;

Además en el functions.php de tu theme disqus.php [/{ruta a tu public_html}/wp-content/themes/{nombre de tu theme}/functions.php]
agrega:

function curPageURL() {
$pageURL = 'http';
if ($_SERVER["HTTPS"] == "on") {
$pageURL .= "s";
}
$pageURL .= "://";
if ($_SERVER["SERVER_PORT"] != "80") {
$pageURL .= $_SERVER["SERVER_NAME"] . ":" . $_SERVER["SERVER_PORT"] . $_SERVER["REQUEST_URI"];
} else {
$pageURL .= $_SERVER["SERVER_NAME"] . $_SERVER["REQUEST_URI"];
}
return $pageURL;
}

Lamentablemente esto debes realizarlo cada vez que actualices tu disqus [se "dispara" automáticamente en cada lectura del loop de WordPress]

Hay otra opción que en teoría debería funcionar, y es agregar en el mismo archivo disqus.php y en la misma línea:

if(is_home() || is_front_page())
return ;

Pero lamentablemente no funciona siempre

Visto acá

if (has_post_thumbnail ()) {
$image_id = get_post_thumbnail_id();
$image = vt_resize($image_id, '', 250, 250, true, 100);
echo '<img src="' . $image[">';
}

Aunque le apliqué una mejora ínfima que permite ajustar la calidad de la imagen redimensionada, por lo que quedaría algo así

/*
* Resize images dynamically using wp built in functions
* Victor Teixeira
*
* php 5.2+
*
* Exemplo de uso:
*
* <?php
* $thumb = get_post_thumbnail_id();
* $image = vt_resize( $thumb, '', 140, 110, true, 90 );
* ?>
* <img src="<?php echo $image[url]; ?>" width="<?php echo $image[width]; ?>" height="<?php echo $image[height]; ?>" />
*
* @param int $attach_id
* @param string $img_url
* @param int $width
* @param int $height
* @param bool $crop
* @param int $quality default: 90
* @return array
*/
function vt_resize($attach_id = null, $img_url = null, $width, $height, $crop = false, $quality=90) {
// this is an attachment, so we have the ID
if ($attach_id) {
$image_src = wp_get_attachment_image_src($attach_id, 'full');
$file_path = get_attached_file($attach_id);
// this is not an attachment, let's use the image url
} else if ($img_url) {

$file_path = parse_url($img_url);
$file_path = $_SERVER['DOCUMENT_ROOT'] . $file_path['path'];

//$file_path = ltrim( $file_path['path'], '/' );
//$file_path = rtrim( ABSPATH, '/' ).$file_path['path'];

$orig_size = getimagesize($file_path);

$image_src[0] = $img_url;
$image_src[1] = $orig_size[0];
$image_src[2] = $orig_size[1];
}

$file_info = pathinfo($file_path);

$extension = '.' . $file_info['extension'];

// the image path without the extension
$no_ext_path = $file_info['dirname'] . '/' . $file_info['filename'];

$cropped_img_path = $no_ext_path . '-' . $width . 'x' . $height . $extension;

// checking if the file size is larger than the target size
// if it is smaller or the same size, stop right here and return
if ($image_src[1] > $width || $image_src[2] > $height) {

// the file is larger, check if the resized version already exists (for $crop = true but will also work for $crop = false if the sizes match)
if (file_exists($cropped_img_path)) {

$cropped_img_url = str_replace(basename($image_src[0]), basename($cropped_img_path), $image_src[0]);

$vt_image = array(
'url' => $cropped_img_url,
'width' => $width,
'height' => $height
);

return $vt_image;
}

// $crop = false
if ($crop == false) {

// calculate the size proportionaly
$proportional_size = wp_constrain_dimensions($image_src[1], $image_src[2], $width, $height);
$resized_img_path = $no_ext_path . '-' . $proportional_size[0] . 'x' . $proportional_size[1] . $extension;

// checking if the file already exists
if (file_exists($resized_img_path)) {

$resized_img_url = str_replace(basename($image_src[0]), basename($resized_img_path), $image_src[0]);

$vt_image = array(
'url' => $resized_img_url,
'width' => $proportional_size[0],
'height' => $proportional_size[1]
);

return $vt_image;
}
}

// no cache files - let's finally resize it
$new_img_path = image_resize($file_path, $width, $height, $crop, $quality);
$new_img_size = getimagesize($new_img_path);
$new_img = str_replace(basename($image_src[0]), basename($new_img_path), $image_src[0]);

// resized output
$vt_image = array(
'url' => $new_img,
'width' => $new_img_size[0],
'height' => $new_img_size[1]
);

return $vt_image;
}

// default output - without resizing
$vt_image = array(
'url' => $image_src[0],
'width' => $image_src[1],
'height' => $image_src[2]
);

return $vt_image;
}

100% recomendada =)

Saludos

Pero también sucede que cuando necesitas comprar una libreria TIENES que ver que el código fuente sea EXTENSIBLE y ENTENDIBLE, por lo cuál no es llegar y comprar a tontas y a locas. Para ello puedes desencriptar las librerías que deseas adquirir.

Sigue este tutorial en Francés [Traducido al español para los huasos, como yo]