6 – Introducción a los Windows Forms

1. Resolución del ejercicio del capítulo anterior

Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5.

Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, recordemos el enunciado:

Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máximo de pasajeros permitido y tu sistema debe permitir lo siguiente:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Solución:

Muy bien, vamos a empezar haciendo el truco que te enseñé en el capítulo anterior y vamos a determinar que clases necesitamos, con que atributos y que métodos. Empecemos con las clases, recuerda que para ello hemos de buscar sustantivos:

Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máximo de pasajeros permitido y tu sistema debe permitir lo siguiente:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Empecemos por “sistema”, el sistema de seguridad es lo que nos piden montar, aquí podemos hacer dos cosas: desarrollar el sistema como una clase, o obviarlo y meter toda nuestra lógica directamente en el formulario… Había pensando en obviarla pero la voy a tener en cuenta para que veas que esto puede ser tan flexible como tu quieras. Seguimos por “ascensor”, que es el elemento principal de éste ejercicio. Si te fijas todo gira en torno al ascensor (es por ello que decía que podíamos obviar la clase “sistema”) por lo que podemos decir que “ascensor” es la clase fuerte o dominante.

Nos queda la clase “pasajeros”, nos la apuntamos también.

Vamos a buscar ahora atributos, recuerda que es todo aquello que denote algún tipo de propiedad o descripción ya sean adjetivos o pequeños sintagmas:

Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máximo de pasajeros permitido y tu sistema debe permitir lo siguiente:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Bien, sencillo hace referencia al sistema de seguridad y nos indica que el problema es fácil, no hace falta comerse mucho la cabeza para ver que nos lo podemos pasar por el forro. Lo siguiente tiene más chicha, “número máximo de pasajeros” no es un adjetivo pero sí que define una propiedad del ascensor, nos está dando información detallada del mismo así que podríamos tomarlo como un parámetro.

Esto no siempre es infalible ni tampoco claro, ante la duda te recomiendo que lo tengas en cuenta y sobre la marcha te darás cuenta que sobra… siempre es mejor que sobre que no que falte 😉

Fíjate que he marcado “el límite de pasajeros permitido”, “la cuenta de pasajeros que entran” y “la cuenta de los pasajeros que salen”. El primero ya lo hemos tenido en cuenta, pero los otros dos nos dan una pista de que vamos a necesitar un contador de pasajeros, por tanto necesitamos otro atributo.

Por último los métodos, suelen ser verbos o acciones:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

¿Bastante fácil esta parte no? Lo cierto es que intenté que el enunciado fuera sencillo y fácilmente analizable, si no lo he conseguido me lo tengo que hacer mirar :p

¿Que tenemos hasta ahora? Agarra papel y lápiz (tus dos mejores amigos) y hagamos recunto:

  • Tres clases: “sistema”, “ascensor” y “pasajero”.
  • Dos atributo de “ascensor”: el “número máximo de pasajeros” y “los pasajero que hay montados”
  • 4 métodos para el sistema de seguridad:
  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Si te fijas, la clase “pasajero” se nos ha quedado sin atributos ni métodos, de hecho lo único que vamos a hacer es contar pasajeros, por lo que son más bien un atributo y no una clase así que no la tendremos en cuenta.

Te recomiendo siempre que vayas de dentro hacia afuera, como el sistema de seguridad es el que maneja ascensores vamos a empezar por ascensor, programemos:

6.1.solucion1

Aquí tienes mi clase Ascensor, que he creado en un fichero nuevo llamado “Ascensor.cs” y tiene los dos atributos que hemos visto antes.

Vamos ahora con la clase Sistema:

6.2.solucion2

El constructor de Sistema crea el ascensor. El resto de métodos nos permiten hacer lo que nos pide el enunciado: establecer el número máximo de pasajeros, llevar la cuenta de los que entran y salen (es decir, poner y quitar) y mirar si el límite está sobrepasado.

