Author Archives: admin

Android Aplicación completa I : Interfaz gráfica

(Fuente: http://www.javacodegeeks.com/2010/10/android-full-app-part-1-main-activity.html)

Esta es la primera parte de una serie de artículos para construir una aplicación completa en Android. La aplicación que  se va a realizar  es un servicio de búsqueda fácil de actores y películas a través de internet. En esta primera parte vamos a configurar el proyecto Eclipse, prepararemos el interfaz de usuario para la principal actividad y finalmente lo probamos en un emulador de Android apropiado.

Configurando el proyecto Eclipse

Suponiendo que tenemos ya instalado todo para programar en Android , empecemos creando un nuevo proyecto Eclipse. Al proyecto lo llamaremos ‘AndroidSupermocoFinder y la aplicación se llamará “SupermocoFinderApp”. Observese que el Android 1.5 (API de nivel 3) se utiliza como la plataforma target, porque no utilizaremos ninguno de los últimos APIs.

Definiendo el interfaz de usuario

Nuestro interfaz de usuario será simple:

  • Una textbox donde el usuario  introduce la query de búsqueda
  • Dos radiobuttons indicando si es una búsqueda de peli o de actor
  • Una label para mostrar el tipo de búsqueda
  • Y un botón para realizar la búsqueda. Los resultados de la búsqueda serán presentados en otro activity (esto será discutido luego).

Como probablemente sabes, el interfaz se crea via un fichero XML para así tener independizados la vista de presentación de la lógica de la aplicación. El fichero correspondiente se llama “main.xml” y está en la carpeta “res/layout”. Lo abrimos e introducimos el siguiente contenido:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="vertical"
	android:layout_width="fill_parent"
	android:layout_height="fill_parent">

	<EditText android:id="@+id/search_edit_text"
		android:text="@string/search"
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"	/>

	<RadioGroup
			android:id="@+id/search_radio_group"
			android:layout_width="fill_parent"
			android:layout_height="wrap_content"
			android:orientation="vertical">

			<RadioButton
			android:id="@+id/movie_search_radio_button"
			android:checked="true"
			android:layout_width="wrap_content"
			android:layout_height="wrap_content"
			android:text="@string/movies" />

			<RadioButton
			android:id="@+id/people_search_radio_button"
			android:checked="false"
			android:layout_width="wrap_content"
			android:layout_height="wrap_content"
			android:text="@string/people" />

	</RadioGroup>

	<TextView
		android:id="@+id/search_type_text_view"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:textColor="#ffffff"/>

	<Button
		android:id="@+id/search_button"
		android:text="@string/search"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"/>

</LinearLayout>

Observe que los elementos que muestran cadenas no están hard-coded, sino que sus valores son tomados de recursos externos y más específicamente de un fichero llamado “strings.xml” que reside en la carpeta “res/values”.Esta es una buena práctica para tener la internacionalización preparada para tu aplicación. El fichero es el siguiente:

<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="hello">Hello World, MovieSearchAppActivity!</string>
	<string name="app_name">MovieSearchApp</string>
	<string name="search">Search</string>
	<string name="movies">Movies</string>
	<string name="people">People</string>
</resources>

Podemos arrancar ya la aplicación en un emulador apropiado para ver cómo va quedando:

Integrando el interfaz gráfico con el código

Localizar elementos del UI

El siguiente paso es enganchar estos elementos UI en nuestro código y manipularlos para que estén acordes con nuestra funcionalidad de búsqueda. Este enganche es posible a través del método findViewById , que recibe un parámetro integer que es un Id unívoco , ese Id se lo dimos en el main.xml.

Listeners de los UI

Un aspecto muy importante de los widgets UI de Android es que tiene listeners que permiten programarlos para que ser notificados cuando el usuario realiza alguna acción, tal como hacer click en un botón. Para manejar el evento de clicking, implementamos el interfaz OnClickListener, que define un callback que será invocado cuando una vista sea clicada. El interfaz contiene sólo un método llamado onClick, que es invocado cuando la vista es clicada.

Otro interfaz útil es el OnFocusChangeListener, que define un callback para ser invocado cuando el estado del foco de una view es cambiado. Su único método es onFocusChange, que es invocado cuando cambia el estado del foco del elemento o view.

Veamos cómo se aplican estos listeners en nuestro ejemplo. El código para nuestra clase main principal es la siguiente:

package com.jes;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnFocusChangeListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.TextView;
import android.widget.Toast;

public class SMFinderActivity extends Activity {

	private static final String EMPTY_STRING = "";
	private EditText searchEditText;
	private RadioButton moviesSearchRadioButton;
	private RadioButton peopleSearchRadioButton;
	private RadioGroup searchRadioGroup;
	private TextView searchTypeTextView;
	private Button searchButton;

	@Override
	public void onCreate(Bundle savedInstanceState) {

		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		this.findAllViewsById(); 

		moviesSearchRadioButton.setOnClickListener(radioButtonListener);
		peopleSearchRadioButton.setOnClickListener(radioButtonListener);
		searchButton.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				String query = searchEditText.getText().toString();
				if (moviesSearchRadioButton.isChecked()) {
					longToast(moviesSearchRadioButton.getText() + " " + query);
				}
				else if (peopleSearchRadioButton.isChecked()) {
					longToast(peopleSearchRadioButton.getText() + " " + query);
				}
			}
		});

		searchEditText.setOnFocusChangeListener(new DftTextOnFocusListener(getString(R.string.search)));
		int id = searchRadioGroup.getCheckedRadioButtonId();
		RadioButton radioButton = (RadioButton) findViewById(id);

		searchTypeTextView.setText(radioButton.getText());
	}

	private void findAllViewsById() {
		searchEditText = (EditText) findViewById(R.id.search_edit_text);
		moviesSearchRadioButton = (RadioButton) findViewById(R.id.movie_search_radio_button);
		peopleSearchRadioButton = (RadioButton) findViewById(R.id.people_search_radio_button);
		searchRadioGroup = (RadioGroup) findViewById(R.id.search_radio_group);
		searchTypeTextView = (TextView) findViewById(R.id.search_type_text_view);
		searchButton = (Button) findViewById(R.id.search_button);
	}

	public void longToast(CharSequence message) {
		Toast.makeText(this, message, Toast.LENGTH_LONG).show();
	}

	private OnClickListener radioButtonListener = new OnClickListener() {
		public void onClick(View v) {
			RadioButton radioButton = (RadioButton) v;
			searchTypeTextView.setText(radioButton.getText());
		}

	};

	private class DftTextOnFocusListener implements OnFocusChangeListener {
		private String defaultText;
		public DftTextOnFocusListener(String defaultText) {
			this.defaultText = defaultText;
		}

		public void onFocusChange(View v, boolean hasFocus) {
			if (v instanceof EditText) {
				EditText focusedEditText = (EditText) v;
				// handle obtaining focus
				if (hasFocus) {
					if (focusedEditText.getText().toString().equals(defaultText)) {
						focusedEditText.setText(EMPTY_STRING);
					}
				}
				// handle losing focus
				else {
					if (focusedEditText.getText().toString().equals(EMPTY_STRING)) {
						focusedEditText.setText(defaultText);
					}
				}
			}
		}
	}
}

Empezamos configurando la View para nuestra actividad utilizando el método setContentView. El view usado es el definido por el main.xml.

super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Entonces, tomamos referencia de todos los elementos UI asi que podamos manipularlos via código

private void findAllViewsById() {
	searchEditText = (EditText) findViewById(R.id.search_edit_text);
	moviesSearchRadioButton = (RadioButton) findViewById(R.id.movie_search_radio_button);
	peopleSearchRadioButton = (RadioButton) findViewById(R.id.people_search_radio_button);
	searchRadioGroup = (RadioGroup) findViewById(R.id.search_radio_group);
	searchTypeTextView = (TextView) findViewById(R.id.search_type_text_view);
	searchButton = (Button) findViewById(R.id.search_button);
}

Creamos dos OnclickListeners, uno para manejar los clicks de los radio buttons y otro para la ejecución de la búsqueda cuando se hace click sobre el botón. Los listeners son enganchados a los elementos UI utilizando el método setOnclickListener.

moviesSearchRadioButton.setOnClickListener(radioButtonListener);
peopleSearchRadioButton.setOnClickListener(radioButtonListener);

searchButton.setOnClickListener(new OnClickListener() {
					@Override
					public void onClick(View v) {
						String query = searchEditText.getText().toString();
						if (moviesSearchRadioButton.isChecked()) {
							longToast(moviesSearchRadioButton.getText() + " " + query);
						} else if (peopleSearchRadioButton.isChecked()) {
							longToast(peopleSearchRadioButton.getText() + " " + query);
						}
					}
});

private OnClickListener radioButtonListener = new OnClickListener() {
						public void onClick(View v) {
							RadioButton radioButton = (RadioButton) v;
							searchTypeTextView.setText(radioButton.getText());
						}
};

Como los radiobuttons están definidos dentro de un componente RadioGroup, el framework de Android es el que se encarga de permitir que sólo esté seleccionado a la vez. En tiempo de ejecución , podemos encontrar qué radio button está seleccionado utilizando el método getCheckedRadioButtonId. Observese que este método retorna una ID único global de el radiobutton y puede ser utilizado como argumento del método findViewById para tener referencia del botón.

Finalmente, creemos un  OnFocusChangeListener y lo enganchamos al widget EditText utilizando el método setOnFocusChangeListener:

searchEditText.setOnFocusChangeListener(new DftTextOnFocusListener(getString(R.string.search)));

Con esta implementación , queremos algo como lo siguiente:

Cuando la text box tiene el foco y está vacía, estás preparado para teclear la query de búsqueda. La query permanece allí tanto si la caja de texto tiene el foco como si no lo tiene. Sin embargo, cuando la caja de texto está vacía y pierde el foco, aparece un mensaje predefinido (con un texto que sacamos del strings.xml).

Primera ejecución

Estamos ahora preparados para darle a nuestra aplicación una primera ejecución. Esto lo haremos utilizando un emulador apropiado delAndroid SDK. Lanzamos el AVD (Android Virtual Device) Manager desde el Eclipse y creamos un nuevo device. Le damos un nombre que sea distintivo, por ejemplo “Android1.5-SD” y elegimos la plataforma target, en nuestro caso Android 1.5. También hemos elegido soporte para la SD card, solo por si lo necesitamos.Así es como queda el setup:

Ahora creamos un nueva “Run configuration” de Eclipse, elige nuestro proyecto Android y la “SupermocoFinderAppActivity” para arrancar. Esto es lo que debería salirnos:

En la pestaña “Target” , elegimos el nuevo AVD creado , aplicamos y ejecutamos. Tarda un rato , desbloqueamos y la aplicación aparecerá. Juega un poco con la aplicación , en este momento no realiza nada avanzado, tan solo sale una ventana cuando se le da a buscar con los valores introducidos.

Archivos fuentes utilizados

JSON Introducción

JSON es el acrónimo de JavaScript Object Notation.JSON es un formato alternativo de envío y recepción de datos, es decir remplaza a XML o el envío de texto plano.Este formato de datos es más liviano que XML.Veremos que hace el código más sencillo ya que utiliza el código JavaScript como modelo de datos.

Repaso de arrays literales y objetos literales en Javascript

Tenemos que repasar un poco como se definen los array literales y objetos literales en JavaScript, ya que serán las estructuras para la transmisión de datos:

var usuario=['juan',26];

Como vemos los elementos de un array literal se encierran entre corchetes y los valores contenidos van separados por coma.Cuando definimos un array literal no le indicamos a cada elemento de que tipo se trata, podemos almacenar cadenas (entre comillas), números, valores lógicos (true,false) y el valor null.Paraacceder a los elementos de un array literal lo hacemos por su nombre y entre corchetes indicamos que elementos queremos acceder:

alert(usuario[0]); //Imprimimos el primer elemento del array
alert(usuario[1]); //Imprimimos el segundo elemento del array

Veamos como definimos los objetos literales en javascript:

var persona={
	'nombre':'juan',
	'clave':'xyz',
	'edad':26
};

Los objetos literales se definen por medio de pares “nombre”:”valor”.Todo objeto literal tiene un nombre, en el ejemplo le llamé persona. Un objeto literal contiene una serie de propiedades con sus respectivos valores. Todas las propiedades del objetos se encuentran encerradas entre llaves. Luego cada propiedad y valor se las separa por dos puntos. Y por último cada propiedad se las separa de las otras propiedades por medio de la coma.Para acceder a las propiedades del objeto literal lo podemos hacer de dos formas:

alert(persona.nombre); //Imprime el valor de la propiedad nombre del objeto persona.

La segunda forma es indicando la propiedad entre corchetes:

alert(persona['nombre']);

Luego se pueden combinar objetos literales y array literales:

var persona={
	'nombre':'juan',
	'edad':22,
	'estudios':['primario','secundario']
};

Como podemos ver podemos crear estructuras de datos complejas combinando objetos literales y array literales.Luego para acceder a los distintos elementos tenemos:

alert(persona.nombre);
alert(persona.estudios[0]);
alert(persona.estudios[1]);

Sintaxis JSON

La sintaxis de JSON difiere levemente de lo visto anteriormente:

{
	'nombre':'juan',
	'edad':22,
	'estudios':['primario','secundario']
}

Como podemos ver en la sintaxis JSON no aparecen variables, sino directamente indicamos entre llaves las propiedades y sus valores.Tambien hemos eliminado el punto y coma luego de la llave final. El resto es igual.

Diferencia entre JSON y XML

Ahora veamos la diferencia entre JSON y XML utilizando este ejemplo:

XML:

<persona>
	<nombre>juan</nombre>
	<edad>22</edad>
	<estudios>
		<estudio>primario</estudio>
		<estudio>secundario</estudio>
	</estudios>
</persona>

Y como vimos en JSON:

{
	“nombre”:”juan”,
	“edad”:22,
	“estudios”:[“primario”,”secundario”]
}

Podemos ver que es mucho más directa la definición de esta estructura (de todos modos cuando la estructura a representar es muy compleja XML sigue siendo la opción principal).Como podemos ver si tenemos que transmitir estas estructuras por internet la notación JSON es más liviana.

Leer datos JSON en Javascript

Otra ventaja es como recuperamos los datos en el navegador, como vimos si se trata de un archivo XML llamamos al método requestXML y luego accedemos por medio del DOM.En cambio con JSON al llegar el archivo procedemos a generar una variable en JavaScript que recree el objeto literal, esto mediante la función eval:

var persona=eval('(' + conexion1.responseText + ')');

Ya veremos en el próximo concepto como recuperar los datos del servidor mediante el objeto XMLHttpRequest.

Ejemplo

Para probar y generar un objeto a partir de una notación JSON haremos el siguiente problema: Confeccionar una página que contenga un botón. Al ser presionado evaluar un string que almacena un objeto literal con notación JSON. El objeto literal debe representar las características de una computadora (procesador, memoria ram, capacidad de cada disco duro)

Mostrar los datos mediante el método alert.Hay que tener bien en cuenta que en este problema no hay nada de AJAX ya que no nos comunicaremos con el servidor para el envío de datos.

pagina1.html

<html>
<head>
	<title>Problema</title>
	<script src="funciones.js" language="JavaScript"></script>
</head>
<body>
	<h1>Evaluar una variable que contiene notación JSON.</h1>
	<input type="button" id="boton1" value="Ver">
</body>
</html>

funciones.js

addEvent(window,'load',inicializarEventos,false);

function inicializarEventos()
{
	var ob=document.getElementById('boton1');
	addEvent(ob,'click',presionBoton,false);
}

function presionBoton(e)
{
	var cadena="{ 'microprocesador':'pentium'," +
							" 'memoria':1024," +
							" 'discos':[80,250]" +
							" }";

	var maquina=eval('(' + cadena + ')');
	alert('microprocesador:'+maquina.microprocesador);
	alert('Memoria ram:'+maquina.memoria);
	alert('Capacidad disco 1:'+maquina.discos[0]);
	alert('Capacidad disco 2:'+maquina.discos[1]);
}

//***************************************
//Funciones comunes a todos los problemas
//***************************************
function addEvent(elemento,nomevento,funcion,captura)
{
	if (elemento.attachEvent)	{
		elemento.attachEvent('on'+nomevento,funcion);
		return true;
	} else if (elemento.addEventListener) {
		elemento.addEventListener(nomevento,funcion,captura);
		return true;
	}	else
		return false;
}

Cuando se presiona el botón se ejecuta la función presionBoton. En esta lo primero que hacemos definimos un string que contiene un objeto con notación JSON:

var cadena="{ 'microprocesador':'pentium'," +
							" 'memoria':1024," +
							" 'discos':[80,250]" +
							" }";

Seguidamente pasamos a evaluar este string:

var maquina=eval('(' + cadena + ')');