El atributo “_ascensor” lo que puesto como private para que no sea visible desde fuera de “Sistema”, lo del guión delante es una manía mía que me ayuda a identificar rápidamente que atributos son públicos y cuales privados… no es esencial pero a mi me resulta útil.

Con esto habríamos resuelto el ejercicio pero creo que es una oportunidad perfecta para enseñarte la importancia de los atributos y métodos privados.

2. La importancia de los atributos y métodos privados.

Imagina que le entregamos a un cliente esta clase tal cual la tenemos programada y la empieza a usar en sus sistema de seguridad para ascensores. Nos dice que gracias a nuestro trabajo ha desarrollado un sistema de alarma que le avisa si el ascensor está en peligro de sobrecarga.

Como gracias a nuestro trabajo no ha de preocuparse de que el ascensor se caiga nos va a pagar un pastizal, pero también nos advierte de que si algo sale mal nos va a tirar a sus abogados para que nos quiten hasta los dientes.

Si código es el que sigue:

6.3.solucion3

Como puedes ver el tío tiene razón, ha usado nuestra clase Sistema para montar un sistema de alarma, su méetodo PasajeroEntra le retorna un booleano que le dice si se ha sobrepasado el límite de ocupación o no (que está inicialmente establecido en 4).

¿Te das cuenta de lo que ha hecho este pedazo de imbécil? ¡El tío incrementa el número máximo de pasajeros cuando se supera el límite y se queda tan tranquilo! ¡¡Esta alarma nunca va a sonar!! ¡¡¡Nos va a echar la culpa a nosotros!!!

Vale, es un ejemplo un poco bestia pero toda esa gente va a morir porque nosotros le hemos dejado usar nuestro sistema de seguridad como le ha dado la gana y eso, precisamente, no es seguro… Vamos a hacer un par de cambios:

6.4.mejora1

Ahora nuestro método SetMaxPasajeros es privado y no se puede llamar desde fuera, en cambio el máximo de pasajeros se le pasa a la constructora que sí puede llamar al viejo método SetMaxPasajeros.

¿Que hemos conseguido ahora? Justamente esto:

6.5.mejora2

El tío ya no puede hacer lo que hacía, porque los métodos que quiere tocar ya no son accesibles y por ello se ve obligado a cambiar el código de la siguiente forma:

6.6.mejora3

Se ve obligado a establecer el máximo desde un inicio y ya no lo puede cambiar dentro de nuestro “Sistema” aunque el muy burro lo cambie fuera. Con éste sencillo cambio nuestro sistema ha dado la alarma cuando debía sin sufrir manipulaciones externas… siempre y cuando sea verdad que el ascensor aguanta a 4 personas…

3. Contenido del capítulo

Ya sé que siempre pongo esto en el punto 2 pero esta vez se me ha ido al 3…

  • Introducción a Windows Forms
    • Controles
    • Propiedes
    • Eventos
  • Resolución de un ejercicio de ejemplo
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

Como puedes ver lo prometido es deuda y hoy vamos a hablar de ventanitas, botoncicos 🙂

4. Introducción a Windows Forms

Windows Forms es el nombre que reciben las aplicaciones desarrolladas con Visual Studio que muestran ventanas con botones, menús, campos de texto, etc. Hasta la fecha hemos estado creando aplicaciones de éste tipo pero solamente hemos visto el código, hasta hoy.

Ha llegado el momento de echar un vistazo al fichero “Form1.cs” en su vista de diseño, puedes usar el mismo proyecto que usamos para la calculadora porque nos va a ir de lujo para lo que te quiero enseñar. Si lo abres deberías ver algo como esto:

6.7.forms1

Seguro que lo recuerdas de sesiones anteriores, era esa ventana donde no podíamos tocar nada excepto hacerla más grande. Pues ese es nuestro formulario y es donde vamos a aprender a usar éstos elementos.

4.1. Controles

Lo primero que vamos a hacer es poner un cuadro de texto en éste formulario, para ello desplegamos el “cuadro de herramientas” (a la izquierda) y, dentro de “Controles comunes”,  escogemos “TextBox” haciendo clic. 6.8.forms2