Ahora si tenemos un objeto JavaScript. Esto se logra utilizando la función eval de JavaScript. Es importante que siempre al string que contiene la notación JSON le debemos anteceder el paréntesis de apertura y finalizarlo con el paréntesis de cerrado (esto para que JavaScript no tenga problemas con las llaves de apertura y cierre de la notación JSON.Una vez que tenemos el objeto en JavaScript procedemos a acceder a sus atributos:

alert('microprocesador:'+maquina.microprocesador);
alert('Memoria ram:'+maquina.memoria);
alert('Capacidad disco 1:'+maquina.discos[0]);
alert('Capacidad disco 2:'+maquina.discos[1]);

 

Llaves, corchetes, dos puntos y comas

Las llaves actuan de ‘contenedores’.Los corchetes almacenan arrays ,es decir delimitan arrays.Names y values son separados por dos puntos.Los elementos de un array son separados por comas

Piensa en JSON como un ‘XML con Anorexia’

O también se pueden ver como ‘ficheros INI con jerarquia’.

JSON es similar a XML por lo siguiente:

  • Ambos tienen significado ‘autodescriptivo’, es decir los valores están nombrados, y eso lo hace muy legible
  • Ambos tienen una estructura jerárquica (es decir puedes tener valores dentro de valores)
  • Ambos pueden ser parseados y utilizados en la mayoría de los lenguajes de programación
  • Ambos pueden ser pasados por AJAX (es decir HttpWebRequest)

JSON es distinto de XML por lo siguiente:

  • XML utiliza ‘<‘ y ‘>’ ,con un nombre de tag al comienzo y al final del elemento. JSON utiliza llaves con el nombre sólo al principio del elemento.
  • JSON es mas simple, luego es más rápido de escribir a los humanos, y también más fácil de leer.
  • JSON puede ser parseado trivialmente utilizando el procedimiento ‘eval()’ de Javascript
  • JSON puede incluir arrays (donde los elementos no tienen que tener unname cada uno)
  • En XML puedes utilizar cualquier nombre que quieras para un elemento, en JSON no pueden utilizar palabras reservadas de Javascript.

Por qué es bueno utilizar JSON?

Cuando estamos escribiendo código JSON, si utilizamos JSON eliminamos el tener que escribir a mano XML, lo cual es más rápido. JSON parece más fácil de utilizar:

Aproximación XML Aproximación JSON
Recupera un documento XML 

Navega por el documento, recuperando valores que necesites

Haz algo con estos valores

Recupera una cadena JSON 

‘eval’ el JSON

 

Es JSON orientado a objetos?

No estrictamente. JSON proporciona una buena técnica de encapsulamiento, que puedes utilizar para separar valores y funciones, pero no hay nada de herencia, polimorfismo, interfaces, etc.

Se utiliza solo JSON en el lado del cliente?

Si y no. En el lado de servidor se puede serializar / deserializar objetos a/desde JSON. Los programadores .net pueden utilizar librerias como Json.net que hace esto automáticamente.

(Other side note: Jason and Ajax were both mythical greek heroes. Prediction: other forthcoming technology jargon will include: Heracles, Perseus, Deucalion, Theseus and Bellerophon.)

Dojo: Hola Mundo

[Fuente: http://dojotoolkit.org/documentation/tutorials/1.6/hello_dojo/]

En este tuto cargaremos DOJO en una pagina HTML simple, poniendo algunas de las funciones básicas de DOJO a funcionar. Tocaremos la estructura modular de DOJO y discutiremos como cargar dependencias para tener un experiencia de usuario más rica.

  • Dificultad: principiante
  • Dojo Version: 1.6

Introducción

Nuestro punto de comienzo es una pagina HTML simple. Queremos cargar DOJO en esa pagina y añadir algun codigo que muestre que está bien cargado.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Tutorial: Hello Dojo!</title>
<!-- load Dojo -->
<script src="http://ajax.googleapis.com/ajax/libs/dojo/1.6.0/dojo/dojo.xd.js"></script>
</head>
<body>
<h1 id="greeting">Hello</h1>
</body>
</html>

View Demo

Vemos como hemos enganchado la libreria dojo.js via CDN. Ahora necesitamos algón código para que Dojo este preparado para funcionar y podamos hacer algo con él.

dojo.ready

Si jquery tiene el document.ready , pues Dojo tiene el dojo.ready. Es decir es el método para saber cuando el DOM del HTML  se ha cargado y todas las librerias (incluida Dojo) han sido cargadas. Al dojo.ready le pasamos una función y la función se ejecutará cuando llegue el momento ready:

 

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Tutorial: Hello Dojo!</title>
<!-- load Dojo -->
<script src="http://ajax.googleapis.com/ajax/libs/dojo/1.6.0/dojo/dojo.xd.js"></script>
<script>
dojo.ready(function(){
alert("Dojo version " + dojo.version + " is loaded");
});
</script>
</head>
<body>
<h1 id="greeting">Hello</h1>
</body>
</html>

 

View Demo

En vez del alert utilicemos una función de Dojo para ir cogiendo el gustillo.

 

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Tutorial: Hello Dojo!</title>
<!-- load Dojo -->
<script src="http://ajax.googleapis.com/ajax/libs/dojo/1.6.0/dojo/dojo.xd.js"></script>
<script>
dojo.ready(function(){
dojo.byId("greeting").innerHTML += ", from " + dojo.version;
});
</script>
</head>
<body>
<h1 id="greeting">Hello</h1>
</body>
</html>

 

View Demo

Si tenemos más de una linea  en el dojo.ready es común utilizar una función init:

 

function init() {
alert("Dojo ready, version:" + dojo.version);
// More initialization here
}
dojo.ready(init);

 

NOTA: observar que al dojo.ready le pasamos el objeto función en si , sin comillas.

Módulos

Dojo es un toolkit modular, con un sistema de paquetes que te prmite cargar solo el código que necesites dentro de tu página y hacer que la gestión de dependencias sea más fácil. Para ello Dojo introduce el dojo.require para indicar la dependencia del módulo indicado.

De momento, apuntemos que cuando cargamos dojo.js, no estamos cargando el Dojo Toolkit entero, sólo los módulos básicos tales como el sistema de paquetes , el sistema de eventos, Ajax, DOM helpers y otras funcionalidades comunmente utilizadas.

Carga de módulos

Los básico de Dojo incluye un framework de animación para efectos visuales y un par de los efectos más comunes (el dojo.fadeOut y el dojo.fadeIn). Eso esta bien, pero nosotro queremos algo que haga que el saludo de nuestra pagina de ejemplo se deslice por la  pantalla. Para eso utilizaremos dojo.fx.slideTo. El módulo dojo.fx no está incluido en el dojo.js asi que necesitaremos cargarlo:

 

// New: Require in the dojo.fx module
dojo.require("dojo.fx");
// Remember, dojo.ready waits for both the DOM and all dependencies
dojo.ready(function(){
// The piece we had before - change our innerHTML
dojo.byId("greeting").innerHTML += ", from " + dojo.version;
// Now, slide the greeting
dojo.fx.slideTo({
top: 100,
left: 200,
node: dojo.byId("greeting")
}).play();
});

 

The slideTo effect we want is a part of the dojo.fx module. The dojo.require line states the dependency, and asks the loader to load the file if it is not already available. There’s no new script tag to fiddle with, and crucially, the rest of our initialization needn’t change — we still use dojo.readyand our code will only run once the DOM is ready and all dependencies are loaded.

The next part is to put what we loaded to use. Like all property animations in Dojo, we pass in an object with a node reference, and any other properties to configure the animation. We’ll be looking closer at animations in Dojo in a future tutorial.

View Demo

Conclusion

Getting started with the Dojo Toolkit is as simple as adding a script tag, but the broad scope of the toolkit is placed at your fingertips, as and when you need it. In this tutorial we’ve taken the first step towards putting Dojo to work in your web sites and applications. In future tutorials in this series we’ll visit each of the major groups of functionality — from DOM helpers to Ajax, effects, events and more — exploring and explaining each step of the way.

Dojo: gráficas

The dojox.charting permite a los programadores crear gráfics funcionales, únicas y dinámicas desde varios conjuntos de datos. Además, dojox.charting proporciona varios themes y chart types que permite a los programadores mostrar sus datos de caulquier forman que gusten. En este tuto mostraremos como crear basic charts con variedad de datos, plots , ejes y themes.

  • Dificultad: principiante
  • Dojo Version: 1.6

Introducción

La libreria de gráficas de Dojo vive dentro del recurso “dojox.charting“. La colección dojox.charting único en lo siguiente:

  • Permite crear charts con HTML (declarativamente) o con Javascript (programamaticamente)
  • Funciona en todos los dispositivos
  • Puede renderizar en SVG, VML, Silverlight y Canvas. Para que soporte SVGWeb se esta haciendo.
  • Permite a los programadores decidir qué tipo utilizar
  • Evalua el cliente y utiliza el render apropiado basandose en lo que el navegador del cliente soporta
  • Crea gráficas con dojox.gfx, una libreria de gráficas vectoriales potente capaz de hacer que tus gráficas tengan animación en una amplia variedad de formas.
  • Viene con una amplia variedad de themes atractivos
  • Permite utilizar gradientes radiales y lineales dentro de los chart themes (que incluso funcionan en IE!!)

Antes de crear estas gráficas, es importante hacer los recursos que utilizará la gráfica disponible dentro de la página.

Configurar dojox.charting

Como para utilizar cualquier recurso de Dojo Toolkit, es importante que utilicemos “dojo.require” para cargar todas las dependencias. Dos dependencias que siempre son necesarias son el recurso de gráfica y el theme deseado:

// Require the basic 2d chart resource: Chart2D
dojo.require("dojox.charting.widget.Chart2D");
// Require the theme of our choosing
//"Claro", new in Dojo 1.6, will be used
dojo.require("dojox.charting.themes.Claro");
// Any plugins we choose to use would be required here as well...

Si tenemos una prioridad específica de renderizado preferida, es posible añadir un dojoConfig object que sea creado antes de cargar el Dojo:

<script>
dojoConfig = {
parseOnLoad: true, //enables declarative chart creation
gfxRenderer: "svg,silverlight,vml" // svg is first priority
};
</script>
<script src="/path/to/dojo/dojo/dojo.js"></script>

Con estas minimas dependencias cargadas ahora nuestra aplicacion web está lista para crear gráficas.

Creando un gráfica básica

De forma declarativa

Hay dos formas de crear un gráfica básica: declarativamente o programaticamente. Antes de crear la gráfica, sin embargo, es importante primero crear o acceder a los datos que la formarán. Los siguientes son unos datos de ejemplo que vamos a utilizar para crear nuestro ejemplo básico:

// x and y coordinates used for easy understanding of where they should display
// Data represents website visits over a week period
chartData = [
{ x: "1", y: "19021" },
{ x: "1", y: "12837" },
{ x: "1", y: "12378" },
{ x: "1", y: "21882" },
{ x: "1", y: "17654" },
{ x: "1", y: "15833" },
{ x: "1", y: "16122" }
];

Con los datos formateados apropiadamente y disponibles , una gráfica creada declarativamente se parece a algo como esto:

<!-- create the chart -->
<div dojoType="dojox.charting.widget.Chart2D" theme="dojox.charting.themes.Claro" id="viewsChart" style="width: 550px; height: 550px;">
<!-- Pie Chart: add the plot -->
<div class="plot" name="default" type="Pie" radius="200" fontColor="#000" labelOffset="-20"></div>
<!-- pieData is the data source -->
<div class="series" name="Last Week's Visits" array="chartData"></div>
</div>

View Demo

Dojo Pie Chart

A pie chart usingthe Claro theme

El código entero del ejemplo anterior:

<html>
<head>
	<script>
		djConfig = {
			isDebug: true,
			parseOnLoad: true
		};
	</script>

	<script src="http://ajax.googleapis.com/ajax/libs/dojo/1.6.0/dojo/dojo.xd.js"></script>
	<script>
		// Grab the parser
		dojo.require("dojo.parser");

		// Require the basic 2d chart resource: Chart2D
		dojo.require("dojox.charting.widget.Chart2D");

		// Require the theme of our choosing
		//"Claro", new in Dojo 1.6, will be used
		dojo.require("dojox.charting.themes.Claro");
		// Any plugins we choose to use would be required here as well...

		// x and y coordinates used for easy understanding of where they should display
		// Data represents website visits over a week period
		chartData = [
			{ x: "1", y: "19021" },
			{ x: "1", y: "12837" },
			{ x: "1", y: "12378" },
			{ x: "1", y: "21882" },
			{ x: "1", y: "17654" },
			{ x: "1", y: "15833" },
			{ x: "1", y: "16122" }
		];

	</script>

</head>
<body>
	<h1>Prueba de Dojo Charting</h1>	

	<!-- create the chart -->
	<div dojoType="dojox.charting.widget.Chart2D" theme="dojox.charting.themes.Claro" id="viewsChart" style="width: 550px; height: 550px;">
		<!-- Pie Chart: add the plot -->
		<div class="plot" name="default" type="Pie" radius="200" fontColor="#000" labelOffset="-20"></div>

		<!-- pieData is the data source -->
		<div class="series" name="Last Week's Visits" array="chartData"></div>
	</div>

</body>
</html>

Cuando creamos la gráfica de forma declarativa, los settings principales de la gráfica están dentro del nodo contenedor. Plots y series consiguen sus propios nodos con atributos de personalizacion conteniendo chart settings, como por ejemplo plugins y trozos de gráficas.

Nota importante: Aunque es ciertamente posible crear gráficas declarativamente, es altamente recomendado que los programadores los creen programaticamente. Todavia dojox.charting no soporta completamente los atributos “data-dojo” de Dojo 1.6

Programaticamente

Programaticamente la creación de gráficas requiere un poco de más código pero proporciona más estabilidad y control. La misma gráfica puede ser creada programaticamente con el código siguiente:

<script>
// When the DOM is ready and resources are loaded...
dojo.ready(function() {
	// Create the chart within it's "holding" node
	var pieChart = new dojox.charting.Chart2D("chartNode");
	// Set the theme
	pieChart.setTheme(dojox.charting.themes.Claro);
	// Add the only/default plot
	pieChart.addPlot("default", {
		type: "Pie",
		radius: 200,
		fontColor: "black",
		labelOffset: "-20"
	});
	// Add the series of data
	pieChart.addSeries("January",chartData);
	// Render the chart!
	pieChart.render();
});
</script>
<!-- chart will go here -->
<div id="chartNode" style="width: 550px; height: 550px;"></div>
View Demo

El código completo del ejemplo anterior es :

<html>
<head>
	<script>
		djConfig = {
			isDebug: true,
			parseOnLoad: true
		};
	</script>

	<script src="http://ajax.googleapis.com/ajax/libs/dojo/1.6.0/dojo/dojo.xd.js"></script>

	<script>
		// Grab the parser
		dojo.require("dojo.parser");

		// Require the basic 2d chart resource: Chart2D
		dojo.require("dojox.charting.widget.Chart2D");

		// Require the theme of our choosing
		//"Claro", new in Dojo 1.6, will be used
		dojo.require("dojox.charting.themes.Claro");
		// Any plugins we choose to use would be required here as well...

		// x and y coordinates used for easy understanding of where they should display
		// Data represents website visits over a week period
		chartData = [
			{ x: "1", y: "19021" },
			{ x: "1", y: "12837" },
			{ x: "1", y: "12378" },
			{ x: "1", y: "21882" },
			{ x: "1", y: "17654" },
			{ x: "1", y: "15833" },
			{ x: "1", y: "16122" }
		];

		// When the DOM is ready and resources are loaded...
		dojo.ready(function() {
		    // Create the chart within it's "holding" node
		    var pieChart = new dojox.charting.Chart2D("chartNode");
		    // Set the theme
		    pieChart.setTheme(dojox.charting.themes.Claro);
		    // Add the only/default plot
		    pieChart.addPlot("default", {
		        type: "Pie",
		        radius: 200,
		        fontColor: "black",
		        labelOffset: "-20"
		    });
		    // Add the series of data
		    pieChart.addSeries("January",chartData);
		    // Render the chart!
		    pieChart.render();
		});
	</script>
</head>

<body>
	<!-- chart will go here -->
	<div id="chartNode" style="width: 550px; height: 550px;"></div>
</body>
</html>

Asignando colores a la gráfica sin utilizar Themes

Se hace pasandole colores como atributos en el metodo addSeries:

chart.addSeries("Monthly Sales - 2009",chartData2,{ stroke: "red", fill: "pink" });

Themes de gráficas

La Libreria de Dojo charting proporciona varios themes para que elijan los programadores.Los Themes varian en complejidad visual: algunos themes utilizan colores hexadecimales mientras otros más complejos utilizan lógica avanzada para calcular gradientes radiales o lineales para asi mejorar el look.

Todos los Themes pueden ser encontrados dentro del recurso dojox.charting.themes. Los Themes son ficheros javascript con datos especificos del Theme que representan. Lo siguiente es el código que crea el Theme “Miami Nice”:

// “Provide” the resource

dojo.provide("dojox.charting.themes.MiamiNice");
// Require the Theme class which is used by all themes
dojo.require("dojox.charting.Theme");
// Create a basic new theme with a list of solid colors
(function(){
	var dxc=dojox.charting;
	dxc.themes.MiamiNice=new dxc.Theme({
		colors: [
			"#7f9599",
			"#45b8cc",
			"#8ecfb0",
			"#f8acac",
			"#cc4482"
		]
	});
})();

Hay temas más complejos disponibles.Un ejemplo sería el theme “Claro” que utiliza gradientes y fuentes customizadas:

dojo.require("dojox.gfx.gradutils");
dojo.require("dojox.charting.Theme");

// created by Tom Trenka
(function(){
	
	var dc = dojox.charting, themes = dc.themes, Theme = dc.Theme, g = Theme.generateGradient,
	
	defaultFill = {type: "linear", space: "shape", x1: 0, y1: 0, x2: 0, y2: 100};
	
	themes.Claro = new dc.Theme({
		chart: {
			fill: {
					type: "linear",
					x1: 0, x2: 0, y1: 0, y2: 100,
					colors: [
						{ offset: 0, color: "#dbdbdb" },
						{ offset: 1, color: "#efefef" }
					]
			},
			
			stroke:    {color: "#b5bcc7"}
		},
		
		plotarea: {
			fill:{
					type: "linear",
					x1: 0, x2: 0, y1: 0, y2: 100,
					colors: [
						{ offset: 0, color: "#dbdbdb" },
						{ offset: 1, color: "#efefef" }
					]
			}
		},
		
		
		axis:{
			stroke: { // the axis itself
							color: "#888c76",
							width: 1
			},
		
			tick: { // used as a foundation for all ticks
				color: "#888c76",
				position: "center",
				font: "normal normal normal 7pt Verdana, Arial, sans-serif", // labels on axis
				fontColor: "#888c76" // color of labels
			}
		},
		
		series: {
			stroke:  {width: 2.5, color: "#fff"},
			outline: null,
			font: "normal normal normal 7pt Verdana, Arial, sans-serif",
			fontColor: "#131313"
		},
		
		marker: {
			stroke:  {width: 1.25, color: "#131313"},
			outline: {width: 1.25, color: "#131313"},
			font: "normal normal normal 8pt Verdana, Arial, sans-serif",
			fontColor: "#131313"
		},
		
		seriesThemes: [
			{fill: g(defaultFill, "#2a6ead", "#3a99f2")},
			{fill: g(defaultFill, "#613e04", "#996106")},
			{fill: g(defaultFill, "#0e3961", "#155896")},
			{fill: g(defaultFill, "#55aafa", "#3f7fba")},
			{fill: g(defaultFill, "#ad7b2a", "#db9b35")}
		],
		
		markerThemes: [
			{fill: "#2a6ead", stroke: {color: "#fff"}},
			{fill: "#613e04", stroke: {color: "#fff"}},
			{fill: "#0e3961", stroke: {color: "#fff"}},
			{fill: "#55aafa", stroke: {color: "#fff"}},
			{fill: "#ad7b2a", stroke: {color: "#fff"}}
		]
	});
	
		themes.Claro.next = function(elementType, mixin, doPost){
													var isLine = elementType == "line";
													if(isLine || elementType == "area"){
															// custom processing for lines: substitute colors
															var s = this.seriesThemes[this._current % this.seriesThemes.length],
															m = this.markerThemes[this._current % this.markerThemes.length];
															s.fill.space = "plot";
															if(isLine){
																s.stroke  = { width: 4, color: s.fill.colors[0].color};
															}
															m.outline = { width: 1.25, color: m.fill };
															var theme = Theme.prototype.next.apply(this, arguments);
															// cleanup
															delete s.outline;
															delete s.stroke;
															s.fill.space = "shape";
															return theme;
													} else if(elementType == "candlestick"){
														var s = this.seriesThemes[this._current % this.seriesThemes.length];
														s.fill.space = "plot";
														s.stroke  = { width: 1, color: s.fill.colors[0].color};
														var theme = Theme.prototype.next.apply(this, arguments);
														return theme;
													}
													return Theme.prototype.next.apply(this, arguments);
		};
		
		themes.Claro.post = function(theme, elementType){
													theme = Theme.prototype.post.apply(this, arguments);
													if((elementType == "slice" || elementType == "circle") && theme.series.fill && theme.series.fill.type == "radial"){
													theme.series.fill = dojox.gfx.gradutils.reverse(theme.series.fill);
													}
													return theme;
		};
})();

Whether the theme you implement (or create) is basic or complex, implementing the theme within your chart couldn’t be easier. Simply require the resource and call “setTheme” on the chart:

// Require the theme of our choosing
dojo.require("dojox.charting.themes.Claro");
// Create a chart
var chart = new dojox.charting.Chart2D("chartNode");
// Set the theme
chart.setTheme(dojox.charting.themes.Claro);

You may use any number of themes on a given page. Want to learn how to create a custom chart theme for your web application? Read Dive Into Dojo Chart Theming.

Componentes de gráficas: Plots , Ejes y Series

Definir una gráfica básica e implementar su theme es bastante simple. El trabajo real viene cuando tenemos que definir plots, ejes y series. Cada componente tiene si proposito especial.

Los Plots

Uno de los principales objetivos de los plots dentro del dojox.charting es definir el tipo de gráfica que debe ser añadida y proporcionar los valores para ese tipo especifico de chart. Los tipos por defecto que incluye dojox.charting en gráficas 2D son los siguientes:

  • Default – Universal line chart capable of rendering lines, fill areas under those lines, and placing markers at data points. This plot type is used if no plot type was specified when adding it to a chart.
  • Lines – Basic line chart. Uses Default.
  • Areas – Area under data line(s) will be filled. Uses Default.
  • Markers – Lines with markers. Uses Default.
  • MarkersOnly – Markers, sans lines. Uses Default.
  • Stacked – Data sets charted in relation to the previous data set. Extension of Default.
  • StackedLines – Stacked data sets using lines. Uses Stacked.
  • StackedAreas – Stacked data sets with filled areas under chart lines. Uses Stacked.
  • Bars – Horizontal bars.
  • ClusteredBars – Horizontal bars with clustered data sets. Uses Bars.
  • StackedBars – Stacked data sets with horizontal bars. Uses Bars.
  • Columns – Vertical bars.
  • ClusteredColumns – Vertical bars with clustered data sets. Uses Columns.
  • StackedColumns – Stacked data sets with vertical bars. Uses Columns.
  • Pie – The traditional pie chart.
  • Scatter – Similar to MarkerOnly, yet capable of charting using gradient fields.
  • Grid – For adding a grid layer to your chart.

You can see each chart type in action by visiting Dojo’s nightly charting tests.

Los Plots se añaden a las gráficas con el método addPlot, pasándole el nombre de la gráfica (generalmente “default” ) y opciones especificas del plot:

chart.addPlot("default",{
       // Add the chart type
	type: "Pie"
});

Algunas de las opciones de Plot estandars son:

  • type – The chart type (Pie, Bars, Scatter, etc.)
  • lines – Represents if lines should be added within the chart
  • markers – Represents if markers should be added to data points within the chart
  • areas – Represents if areas within the chart should be shaded
  • shadows – Represents if shadows should be added to lines within the plot (ex: {dx:4, dy:4})
  • tension – Adds curves to lines within plots for added smoothness. Values can be:
    • X – Cubic bezier lines
    • x – Similar to “X” but assumes that the point set is closed (a loop). It can be used when plotting true XY data.
    • S – Quadratic bezier lines.
  • gap – Represents the number of pixels between bars

Después cada tipo de chart puede tener sus propias opciones. El tipo Pie , por ejemplo, tiene una propiedad radius que define el tamaño del radio del chart:

// Add the default plot
chart.addPlot("default",{
	// Add the chart type
	type: "Pie",
	// Add the radius size because it's a pie chart
	radius: 200 //pixels
});

Antes de crear la gráfica, es mejor tomarse un tiempo visitando la dojox.charting Reference Guide para ver que settings especiales y customizaciones están disponibles para la gráfica que tú necesitas.

Los Ejes

La mayoría de las gráficas personalizan sus ejes x e y. Un eje puede ser horizontal (por defecto) o vertical. Los ejes son añadidos a las gráficas con el método addAxis. El siguiente trozo de código añade los ejes x  e y a una chart:

// Add the X axis
chart.addAxis("x");
// Ad the Y axis
chart.addAxis("y",{
	vertical: true // y is vertical!
});
Se pueden customizar los ejes:

// Add a custom "dw" axis
chart.addAxis("dw",{
	vertical: true,
	leftBottom: false
});

Algunas de las opciones de personalizacion de ejes mas usuales son:

  • fixUpper – Aligns chart ticks (can be “major”, “minor”, “micro”, and “none”)
  • fixLower – Aligns chart ticks (can be “major”, “minor”, “micro”, and “none”)
  • leftBottom – Determines the side of the chart the axis is placed (default is true)
  • min – The minimum number an axis can start at
  • max – The maximum number an axis can end at

You can learn more about an axis’ settings including customization of colors, fonts, stepping, and precision here.

Las Series

Este elemento es simplemente una serie de datos a ser referenciados por la chart. Las series se añaden a la chart con el método addSeries. Este método acepta estos argumentos:

  • name – The name of the series. Also represents the series label when the Legend plugin is used.
  • data – The array of data
  • options An object containing series options, which may include:
    • stroke – Color and width of lines (ex: { color:"red", width: 2 })
    • fill – Fill color of bar / line / pie piece

Añadir una serie es tan fácil como esto:

// Add a simple axis to the chart
chart.addSeries("Visits",[10,20,30,40,50],{
	stroke: {
		color: "blue",
		width: 3
	},
	fill: "#123456"
});
Series de datos con múltiples ejes sería como esto:

// Add a multi-axes data series to the chart
chart.addSeries("Visits",[
	{ x: 1, y: 200 },
	{ x: 2, y: 185 },
	// and so on...
	],{
		stroke: {
			color: "blue",
			width: 3
		},
		fill: "#123456"
	}
);

Una chart puede tener cualquier numero de series solapantes.

Eventos de Chart 

Los eventos de Chart te permiten enganchar un comportamiento a varias características de la chart, tales como las marcas en respuesta a acciones de usuarios.

Los eventos soportados son los siguientes: onclick, onmouseover, and onmouseout.

Los manejadores de eventos pueden ser enganchados a plots individuales de una chart:

chart.connectToPlot(
    plotName,    // el nombre del plot (el que se le dio cuando se creo)
    object,      // Tanto los parametros de object como el de methos son los mismos que los que se utilizan en el metodo dojo.connect()
    method       // Se puede poner una function sin object
);
El manejador del evento recibe un argumento que tiene las siguientes atributos:
Attribute Expected Value Description Since
type “onclick”, “onmouseover”, “onmouseout” differentiate between different types of events. 1.0
element “marker”,”bar”,”column”,”circle”,”slice” Indicates what kind of element has sent the event. Can be used to define highlighting or animation strategies. 1.0
x number The “x” value of the point. Can be derived from the index (depends on a chart). 1.0
y number The “y” value of the point. Can be derived from the index (depends on a chart). 1.0
index number The index of a data point that caused the event. 1.0
run object The data run object that represents a data series. Example: o.run.data[o.index] returns the original data point value for the event (o is an event handler’s argument). 1.0
plot object The plot object that hosts the event’s data point. 1.0
hAxis object The axis object that is used as a horizontal axis by the plot. 1.0
vAxis object The axis object that is used as a vertical axis by the plot. 1.0
event object The original mouse event that started the event processing. 1.0
shape object The gfx shape object that represents a data point. 1.0
outline object The gfx shape object that represents an outline (a cosmetic shape). Can be null or undefined. 1.0
shadow object The gfx shape object that represents a shadow (cosmetic shape). Can be null or undefined. 1.0
cx number The “x” component of the visual center of a shape in pixels. Supplied only for “marker”, “circle”, and “slice” elements. Undefined for all other elements 1.0
cy number The “y” component of the visual center of a shape in pixels. Supplied only for “marker”, “circle”, and “slice” elements. Undefined for all other elements 1.0
cr number The radius in pixels of a “circle”, or a “slice” element. Undefined for all other elements 1.0

Ejemplos

Line Chart: Ventas mensuales

The Monthly Sales chart is a lines chart which features multiple axes and the “Tom” theme.

<script>
// Require the basic 2d chart resource: Chart2D
dojo.require("dojox.charting.Chart2D");

// Require the theme of our choosing
//"Claro", new in Dojo 1.6, will be used
dojo.require("dojox.charting.themes.Tom");

// Define the data
var chartData = [10000,9200,11811,12000,7662,13887,14200,12222,12000,10009,11288,12099];

// When the DOM is ready and resources are loaded...
dojo.ready(function() {

// Create the chart within it's "holding" node
var chart = new dojox.charting.Chart2D("chartNode");

// Set the theme
chart.setTheme(dojox.charting.themes.Tom);

// Add the only/default plot
chart.addPlot("default", {
type: "Lines",
markers: true
});

// Add axes
chart.addAxis("x");
chart.addAxis("y", { min: 5000, max: 15000, vertical: true, fixLower: "major", fixUpper: "major" });

// Add the series of data
chart.addSeries("SalesThisDecade",chartData);

// Render the chart!
chart.render();
});
</script>

<!-- create the DOM node for the chart -->
<div id="chartNode" style="width:800px;height:400px;"></div>

View Demo

Dojo Line Chart

A line chart using the Tom theme

Stacked Areas Chart: Ventas Mensuales

Este ejemplo es una amplicación del primero pero añade un segundo eje para mostrar varios conjuntos de datos. Utiliza además el thme Dollar:

// Require the basic 2d chart resource: Chart2D
dojo.require("dojox.charting.Chart2D");

// Require the theme of our choosing
//"Claro", new in Dojo 1.6, will be used
dojo.require("dojox.charting.themes.Dollar");

// Define the data
var chartData = [10000,9200,11811,12000,7662,13887,14200,12222,12000,10009,11288,12099];
var chartData2 = [3000,12000,17733,9876,12783,12899,13888,13277,14299,12345,12345,15763];

// When the DOM is ready and resources are loaded...
dojo.ready(function() {
	// Create the chart within it's "holding" node
	var chart = new dojox.charting.Chart2D("chartNode");

	// Set the theme
	chart.setTheme(dojox.charting.themes.Dollar);

	// Add the only/default plot
	chart.addPlot("default", {
		type: "StackedAreas",
		markers: true
	});

	// Add axes
	chart.addAxis("x");
	chart.addAxis("y", { min: 5000, max: 30000, vertical: true, fixLower: "major", fixUpper: "major" });

	// Add the series of data
	chart.addSeries("Monthly Sales - 2010",chartData);
	chart.addSeries("Monthly Sales - 2009",chartData2);

	// Render the chart!
	chart.render();
});

View Demo

Dojo StackedAreas Chart

A stacked areas chart using the Dollar theme

Columns Chart: Monthly Sales

This chart builds on the original Line chart but instead uses columns. A 5-pixel gap is placed between columns; the MiamiNice theme is used.

// Require the basic 2d chart resource: Chart2D
dojo.require("dojox.charting.Chart2D");

// Require the theme of our choosing
//"Claro", new in Dojo 1.6, will be used
dojo.require("dojox.charting.themes.MiamiNice");

// Define the data
var chartData = [10000,9200,11811,12000,7662,13887,14200,12222,12000,10009,11288,12099];

// When the DOM is ready and resources are loaded...
dojo.ready(function() {
	// Create the chart within it's "holding" node
	var chart = new dojox.charting.Chart2D("chartNode");

	// Set the theme
	chart.setTheme(dojox.charting.themes.MiamiNice);

	// Add the only/default plot
	chart.addPlot("default", {
		type: "Columns",
		markers: true,
		gap: 5
	});

	// Add axes
	chart.addAxis("x");
	chart.addAxis("y", { vertical: true, fixLower: "major", fixUpper: "major" });

	// Add the series of data
	chart.addSeries("Monthly Sales",chartData);

	// Render the chart!
	chart.render();
});

View Demo

Dojo Column Chart

A column chart using the MiamiNice theme

Charting Plugins

The dojox.charting library provides functional and aesthetically pleasing plugins to enhance your forms.

Legend

Charts often include legends to further clarify the data provided within the chart. Using the dojox.charting.widget.Legend is easy: require the resource and create an instance, assigning it a chart:

<script>
	//this legend is created within an element with a "legend1" ID.
	var legend1 = new dojox.charting.widget.Legend({ chart: chart }, "legend");
</script>

<!-- create the DOM node for the chart -->
<div id="chartNode" style="width:800px;height:400px;"></div>

<!-- create the DOM node for the legend -->
<div id="legend"></div>

Tooltip

The Tooltip plugin pone luz sobre los valores que están por encima de las marcas, dependiendo del tipo de chart. Utilizando este plugin es tan facil como importar el plugin con require y crear una instancia enganchada a tu chart:

var tip = new dojox.charting.action2d.Tooltip(chart1, "default");

IMPORTANTE: Esto debe ser hecho antes de la llamada al render y después de añadir las series de datos.

NOTA: Veremos que se genera un div con estilos del tipo dijit_tooltip (http://dojotoolkit.org/reference-guide/dijit/Tooltip.html#dijit-tooltip)

MoveSlice and Magnify

Los plugins de MoveSlice y Magnify utilizan una animación para reaccionar al evento mouseover

The MoveSlice and Magnify plugins use a touch of animation to react to the mouse’s mouseover event. MoveSlice moves a pie chart piece and Magnify slightly enlarges chart markers. Both are implemented by creating a new instance and passing the chart and plot to it:

1
2
3
4
5
// Moves a pie slice: use the "pieChart" chart, and "default" plot
var slice = new dojox.charting.action2d.MoveSlice(pieChart, "default");
// Magnifies a marker: use the "chart" chart, and "default" plot
var magnify = new dojox.charting.action2d.Magnify(chart, "default");

Like the Tooltip plugin, the MoveSlice and Magnify plugins must be assigned to the chart before the render method is called on the chart.

Highlight

The Highlight plugin changes the color of an area when the mouse enters the area:

1
2
// Highlights an area: use the "chart" chart, and "default" plot
var magnify = new dojox.charting.action2d.Highlight(chart, "default");

Monthly Sales with Legend, Tooltips, and Magnify

Let’s add the Legend, Tooltip, and Magnify plugin to a line chart:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// Require the basic 2d chart resource: Chart2D
dojo.require("dojox.charting.Chart2D");
// Retrieve the Legend, Tooltip, and Magnify classes
dojo.require("dojox.charting.widget.Legend");
dojo.require("dojox.charting.action2d.Tooltip");
dojo.require("dojox.charting.action2d.Magnify");
// Require the theme of our choosing
//"Claro", new in Dojo 1.6, will be used
dojo.require("dojox.charting.themes.Claro");
// Define the data
var chartData = [10000,9200,11811,12000,7662,13887,14200,12222,12000,10009,11288,12099];
var chartData2 = [3000,12000,17733,9876,12783,12899,13888,13277,14299,12345,12345,15763];
var chartData3 = [3000,12000,17733,9876,12783,12899,13888,13277,14299,12345,12345,15763].reverse();
// When the DOM is ready and resources are loaded...
dojo.ready(function() {
// Create the chart within it's "holding" node
var chart = new dojox.charting.Chart2D("chartNode");
// Set the theme
chart.setTheme(dojox.charting.themes.Claro);
// Add the only/default plot
chart.addPlot("default", {
type: "Lines",
markers: true
});
// Add axes
chart.addAxis("x");
chart.addAxis("y", { min: 5000, max: 30000, vertical: true, fixLower: "major", fixUpper: "major" });
// Add the series of data
chart.addSeries("Monthly Sales - 2010",chartData);
chart.addSeries("Monthly Sales - 2009",chartData2);
chart.addSeries("Monthly Sales - 2008",chartData3);
// Create the tooltip
var tip = new dojox.charting.action2d.Tooltip(chart,"default");
// Create the magnifier
var mag = new dojox.charting.action2d.Magnify(chart,"default");
// Render the chart!
chart.render();
// Create the legend
var legend = new dojox.charting.widget.Legend({ chart: chart }, "legend");
});

View Demo

Dojo Chart with Legend, Tooltips, and MagnifyA line chart with a legend, tooltips, and magify enabled, using the Claro theme

Monthly Sales Pie Chart with MoveSlice

Add a bit of dynamism to your Pie Chart with MoveSlice:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// Require the basic 2d chart resource: Chart2D
dojo.require("dojox.charting.Chart2D");
// Retrieve the Legend, Tooltip, and MoveSlice classes
dojo.require("dojox.charting.action2d.Tooltip");
dojo.require("dojox.charting.action2d.MoveSlice");
// Require the theme of our choosing
//"Claro", new in Dojo 1.6, will be used
dojo.require("dojox.charting.themes.Claro");
// Define the data
var chartData = [10000,9200,11811,12000,7662,13887,14200,12222,12000,10009,11288,12099];
// When the DOM is ready and resources are loaded...
dojo.ready(function() {
// Create the chart within it's "holding" node
var chart = new dojox.charting.Chart2D("chartNode");
// Set the theme
chart.setTheme(dojox.charting.themes.Claro);
// Add the only/default plot
chart.addPlot("default", {
type: "Pie",
markers: true
});
// Add axes
chart.addAxis("x");
chart.addAxis("y", { min: 5000, max: 30000, vertical: true, fixLower: "major", fixUpper: "major" });
// Add the series of data
chart.addSeries("Monthly Sales - 2010",chartData);
// Create the tooltip
var tip = new dojox.charting.action2d.Tooltip(chart,"default");
// Create the slice mover
var mag = new dojox.charting.action2d.MoveSlice(chart,"default");
// Render the chart!
chart.render();
});

View Demo

Dojo Pie Chart with MoveSliceA pie chart with MoveSlice, using the Claro theme

Monthly Sales with Highlights

The Highlight plugin would look great with the Columns chart:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// Require the basic 2d chart resource: Chart2D
dojo.require("dojox.charting.Chart2D");
// Require the highlighter
dojo.require("dojox.charting.action2d.Highlight");
// Require the theme of our choosing
dojo.require("dojox.charting.themes.MiamiNice");
// Define the data
var chartData = [10000,9200,11811,12000,7662,13887,14200,12222,12000,10009,11288,12099];
// When the DOM is ready and resources are loaded...
dojo.ready(function() {
// Create the chart within it's "holding" node
var chart = new dojox.charting.Chart2D("chartNode");
// Set the theme
chart.setTheme(dojox.charting.themes.MiamiNice);
// Add the only/default plot
chart.addPlot("default", {
type: "Columns",
markers: true,
gap: 5
});
// Add axes
chart.addAxis("x");
chart.addAxis("y", { vertical: true, fixLower: "major", fixUpper: "major" });
// Add the series of data
chart.addSeries("Monthly Sales",chartData);
// Highlight!
new dojox.charting.action2d.Highlight(chart,"default");
// Render the chart!
chart.render();
});

View Demo

Dojo column chart with highlightA column chart with highlight, using the MiamiNice theme

Conclusion

The Dojo Toolkit provides a complete charting library capable of creating elegant, eye-catching, and dynamic charts of various types. dojox.charting is unmatched by other charting libraries in flexibility, functionality, and extendability. Don’t serve your data to users in a boring way — dress up your data with dojox.charting!

dojox.charting Resources

Looking for more detail about Dojo’s charting library? Check out these great resources:

Capitulo 2: Tu primera aplicación en Java para Android

Después de finalizar todos los pasos de la primera parte de este tutorial, referentes a la instalación de todos los elementos necesarios para el desarrollo de aplicaciones para nuestro dispositivo Android, vamos a pasar a hacer la primera. Va a ser un ejemplo muy sencillo.Los programadores tienen la manía, desde tiempos inmemoriales, de que la primera aplicación que hacen para un nuevo lenguaje de programación que están aprendiendo, sea un “Hola mundo”.

Creación de un nuevo proyecto en Eclipse

En primer lugar tendremos que abrir nuestro Eclipse, que como ya habíamos dicho va a ser el entorno de desarrollo que vamos a utilizar para nuestras aplicaciones Android. Una vez aquí, creamos un proyecto nuevo de la siguiente manera:

  • Nosotros queremos crear un nuevo proyecto Android, así que vamos a “otros”. Nos aparecerá el siguiente diálogo, donde veremos una carpeta llamada “Android”, y seleccionaremos nuevo proyecto android.
  • Cuando le damos a siguiente, nos aparecerá un nuevo diálogo donde tendremos que fijar algunas de las propiedades de nuestro proyecto. Vamos a verlo:
    • Project Name: El nombre que le vamos a dar a nuestro proyecto, y por el que podremos reconocerlo dentro de Eclipse. En este caso lo llamaremos HolaMundo
    • Contents: Aquí querrá que le digamos si vamos a crear un proyecto desde cero, o queremos usar algún tipo de código que ya tengamos escrito de antemano, y donde almacenarlo. En default location os pondrá la ruta de vuestro workspaceindicado durante el primer inicio de Eclipse, y no es más que la ruta en vuestro disco duro donde se va a almacenar el proyecto
    • Build Target: Aquí seleccionaremos la versión de sistema operativo que vamos a utilizar. Hay cosas, como por ejemplo Text-To-Speech, que solo están disponibles a partir de la 1.6, cosa a tener en cuenta en el futuro. Tampoco es “paseis” por arriba, ya que entonces no funcionará en dispositivos con versión menor
    • Application name: El nombre que va a tener nuestra aplicación, que será visible, por ejemplo, en el menú de aplicaciones de Android entre otros sitios
    • Package name: El código va a estar ordenado en paquetes, cosa que de momento nos va a dar bastante igual, y os basta con saber que por convenio, suelen empezar por letra minúscula
    • Create Activity: Vamos a marcar esta opción para que nos cree la primera clase, donde nosotros vamos a escribir nuestro código
  • Ya estamos listos para finalizar con este asistente y darle a finish. En este momento, eclipse nos crea toda la estructura necesaria de ficheros y directorios para nuestra aplicación, y vemos lo siguiente:
    • A la izquierda, en “Package explorer”, podemos ver la estructura de nuestro proyecto Android. Nos basta con saber dos de las carpetas:
      • src: Aquí es donde van a ir las SouRCesfuentes de nuestros programas, es decir, el código que nosotros vamos a escribir
      • res: Aquí es donde van los RESources o recursos de nuestros programas, tales como imágenes, sonidos, y las pantallas.
    • A la derecha podemos ver que he abierto la clase HolaMundoActivity.java, que es la activity que le dijimos que crease cuando creamos nuestro proyecto.Esta es la actividad que va a ser llamada cuando arranque nuestro programa, es decir, este es el trozo de código que se va a ejecutar primero en nuestra aplicación. Se va a crear un objeto, en este caso no es un microondas, si no un “HolaMundo” que de momento, va a tener definida una única funcionalidad, onCreate, que lo que va a hacer es definir lo que tiene que hacer cuando se crea, es decir, cuando lo arrancamos.

HolaMundoActivity.java

package com.jes;

import android.app.Activity;
import android.os.Bundle;

public class HolaMundoActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Programando código de nuestra cosecha

Vamos a añadirle un par de propiedades a nuestra clase, unos atributos, que en este caso van a ser el texto que va a mostrar, y el color, por ejemplo.

De esta manera es como le diremos a nuestro programa, que interfaz, que vamos a crear ahora, tiene que utilizar para, en nuestro caso, mostrar nuestro hola mundo.Y a ese método le estamos pasando R.layout.main refiriéndonos a:

  • R: La forma de referirnos a los recursos (res) que tiene nuestro programa
  • layout: Se trata de una interfaz de usuario, que como veremos ahora, están dentro de /res/layout
  • main: Este va a ser el nombre del fichero que vamos a crear para nuestra interfaz.
  • <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:orientation="vertical" >
    
        <TextView
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="@string/hello" />
    
    </LinearLayout>

Como veréis, Eclipse ya nos lo crea inicialmente

  1. Abrimos nuestro main.xml que como dijimos está en /res/layout (donde, recordemos, vamos a guardar las interfaces gráficas) y nos sale esto en la pantalla
  2. Hay una pestañita llamada main.xml, al lado de Graphical Layout. Le damos ahí, y vemos lo siguiente:
    1. Este textview va a ser un objeto, con sus atributos y métodos que nosotros vamos a utilizar para mostrar un texto.Vamos a darle un identificador, para poder referirnos a el desde nuestro programa: Lo haremos simplemente añadiendo esa línea, de la cual ya explicaremos la sintaxis en capítulos posteriores.
    2. <?xml version="1.0" encoding="utf-8"?>
      <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
          android:layout_width="fill_parent"
          android:layout_height="fill_parent"
          android:orientation="vertical" >
      
          <TextView
              android:id="@+id/cajatexto"
              android:layout_width="fill_parent"
              android:layout_height="wrap_content"
              android:text="@string/hello" />
      
      </LinearLayout>
  3. Vámonos ahora de nuevo a nuestro programa principal, y vamos a realizar lo siguiente: Pedir la caja de texto, fijarle el texto, y fijarle el color.Para ello lo haremos así:
    1. Vamos a ver que son estas dos líneas que he añadido:
      1. TextView tv : Creamos la referencia a un objeto de la clase TextView, que es el elemento que tenemos en nuestra interfaz para mostrar nuestro texto.
      2. (TextView) findViewById(): findViewById es, de nuevo, un método que heredamos de activity, y que lo que hace es encontrar una “view” dándole nosotros su identificador (el que acabamos de fijar en el XML).
      3. R.id.cajatexto: Como ya dijimos antes, R (res), id (buscamos un identificador), cajatexto (el nombre que le hemos dado al identificador de nuestro TextView en el XML)
  4. Hacemos los import necesarios y ya tenemos un objeto TextView, llamado tv, que se refiere al TextView de nuestra interfaz. Vamos a decirle que y como queremos mostrar
  5. package com.jes;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.widget.TextView;
    
    public class HolaMundoActivity extends Activity {
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
    
            TextView tv = (TextView)findViewById(R.id.cajatexto);
        }
    }
  6. Nuestro TextView iba a tener unas funcionalidades para fijarle el texto que queremos mostrar, así como el color del mismo (entre otros muchos, por si queréis investigar).Pues así lo hacemos, pasándole nuestras variables definidas anteriormente, llamadas textoMostrar y colorTexto
  7. package com.jes;
    
    import android.app.Activity;
    import android.graphics.Color;
    import android.os.Bundle;
    import android.widget.TextView;
    
    public class HolaMundoActivity extends Activity {
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
    
            TextView tv = (TextView)findViewById(R.id.cajatexto);
    
            tv.setText("Hola Caracola!!!!");
    
            tv.setTextColor(Color.YELLOW);
    
        }
    }
  8. Ya estamos listos para ejecutar nuestra aplicación. Vamos a ello:Le damos ahí, en la barra superior a ese “Play” verde.La primera vez que ejecutemos nuestra aplicación, nos preguntará como queremos ejecutarla. Le decimos que se trata de una aplicaciónAndroid, y le damos a OK.Si no habíais guardado los ficheros que habíamos modificado, os preguntará si guardarlos, le decís quesi, y os va a arrancar el emulador del teléfono móvil android. Como dijimos en el primer capítulo, tardará un poco más o menos, en función del ordenador que estéis utilizando. Tened paciencia.Esperamos unos segundos y…

NOTA: Es posible que tengáis que primero desploquear el emulador para que salga la ejecución de la aplicación, en mi caso tengo que desplazar un candado hacia la derecha

Ahí está. Vuestra primera aplicación Android funcionando!

Cómo empezar a desarrollar para dispositivos móviles con Android

(Fuente: http://www.paratuandroid.com/Desarrollo/como-empezar-a-desarrollar-aplicaciones-para-dispositivos-moviles-con-sistema-operativo-android-capitulo-1-introduccion-y-requisitos.html)

Capítulo 1. Introducción y requisitos

En este capítulo dejaremos nuestro equipo preparado con todo lo necesario para adentrarnos en el gratificante mundo del desarrollo.

Una de las grandes cualidades, a veces poco destacada, de los dispositivos móviles con sistema operativo Android, tales como smartphones y tablets, es la libertad y facilidades que sus creadores han dado al usuario medio-avanzado para el desarrollo de aplicaciones propias.

Si bien esto requiere de ciertas habilidades de programación, muchas de las funcionalidades ya nos las dan programadas, y solo hay que hacer llamadas a sus funciones. Te preguntarás, ¿puedo yo desarrollar una aplicación para android? La respuesta es sí. Ahora solo queda saber cuánto puedes abarcar.

1.1.Requisitos

Para desarrollar una aplicación básica para android, como veremos, vamos a necesitar lo siguiente:

Sin conocimientos en absoluto de programación, esta tarea puede hacerse más tediosa, pero cuando consigáis hacer funcionar vuestras aplicaciones, será mucho más gratificante.

1.2.Integración

Ya podemos proceder a la integración de Android con nuestro entorno de desarrollo. Para ello, abrimos nuestro Eclipse, y seguiremos los siguientes pasos:

  • Pulsamos arriba, en ayuda, y ahí en Instalar nuevo software
  • En la nueva ventana de dialogo que se abre, pulsamos en la parte superior, en Añadir
  • Se abre un formulario que nos pide, nombre y dirección. Como nombre le daremos ADT Plugin y en la dirección le pondremos los repositorios de google: https://dl-ssl.google.com/android/eclipse/
  • Le damos a OK, y cuando acabe de pensar, marcamos en el cuadro de software disponible el checkbox de Developer Tools
  • Cuando le damos a siguiente nos dirá todo lo que va a bajar, seleccionamos todo, le damos a siguiente, aceptando todas las licencias, y al cabo de un rato de espera, ya tendremos todo instalado
  • Una vez ha terminado de instalarlo, reiniciamos nuestro Eclipse.

Ya solo nos queda decirle donde hemos instalado nuestro SDK de Android:

  • Seleccionamos arriba Ventana –> Preferencias
  • En la barra izquierda seleccionamos Android
  • Donde nos pregunta por el SDK Location buscamos la carpeta donde lo hemos descomprimido / instalado
  • Aplicamos los cambios, y hemos terminado.

1.3.Creación de dispositivos virtuales

En este punto, ya tenemos un entorno de desarrollo funcional para nuestras aplicaciones Android. Podemos pasar a crear un nuevo dispositivo virtual en el que probaremos nuestros programas. Esto será un teléfono Android perfectamente funcional ejecutándose en nuestro ordenador.

Vamos a la carpeta de nuestro SDK de Android, en tools, y arrancamos el ejecutable android.exe.

La primera vez que lo arrancamos, no tenemos ninguna versión de Android instalada, por lo que seguiremos los pasos que nos indica para actualizarlo y descargar los sistemas operativos. Aunque solo queráis programar para una versión, yo os recomendaría decirle que baje todas, ya que nos es mucho problema el tamaño que ocupan, y luego podemos elegir. Habiendo actualizado, ya podemos crear un nuevo dispositivo.

Aquí depende mucho de lo que queramos hacer con nuestras aplicaciones, aunque no es problema si dejáis algo atrás, ya que posteriormente se le puede añadir todas las funcionalidades que se desee.

  • Nos ponemos en Virtual Devices y le decimos que queremos crear uno nuevo
  • Le podéis dar el nombre que os venga en gana, no es más que un identificador
  • En Target es donde vamos a seleccionar el sistema operativo que va a tener nuestro dispositivo. Aquí hay que tener unas cuantas cosas en cuenta, como por ejemplo, que algunas de las funcionalidades de 2.3, por ejemplo, no se encuentran disponibles en 1.5. Otra cosa a tener en cuenta es si vamos a querer utilizar Google Maps en nuestra aplicación. Si es así, tendremos que seleccionar la versión que corresponda, pero la línea que pone Google API
  • Si vuestras aplicaciones van a utilizar la tarjeta SD del teléfono, podéis marcarle ahí el tamaño que le vais a dar para utilizar en vuestro dispositivo virtual
  • En Skin vamos a decirle que tipo de pantalla tiene nuestro teléfono, pudiendo escoger entre las más utilizadas sin necesidad de darle nosotros la resolución
  • Y en Hardware le vamos a decir que funcionalidades va a tener nuestro dispositivo, tales como GPS, acelerómetros, etc. etc. Como ya hemos dicho, añadid las que creáis que necesitáis, sin preocuparos si dejáis alguna, ya que posteriormente se puede editar y añadir a vuestro antojo
  • Le damos a Crear y ya tenemos nuestro móvil virtual sobre el que probar las aplicaciones. Podéis probarlo dándole a Start. Tened en cuenta, que en función del ordenador que tengáis, puede llegar a tardar 3-4 minutos en arrancar.

Ya tenemos todo listo. Un entorno de desarrollo perfectamente funcional para programar nuestras propias aplicaciones Android de manera 100% gratuita y libre. En el próximo capítulo veremos cómo empezamos a programar una sencilla aplicación y la ejecutamos tanto en el emulador, como en un teléfono móvil.

La mano trémula

– Hay un momento en el que se confabulan las ciscunstancias adversas , se acumulan las preocupaciones y las exigencias no dejan de aumentar. Nuestro sistema nervioso se fuerza mas alla de nuestras posibilidades (quizas las hemos sobreestimado).

– En este contexto se nos presenta una situacion social en el que nuestra mano ha de estar expuesta a la vista , como al hacer un pago o al tocar la guitarra.
LA MANO TIEMBLA!!

– Una mano rebelde, que no cesa de temblar a pesar de nuestros esfuerzos.

– Las conductas evitativas como retrasar el momento , disimulos , etc. Solo hacen admitir y persuadir de la incapacidad de controlarlo. Se convence de que nada puede hacer (salvo beber copas o tomar farmacos) —> FALACIA DE IMPOTENCIA.

– Lo que se puede hacer :
1. No hacerse peliculas de terror antes de tiempo.
2. No hacer maniobras evitativas . Mas que huir . Buscar alternativas o conductas nuevas (bromear , hacer comentarios ,etc)
3. Diagnosticar ‘TENGO MIEDO’ en vez de tiembla mi mano.
4. Hacer el acto suave , sin presion y a un ritmo agradable , recrearse , entretenerse con la accion.
5. Da buenos resultados interrelacionarse mientras hacemos los movimientos. …Me gusta mucho como ha quedado … Espero este satisfecho … Eso que me dices me recuerda …
Ademas de hablar conviene mirar a los ojos a los presuntos censuradores para ver si simpatia tranquilizadora.
6. Respiracion profunda y consigna de aflojar los musculos . Ayuda a coger un camino llano en vez de accidentado.
7. Hacer algo normal con suavidad como atarse los zapatos , abrir carpeta para tomar apuntes , coger una servilleta , dar un toquecito en el hombro a un conocido , que todo se haga a camara lenta.
8. Sostener la mirada y prestar atencion directa a los otros como si estuviera interesado enormemente. Procurar centrar la atencion en los asuntos tratados respondiendo a preguntas guion como : ‘que me parece lo que dice’ , ‘que es lo mas discutible’ …
9. Perseverar. No jugarselo todo a una carta. Si de 10 , salen 5 es una buena noticia.
10. No recurrir a la bebida como solucion.
11. Mejorar nuestra asertividad , espontaneidad y autopromocion para lograr un enfoque distinto a nuestras acciones.
12. Expresarnos de una forma mas atrevida (en vez de apocada y acomplejada) ante las personas que mas nos impresionan.
13. Buscar asesoramiento profesional.

Mandamientos eternos

  • Prefiero molestar con la verdad que complacer con adulaciones.
  • Cuanto más planifique el hombre su proceder más fácil le será a la casualidad encontrarle.
  • Culto es aquel que sabe donde encontrar lo que no sabe.
  • No hay secreto para el exito.Éste se alcanza preparandose, trabajando arduamente y aprendiendo del fracaso.
  • Cuando algo importante esta sucediendo guardar silencio es mentir.
  • La soledad es un buen refugio, pero no para quedarse en él.
  • Conservarás tu juventud mientras sigas aprendiendo, adquiriendo nuevos hábitos y aceptando que te contradigan.
  • No hagas que el oficio altere tu alma.
  • Educad a los niños y no será necesario castigar a los hombres.
  • He aqui la prueba para verificar si tu misión en la tierra ha concluido: si estás vivo no ha concluido aún.
  • El pasado debe ser un trampolín, no una hamaca.
  • Estudia como si fueras a vivir para siempre, vive como si fueras a morir pronto.
  • A tu amada: -“Eres la única mujer que me gustaría ser”-.
  • Los ojos de ver son los del corazón. Cuando cierras los ojos puedes ver lo que quieras.
  • Una vez me crucé con un viejo recluso que me señaló a los tipos que jugaban a la pelota, y me dijo: “¿Ves a esos tios? Cuando salgan harán el imbecil, y volverán pronto, ¿quierés que todo esto te sirva de algo? Ve a la biblioteca, lee libros, haz trabajar tu mente.”. Y tenía razón.
    • Mike Tyson (ex-campeón del mundo de los pesos pesados).

Hipocresia

Repele el nombre y la realidad.Se aparta uno del hipócrita reconocido como tal, como se guarda del enfermo declarado contagioso.Sin embargo las relaciones humanas estan penetradas en buena medida de la hipocresía.

Es hipocresía el disimulo de intenciones, los halagos en presencia y la crítica despiadada a las espaldas.Es hipocresía la promesa que sabemos que no vamos a cumplir. Es hipocresía ocultar cuidadosamente los defectos de la mercancia que ofrecemos como inmejorable y cantar de ella unas excelencias que sabemos que no tiene.Es hipocresía, y reviste en ocasiones particular malicia. mostrar solo el lado mas favorable, cuando es de justicia la manifestación completa de la personalidad y de las propias circunstancias.

Queremos que los demas nos tengan por mejores de lo que somos en cualquiera de las líneas de la perfección humana.Sabemos cuidar muy bien los detalles para lograrlo.No caemos en la cuenta de que todo eso es hipocresía, si no lo acompaña un esfuerzo sincero y constante para hacer realidad lo que deseamos que piensen de nosotros los demas.

WordPress: ficheros de template para categorias

[Fuente: http://codex.wordpress.org/Category_Templates]

Introducción

Desde que llegaron los Themes en WordPress 1.5,  cambiar el look and feel de tu web WordPress se ha hecho muy versatil. Por ejemplo, cuando un visitante de tu web hace click en un link de una de las categorias de tu site, es llevado a una page que lista los Posts de esa categoria en particular en orden cronológico empezando por el último. Hay muchas posibilidades de visualizacion, desde incluir el post completo a solo resumenees, y que información adicional (titulo, autor, fecha de publicacion, hora de la ultima modificacion, etc). Cada Theme tiene elecciones diferentes y tu querrias saber cambiarlas.

En este articulo se explica como cambiar lo que sucede cuando el visitante de tu blog esta visitando las páginas de categoria de tu web.Esto inclute hacerlo utilizando los ficheros de template.

Qué fichero de Template utilizamos?

El primer paso para modificar lo que sucede cuando alguien visita la pagina de una categoria es averiguar cual de los ficheros del theme va a ser utilizado para mostrar los posts. Esto viene en Template Hierarchy.

En el caso de las categorias, la jerarquia es muy simple. Por ejemplo, supongamos que el ‘slug’ de la categoria es ‘news’ y el Id de la categoria es 6. Entonces el Template Hierarchy especifica que WordPress utilizará el primer fichero de template que encuentre en la carpeta del theme de los siguientes:

  1. category-slug.php (Note: available with Version 2.9)
  2. category-ID.php
  3. category.php
  4. archive.php
  5. index.php

Asi , siguiendo con el ejemplo , si no existe category-news.php , WordPress mirará que haya un category-6.php y asi.

Con category.php cambias el look de todas las categorias.

Con archive.php cambiamos el look de todas las páginas archivadas.

Cambiando el index.php cambias el look de todo el blog.

Si necesitas crear un nuevo fichero, es una buena idea empezar haciendo una copia del siguiente fichero en la jerarquia. Por ejemplo, si queremos un look especial para la categoria 6 , empezamos por hacer una copia del fichero category.php, si este no esta, del archive.php y asi.

Ejemplos

En estos ejemplos , cuando decimos ‘edita el fichero de template’ nos referimos a editar el fichero que se ha elegido en el apartado anterior.

Añadiendo texto a la Category Pages

Texto estático sobre los Posts

Supongamos que queremos mostrar texto estático antes de la lista de posts en la category page. Por estático queremos decir que el texto permanece el mismo, no importa que posts sean mostrados debajo, y es para todas las categorias. Para hacerlo:

Encima de la seccion Loop (The Loop) del fichero de template en el que estes, inserta el siguiente código (no tiene misterio):

<p>This is some text that will display at the top of the Category page.</p>

Texto distinto en algunas paginas de categoria

A slightly more complex possibility is that you want different text to display depending on which category page the visitor is viewing. Then you would add the “default” text to the main category.php file, and create special category-#.php files (with their own version of the text, as described in the Introduction) for each category that needs special text at the top.

This does however create a lot of files in your theme directory, and can be avoided using the following code OUTSIDE the loop:

<?php if (is_category('Category A')) : ?>
<p>This is the text to describe category A</p>
<?php elseif (is_category('Category B')) : ?>
<p>This is the text to describe category B</p>
<?php else : ?>
<p>This is some generic text to describe all other category pages,
I could be left blank</p>
<?php endif; ?>

This does the following. Checks to see if we are looking at Category A, if we are then show the first bit of text, but if we’re not then check if we are looking at Category B. If we are then show that bit of text, and finally, if it is neither Category A or B, then show this default text.

Text Displaying Only on First Page of Archive

Another thing that can happen is that if your Category contains more posts than will fit on one page (according to the Options for Blog Reading you have set in the Administration panels of your blog), the category archive will split into multiple pages. And maybe you only want to display your static text if the viewer is on the first page of results, or you want to display different text for the other pages.

To make this happen, you can use a PHP if statement, which looks at the value of the $paged WordPress variable ($pagedis equal to the page number: 1 for the first page of results, 2 for the second page, etc.). It may sound complicated, but it’s actually not too bad. Just put the following above The Loop:

<?php if ( $paged < 2 ) : ?>
<p>Text for first page of Category archive.</p>
<?php else : ?>
<p>Text for subsequent pages of Category.
Can be left out.</p>
<?php endif; ?>

Category Name

Another possibility is to put the category name at the top of the page. If this is not already part of your template, you can add it by doing something like this, above The Loop:

<p>Category: <?php single_cat_title(); ?></p>

Modificando como los Post son mostrados

Excerpts vs. Full Posts

Perhaps you are looking to cut down on the size of your Category pages. You could do this by displaying excerpts rather than the entire content of each Post. To do this, you will just need to find where it says the_content() inside The Loop in your Template, and replace it with the_excerpt(). These will most likely be inside PHP tags:

  <?php the_excerpt(); ?>
and
  <?php the_content(); ?>

Conversely, if your Theme is currently displaying excerpts and you want full posts, replace the_excerpt with the_content.

Display Images Linking to Full Posts

Another thing that is interesting to do in a category archive page is to replace the post content with an image that links to your post. To do this, you will first need to put images into the Excerpt sections of your posts. Here’s how to do that, for one post:

  1. Upload an image on the post editing screen.
  2. Switch to the “Code” editor, rather than the “Visual” editor.
  3. Use the Uploads / Browse tab to insert the image into your post. Make sure to insert the full-sized image, with no link.
  4. Copy the inserted HTML img tag, and paste it into the “Optional Excerpt” section of the post editing screen.
  5. Finish writing the post content (you can remove the image), and publish the post.

Now you will need to modify your template. We’ll use a trick: the the_excerpt_rss() Template Tag does not put a paragraph tag around the excerpt. So we can use it to insert the img HTML and put it inside a link. Here’s what you need to put into your Template, in place of using the_content:

<a href="<?php the_permalink() ?>">
<?php the_excerpt_rss(); ?>
</a>

Caveat: using the excerpt this way may affect your RSS feed, because it places an img tag in the excerpt, instead of text. So if you are going to do this, you probably want to set your options so that the full posts are put in RSS feeds, rather than excerpts.

What categories do you show to the visitors?

You can limit the categories in archive and other pages with this code:

<?php query_posts('cat=1&posts_per_page='.get_option('posts_per_page')); ?>

This is placed before the Loop.

query_posts documentation: http://codex.wordpress.org/Template_Tags/query_posts

The get_option('posts_per_page') part of the code uses your blog’s options to show a limited number of posts.

This code is very useful if you would like to separate the categories. With this code you can make multiple archives. For example:

<?php if (have_posts()) : ?>
 <?php if (is_month()) {query_posts('year='.get_the_time('Y').'&monthnum='.get_the_time('m').'&author_name=admin&cat=1&posts_per_page='.get_option('posts_per_page')); ?>
  <!-- Do stuff... ->
 <?php } ?>
 <?php while (have_posts()) : the_post(); ?>
  <!-- post's contents -->
 <?php endwhile; ?>
<?php endif; ?>

If you use this code in archive.php and navigate to http://yourblog.com/2008/02/, it will show you the admin user’s post that is posted on 2008.02. in the “first” category.

Further Reading