Lo siguiente que has de hacer es dibujar el cuadro de texto sobre el formulario, verás que el cursor ha cambiado de forma al escoger el TextBox así que lo único que tienes que hacer eshacer clic sobre el formulario. Esto hará que aparezca una hermosa y flamante caja de texto vacía.

6.9.form3

 

Verás que la puedes hacer más grande si arrastras los cuadritos blancos de los laterales (aparecen al hacer clic sobre la caja), que la puedes mover si la arrastras, etc. Hasta aparecerán unas guías que te ayudarán a colocarla de forma más cómoda dentro del formulario. Por ahora vamos a hacer que quede de una forma parecida a ésta:

6.10.forms4

4.2. Propiedades

Ahora haz clic sobre la caja para seleccionarla y fíjate en el panel de propiedades abajo a la derecha:

6.11.form5

¿Chulo eh? Esas son todas las propiedades de nuestro TextBox y la mitad no las vamos a tocar en nuestra puta vida. En el listado puedes ver que su nombre es “textBox1”, que su posición es la “12;12” (al menos en mi caso, si en el tuyo es diferente no pasa absolutamente nada) o que sus modificadores son privados (¿te suena?). Vamos a hacer una cosa, vamos a buscar una propiedad que se llama “Text” y vamos a escribir “Hoy estoy chichinabesco” y ni se te ocurra escribir algo diferente o mataré a un gatito.

6.12.form6

Y ahora mira de nuevo tu formulario para contemplar asombrado como ha aparecido ese texto dentro del TextBox.

6.13.form7

Ahora dale al play, verás que aparece esta misma ventana y que podemos jugar con ella y, por supuesto, también podemos modificar el texto que hemos escrito. ¿Por que ocurre esto? ¿Que está pasando? Es muy fácil:

El TextBox que has dibujado, aunque el Visual Studio te lo muestra así en realidad no es más que un objeto, una clase de tipo “TextBox” muy parecida a nuestra clase “Calculadora” pero bastante más compleja. Esta clase “TextBox” tiene sus propios métodos y atributos y uno de ellos es precisamente “Text” que se encarga de almacenar el texto que se ha de mostrar.

 Ahora vamos a añadir un botón a nuestro formulario, repetimos los pasos anteriores pero escogemos “Button” y lo ponemos más o menos así:

6.14.form8

Si haces clic sobre el botón y miras el panel de propiedades verás algo muy parecido a antes, vamos a cambiar la propiedad “Text” y pondremos un texto cualquiera… me siento tán generoso que te dejo elegir XD. Como podrás ver ocurre lo mismo, el texto que sale en el botón ha cambiado.

4.3. Eventos

Ahora quiero que te fijes en el panel de propiedades y busques el símbolo de un rayo, si le haces clic pasarás a ver los eventos del botón (la hojita de la izquierda son las propiedades que veíamos antes, el rayo son los eventos):

6.15.fomr9

Aún no hemos hablado de eventos pero son muy sencillos de entender. Un evento es una especie de método que se ejecuta cuando se produce una situación concreta. Por ejemplo, el evento “Click” de éste botón se ejecuta cuando el usuario le hace clic.

 Vamos a hacer doble clic sobre el texto “Click” y veremos que por automagia se nos ha creado un método click listo para programar:

6.16.form10

Sea lo que sea lo que programes aquí dentro se ejecutará cuando el usuario haga click en el botón. Para demostrarlo vamos a cambiar el texto de la caja de texto que hemos usado antes.

6.17.fomr11

Si recuerdas bien, el TextBox que hemos creado se llamaba “textBox1” (porque no le hemos cambiado el nombre), si lo escribes y le das al punto Visual Studio te muestra sus atributos y métodos. Lo único que hacemos es acceder a su propiedad “Text” y cambiarla por un string a nuestro gusto.

Ahora prueba de darle al play y haz clic en el botón… ¡¡¡sorpresa!!!

6.18.form12

Exacto, ha pasado exactamente lo que hemos programado, al hacer clic se ha ejecutado nuestro código y el texto ha cambiado. Si quieres verlo más en detalle te recomiendo que pongas un breakpoint por ahí e investigues.

Existen infinidad de controles (botones, cajas de texto, tablas, etiquetas…) y obviamente no los vamos a ver todos, pero ya tienes las herramientas necesarias para ir investigando y, como te digo siempre, recuerda que Google es tu amigo y que yo respondo todas las dudas que me encuentro en los comentarios 🙂

5. Resolución de un ejercicio de ejemplo

Para que todo esto quede más claro, vamos a hacer un ejercicio de ejemplo basado en la calculadora que hicimos en el capítulo anterior. Y el ejercicio es… ¡hacer una calculadora!

No te asustes, que la calculadora ya la hemos hecho, es la clase “Calculadora.cs” que hicimos en la sesión anterior pero ahora le vamos a dar una interfaz para que una persona que no sabe programar la pueda usar y, así de paso, ves la diferencia entre el código de una aplicación y el código que controla su interfaz.

Lo primero que vamos a hacer, para que te familiarices con los controles y Visual Studio es imitar la interfaz de la calculadora de Windows en su vista estándar. Usando el mismo proyecto que tenemos creado, vamos a aprovechar el TextBox y el Button que hay en el formulario y vamos a añadir el resto de botones. A continuación te dejo una imagen de la calculadora de Windows (izquierda) y la que he hecho yo (derecha).

  6.19.calc1             6.20.calc2

Antes de liarte a dibujar botones déjame darte dos consejos:

  1. Los botones se pueden copiar y pegar, lo cual es cómodo y útil.
  2. Si quieres poner varios controles iguales, haz clic en el control (del cuadro de herramientas), apreta y deja apretado el control, y a cada clic en el formulario tantas veces como controles del mismo tipo quieras.

Por ahora las calculadoras se parecen como un huevo a una castaña pero ya lo iremos perfilando. Los símbolos de raíz, la flecha, etc. los he cogido del Word (Insertar/Símbolo) pero si no tienes licencia de Word (aquí no animamos a la piratería a no ser que no implique llevar un loro en el hombro) te recomiendo probar con Libre Office (un editor de texto libre y gratuito muy parecido al Word de Microsoft) o, simplemente, copiar y pegar los que te dejo a continuación:

  • Flecha: ←
  • Mas menos: ±
  • Raíz: √

Vale, por ahora no vamos a dejar más bonita la interfaz pero si vamos a tocar un par de detalles de nuestro TextBox. La propiedad Text la vamos a dejar vacía para que no salga nada, y a la propiedad Name le vamos a poner “txtResultado” porque “textBox1” no me gusta… piensa que ahora solo hay un TextBox pero si tuvieras muchos te resultaría muy difícil saber cual es cual si se llaman “textBox1”, “textBox2”, etc.

Vamos a hacer lo mismo con los botones, te dejo escoger el nombre pero te hago dos recomendaciones: que sea un nombre lógico y que empiece por “btn”, como por ejemplo “btnSuma”… ya verás por qué 😉

Vamos al código del formulario principal, re recuerdo que puedes llegar haciendo clic con el botón derecho sobre “Form1.cs” en el “Explorador de soluciones” y escogiendo la opción “Ver código” o pulsando la tecla “F7”.

Asegúrate que todo el código está limpio, deberías ver algo muy parecido a esto:

6.21.clacl3

Vale, antes de empezar a programar una calculadora hay que entender como funciona una calculadora. Como nuestra intención es imitar la calculadora de Windows vamos a ir probando que hace exactamente a fin de irla imitando poco a poco.

Si te fijas, nada más abrirse nos muestra en el resultado un 0, pero si le das al play verás que en tu campo de resultados no aparece nada… No te preocupes que lo solucionaremos.

Empecemos con la suma. Si te fijas, para que la calculadora de Windows haga una suma has de apretar un número, darle al +, después a otro número y acto seguido darle al =. Vamos a empezar programando esto y, para ello hay que entender como funciona por dentro.

Cada vez que pulsas un número aparece en el display de la calculadora, por tanto necesitamos una variable que lo recuerde. Empecemos por ahí. Vamos de nuevo al formulario (si no lo tienes abierto haz doble click en “Form1.cs” en el “Explorador de soluciones” y pulsa sobre el botón “7”. En las propiedades le damos al botón de eventos (el rayo) y hacemos doble click en “click”, lo cual nos lleva de nuevo a la vista de código pero dentro del método click de éste botón.

Como hemos comentado antes, queremos que la calculadora recuerde que hemos pulsado el 7, por lo tanto vamos a definir una variable global, o lo que es lo mismo, un atributo de nuestra clase “Form1”:

6.22.clalc4

Ahora vamos a hacer dos cosas, vamos a decirle a nuestra nueva variable global “_current” que su valor es 7 y vamos a mostrar dicho valor en nuestro TextBox al igual que hace la de Windows:

6.23.calc5

¿Facil verdad? ¿Ves que he puesto un “ToString” detrás de “_current”? El atributo “Text” de “txtResultado” es de tipo string, pero “_current” es un int, el método “ToString” de “_current” permite transformar ese int a string para que lo podamos poner en “Text”.

Si ahora ejecutas la aplicación y le das al botón 7 verás que pasa exactamente esto que decimos aunque no quede igual de bonito que en la calculadora de Windows. Vamos a hacer lo mismo para el resto de números pero primero ahí va otro truco: si haces doble clic a un botón en el formulario crearás automáticamente un evento clic 😉

6.24.calc6

No me han cabido todos en la imagen pero tengo todos los números programados. Volvamos a la calculadora de Windows, y vamos a ver exactamente que pasos sigue a la hora de calcular.

Empieza en 0, si pulsamos el 1 lo muestra en pantalla, si pulsamos el + no hace nada, si pulsamos el 6 lo saca por pantalla, si pulsamos otra vez el + nos saca la suma de 6+1… De esto podemos deducir que la calculadora tiene dos valores principales: el número actual y el resultado.

El primer valor introducido lo usa como resultado. A partir de ahí cada vez que se pulsa un símbolo de operación toma el valor introducido y hace la operación con el resultado… me explico:

actual = 0
resultado = 0

pulso el número 1

actual = 1
resultado = 0

pulso el símbolo +

actual = 0
resultado = 1

pulso el número 3

actual = 3
resultado = 1

pulso el símbolo +

actual = 0
resultado = (3 + 1) = 4

pulso el número 7

actual = 7
resultado = 4

pulso el símbolo –

actual = 0
resultado = (7 + 4) = 11

pulso el número 2

actual = 2
resultado = 11

pulso el símbolo +

actual = 0
resultado = (11 – 2) = 9

Y así hasta el infinito. A esto de deducir como está programada una aplicación estudiando su uso se le llama “Ingeniería Inversa” y en según que cosas (como descubrir como piratear la Play) puede ser hasta ilegal… Microsoft, si estás leyendo esto no te enfades, nuestra calculadora será mucho mejor que la tuya así que tranquila que no estamos copiando nada :p

Bien, soy consciente que programar esto no es trivial, y es posible que tengas la cabeza hecha un lío. No te preocupes, es totalmente normal. Estas cosas se sacan con muchas horas de práctica y muchas más horas de Google.

Si te pongo el código de como programar esto seguramente te limites a leerlo, copiarlo y entenderlo pero lo realmente difícil es sacarlo cuando tienes una pantalla en blanco. Es así como realmente se aprende y se automatizan estas cosas, cuando tienes un lienzo en blanco, te estrujas los sesos y das con una solución que funciona, luego la mejoras, y la vuelves a mejorar… te aseguro que eso no se olvida y proporciona una sensación de satisfacción increíble. Es por ello que no te voy a decir como continuar… ¡hasta el próximo capítulo!

6. Resumen

En realidad no hemos visto muchas cosas en éste capítulo pero si que tienen bastante calado, hemos visto los controles de Windows Forms y solamente hemos usado “Buttons” y “TextBoxes”. También hemos visto que tienen propiedades, métodos e incluso hemos programado alguno de sus eventos como el “Click”.

Por último hemos visto algún ejemplillo y hemos empezado a hacer una calculadora que el muy cabrón de yo no ha querido terminar con la excusa de que esto es bueno para ti.

7. Enunciado del ejercicio para la próxima entrada.

Te dejo para el próximo capítulo la tarea de programar el funcionamiento básico de la calculadora, es decir, eso que hemos explicado con Ingeniería Inversa. Ni más, ni menos.

Creo sinceramente que con todo lo que se ha explicado tienes las herramientas necesarias para hacerlo con éxito. No te pongas límites, no te ofusques, no te preocupes si el código es bonito o eficiente. Usa tantas variables como quieras, públicas o privadas. Haz todo lo que se te ocurra pero haz que funcione. Si consigues hacer que funcione aunque hayas necesitado 2000 líneas de código significa que eres el/la puto amo/a y que estás siguiendo el curso a un ritmo excelente. En serio, para hacer las cosas bonitas siempre se está a tiempo, lo que me interesa ahora es que des con una solución funcional que salga directamente de tu cabeza y a tu manera.

Pista:

¿Recuerdas la clase “Calculadora” del capítulo anterior? Te puede ser de utilidad aunque si no la usas no pasa absolutamente nada.
Usa tantas variables globales como creas que necesitas.
No hay límites de ningún tipo, ¡¡¡desata tu creatividad!!!

Anuncios

2 comentarios en “6 – Introducción a los Windows Forms

  1. Respecto a la corrección del ejercicio anterior:

    No entiendo estas lineas. Las demás las tengo claras.

    class Sistema
    {
    private Ascensor _ascensor;

    public Sistema();
    {
    _ascensor = new Ascensor();
    }

    Ascensor es una clase dentro de la clase Sistema?
    Me podrías explicar lo que hace cada linea?

    Grácias! 😉 (K)

    Me gusta

    1. Buenas Sergi.

      ¡Gracias por la pregunta!

      Verás, “_ascensor” es un atributo privado de la clase “Sistema” y es de tipo “Ascensor”. Es decir, “Sistema” tiene un “Ascensor” dentro. Lo que pasa es que ese ascensor es nulo, está vacío, es como pintar una plaza de párking en el suelo, tienes el hueco reservado pero aún no has metido el coche.

      Después viene un método público que se llama “Sistema”. Siempre que un método se llama igual que la clase hablamos de un método constructor, que se ejecutará cuando crees un objeto de tipo Sistema. Lo que hacemos dentro del constructor es instanciar un nuevo ascensor, es decir, si yo hago “_ascensor = new Ascensor()” lo que estoy haciendo es aparcar el coche en el hueco que he pintado antes.

      A partir de éste punto se puede decir que en “_ascensor” tenemos un objeto de tipo “Ascensor” totalmente funcional, antes de ello no había nada (lo que se conoce como “null”).

      Te pongo un ejemplo:
      Estás en el código de un formulario, en el evento “Load”, y haces “Sistema s;”. Aquí estás diciendo que “s” es una variable de tipo “Sistema” pero no tiene valor.

      Después haces “s = new Sistema();” lo cual cuando se ejecute lanzará el código de la constructora de “Sistema” que a su vez le dará valor al “Ascensor” de dentro, etc.

      Espero haber sido capaz de explicarme, si aún así no queda claro dímelo, lo importante es que quede claro.

      Merci por seguir mi blog y sobretodo por comentar 🙂
      Saludos!

      Me gusta

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s