14/11/10

Comenzando a hablar sobre software educativo

Otra de mis pasiones es el software educativo, la cual nació poco a poco cuando me fui metiendo al mundo de la educación y me di cuenta del gran mercado que hay y la mala calidad de los productos que existen.

Talvez porque los creadores de software educativo son personas que no crecieron con software educativo y también porque muchos de ellos no crecieron siquiera con los videojuegos, incluso he encontrado a varios creadores de software educativo que consideran a los videojuegos como un área contraria a la educación.

Pero comencemos a hablar un poco de software educativo.

La parte más importante del software educativo es sin duda la interfaz de usuario. La interfaz de usuario es la forma mediante la cual el estudiante va a dar instrucciones o va a recibir información del software educativo.

La interfaz de usuario es por decirlo de alguna manera la carta de presentación de nuestro software educativo, de ella depende si los estudiantes lo aceptan o lo rechazan, sin embargo, a diferencia de un software empresarial o de algún otro tipo, la interfaz de usuario en un software educativo va más alla con la aceptación o rechazo del software , sino que también puede provocar en el estudiante un rechazo por el tema o materia que se pretende abordar.

Además la interfaz de usuario debe ser de algún modo sencilla de utilizar para que no sea una barrera entre el conocimiento a transmitir y la forma de interactuar con el software.

Además debe ser atractiva visualmente al estudiante para que de entrada le de la oportunidad de probarlo, recordemos que los estudiantes no tan fácil aceptan lo que diga "Educativo", por lo tanto si la interfaz lo invita a experimentar ya hemos dado un gran paso.

En estos últimos años que me he dedicado al desarrollo de software me he encontrado de todo. Cada software refleja la propuesta pedagógica dependiendo de su estructura y su interactividad.

Por un lado está el software que toman libros impresos y los digitalizan, luego les ponen un par de botones para avanzar y retroceder de página, claro contienen muchisima información, pero no deja de ser una metodología vieja y sin nada nuevo que ofrecer, además que no explota la capacidad de la computadora.

Luego está el software tipo tutorial donde va guiando al usuario por una serie de pasos para la resolución de un problema. Este tipo de software se defiende diciendo que va al ritmo del estudiante, eso no lo niego pero tampoco niego que termina siendo algo mecánico, instruccional y el usuario debe memorizar los pasos.

Por otro lado está el software de tipo juego educativo (en algún lugar le llaman edutainment). Este tipo de software tiene la ventaja de que entretiene al estudiante y los maestros lo utilizan mucho ya que el niño deja de dar lata y se pone a jugar, si desean vender su software este es el tipo de software más buscado y más querido por los maestros y estudiantes. Este tipo de software normalmente es conductista, si resuelves 5 multiplicaciones te ganas una estrellita, si ganas 5 estrellitas entonces te ganas un sello de abejita de "SI TRABAJA" como hace 25 años me hacian mi maestras (sin software educativo).

Luego está el software tipo constructor que también es atractivo para los estudiantes y para los maestros, sin embargo, sin creatividad de alguna de las partes, terminan sin usarlo porque no se les ocurre que construir.

Para terminar existe el software de tipo simulador con una pedagógia constructivista que es muy atractivo por la alta interactividad que ofrece, pero no para el maestro ya que al estudiante le surgen dudas y el maestro tiene que estudiar más.

Los últimos dos tipos de software educativo incluyen más acciones por parte del usuario, son más interactivos pero tambien son más propensos a errores en el diseño de la interfaz de usuario  ya que a mayor interactividad, mayor complejidad en la interfaz.

Todos tienen ventajas y desventajas, dependiendo de los objetivos es la selección del tipo de software a desarrollar.

Luego le sigo con más.

27/9/10

Cómo fabricar un gato tonto en Silverlight

El primer juego en publicar es un Gato (Tic tac toe) tonto, es decir, uno juega contra la computadora, pero la computadora tira donde caiga, sin una estrategia.
La verdad el diseño no es mi fuerte, además siempre me matan las ganas de programar más que de hacerlo bonito (lo siento sé que para el usuario, la interfaz es la aplicación, pero esto es para recorar como lo hice, no para dar gusto a usuarios).
Empezaré con la creación de la interfaz de usuario en XAML de manera que me quede algo como esto:



El XAML es el siguiente:


        
            
            
        
        
            





Ahora a explicar que hace y como lo hace. Vamos a necesitar un arreglo que guarde todas las tiradas, es decir un arreglo de 3 X 3. También vamos a necesitar una variable que nos indique cuántos tiros se han hecho para ver si ya se terminó el juego sin que nadie haya ganado.

Lista de variables a utilizar:

int[,] arrayGato = new int[3, 3];// el arreglo que guarda lo que sucede en cada tirada
        int tiradas = 0; //indica si ya se tiró 9 veces y no hay ganador
        int jugados = 0; //para estadísticas indica cuántos juegos se han jugado
        int ganadosUser = 0;  //para estadísticas indica cuántos juegos ha ganado el usuario
        int ganadosPC = 0;  // para estadísticas indica cuantos juegos ha ganado la compu

Ahora es necesario crear una función que inicialice el arreglo o borre las tiradas después de cada juego:

private void iniciaArray()
        { 
            for(int i = 0; i< 3;i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    arrayGato[i, j] = 0;
                }
            }
        } 
El arreglo se va a llenar con enteros en cada tirada, cuando tire el usuario se va a colocar el valor de 1 (uno) en la celda que haya seleccionado el usuario. Cuando tire la computadora, la celda va a contener el valor de 5, esto se hace para saber quien ganó, recordemos que en el juego del Gato o Tic-tac-toe gana el que tenga 3 celdas en línea, ya sea horizontal, vertical o diagonal, entonces al sumar las tres celdas, nos debe dar el valor de 3 o el valor de 5 dependiendo quien ganó. Entonces hagamos la función que nos devuelve si alguien ganó:
/// 
        /// La función nos devuelve verdadero si ganó la computadora o el usuario, si ganó la computadora la suma de las tres celdas
        /// debe ser igual a 15, si el usuario fue el ganador, la suma de las 3 celdas nos debe dar el valor de 3
        /// 
        /// 
        private bool gano()
        { 
            int ver, hor;
            bool resultado = false;
            for(int i =0; i<3;i++)
            {
                ver = 0;hor = 0;
                for(int j= 0; j<3;j++)//Este for comprueba si alguien ganó en línea horizontal o vertical
                {
                    hor += arrayGato[i,j];
                    ver += arrayGato[j,i];
                }
                if ((hor == 3) || (hor == 15) || (ver == 3) || (ver == 15))
                {
                    resultado = true;
                    break;
                }else{
                    ver = 0;hor = 0;
                }
            }
            //este If comprueba si alguien ganó en alguna diagonal
            if ((3 == arrayGato[0,0]+arrayGato[1,1]+arrayGato[2,2])||(15 == arrayGato[0,0]+arrayGato[1,1]+arrayGato[2,2])
              ||(3 == arrayGato[0,2]+arrayGato[1,1]+arrayGato[2,0])||(15 == arrayGato[0,2]+arrayGato[1,1]+arrayGato[2,0]))
            {
                resultado = true;
            }
            return resultado;
        }
Recordemos que cada celda es un botón, entonces cuando el usuario selecciona una celda, en realidad está presionando un botón por lo cual a todos los botones les vamos a asignar el mismo método que le indica a la computadora que el usuario acaba de tirar. Tambien cada botón va a tener un Tag distinto el de la izquierda superior su tag es 00, el tag de en medio arriba es 01, el tag de lado superior derecho es 02. El tag del boton de enmedio a la izquierda es 10, el de enmedio exáctamente es 11 y el de enmedio a la derecha es 12 y así sucesivamente con los de abajo. Cada tirada debemos cambiar el Content de cada botón dependiendo quien tiró. En el ejemplo el usuario tira las X's mientras que la computadora tira O's. A continuación muestro el método que todos los botones deben tener:
private void button1_Click(object sender, RoutedEventArgs e)
        {
            string cadena, col, ren;
            cadena = ((Button)sender).Tag.ToString();
            col = cadena.Substring(1,1);
            ren = cadena.Substring(0,1);
            tiraUsuario(int.Parse(ren), int.Parse(col));
            ((Button)sender).IsEnabled = false;
            ((Button)sender).Content = "X";
        }
El método obtiene como cadena el Tag del botón y lo divide en 2, el primer valor le corresponde al renglón y el segundo a la columna, luego manda llamar al método tiraUsuario que recibe 2 parámetros: renglón y columna.
private void tiraUsuario(int ren, int col)
        {
            arrayGato[ren, col] = 1;
            tiradas += 1;
            if (gano())
            {
                MessageBox.Show("ganó Usuario");
                ganadosUser += 1;
                jugados += 1;
                lblJuegosJugados.Content = "Juegos jugados: " + jugados.ToString();
                lblJuegosUsuario.Content = "Juegos ganados por el usuario: " + ganadosUser.ToString();
            }
            else {
                if (tiradas < 9)
                {
                    tiraPC();
                    tiradas += 1;
                    if(gano())
                    { 
                        MessageBox.Show("ganó PC");
                        ganadosPC += 1;
                        jugados += 1;
                        lblJuegosJugados.Content = "Juegos jugados: " + jugados.ToString();
                        lblJuegosPC.Content = "Juegos ganados por la computadora: " + ganadosPC.ToString();
                    }
                }
            }
        }
El método anterior pone el valor de 1 (uno) a la celda del array donde tiró el usuario, luego pregunta si ganó y en caso de que no haya ganado entonces manda a llamar al método tiraPC y pregunta si después de tiraPC ganó la computadora. Veamos el método tiraPC ya que este método se va a modificar en la siguiente entrega de este blog para hacer un Gato inteligente.
private void tiraPC()
        {
            Random ran = new Random();
            int r = ran.Next(3);
            int c = ran.Next(3);
            while (arrayGato[r, c] != 0)
            {
                 r = ran.Next(3);
                 c = ran.Next(3);
            }
            arrayGato[r, c] = 5;
            deshabilitaBoton(r,c);
        }
tiraPC coloca la tirada de la computadora al azar, únicamente pregunta por una celda desocupada y ahí hace el tiro, como dije antes, en el siguiente post modificaremos este gato para hacerlo inteligente. Ahora veamos la función que deshabilita el botón para que el usuario no pueda dar clic en una celda que ya ha tirado la computadora:
private void deshabilitaBoton(int r, int c)
        {
            string cadena = r.ToString() + c.ToString();
            foreach (UIElement btn in this.canvas1.Children)
            {
                if (0 == cadena.CompareTo(((Button)btn).Tag.ToString()))
                {
                    ((Button)btn).Content = "O";
                    ((Button)btn).IsEnabled = false;
                }
            }
        }
El método deshabilitaBoton recibe el renglón y columna donde tiró la computadora, luego los valores los convierte a cadena y los compara con los Tag's de los botones para saber que botón deshabilitar. Ya para terminar nos falta un botón que nos va a permitír reiniciar el juego cada que se termine, este método inicializa el arreglo, borra los Content de los botones y los habilita.
private void btnIniciar_Click(object sender, RoutedEventArgs e)
        {
            tiradas = 0;
            iniciaArray();
            foreach (UIElement btn in this.canvas1.Children)
            {
                if (btn is Button)
                {
                    ((Button)btn).Content ="";
                    ((Button)btn).IsEnabled = true;
                }
            }   
            if (rBtnCompu.IsChecked == true) 
            {
                tiraPC();
                tiradas += 1;
            }
        }
    }

Bueno con esto se termina un gato tonto sin embargo trataré de dotarlo de un poco de inteligencia en el siguiente post.

se acabo.

La liga para descargar el código por si no estás perdido debido a mi pésima redacción.
URL:
http://www.mediafire.com/?q5z95b09chob2pq

24/9/10

Agregar formato a código de programación en un post dentro de Blogger

Después de tres post y cuando estaba en la creación del cuarto me di cuenta que mis códigos escritos en csharp (C#) y en XAML no eran legibles y de poco me iban a servir más adelante cuando necesitara de ellos, por lo que me vi en la necesidad de buscar un script que me permitiera darle formato al código de manera fácil y rápida.

La solución fue simple pero lenta porque no encontraba una que pudiera ayudarme con una gran variedad de lenguajes (espero en este Blog escribir en varios lenguajes de programación), además necesitaba que la solución aplicara para Blogger y no tuviera que instalar nada en el servidor, finalmente la solución es la siguiente:

1. Entrar a Blogger con tu cuenta.
2. ir a la sección de Diseño
3. Seleccionar la opción de Edición de HTML
4. Activar la opción: Expandir plantillas de artilugios.
5. Visitar la página:  http://syntaxhighlighter.googlecode.com/svn/trunk/Styles/SyntaxHighlighter.css   y copiar todo el texto.
6. En el código de la plantilla de tu blog buscar la siguiente cadena: ]]--></b:skin>
7. Pegar el texto de la página antes de la cadena ]]]--></b:skin>
8. Luego buscar la cadena: </head> y antes de la cadena pegar lo siguiente:

<!-- Add-in CSS for syntax highlighting -->
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shCore.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushCpp.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushCSharp.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushCss.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushDelphi.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushJava.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushJScript.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushPhp.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushPython.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushRuby.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushSql.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushVb.js' type='text/javascript'></script>
<script src='http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushXml.js' type='text/javascript'></script>

9. Buscar la cadena: </body> y antes de la cadena pegar el siguiente texto:

<!-- Add-in Script for syntax highlighting -->
<script language='javascript'>
dp.SyntaxHighlighter.BloggerMode();
dp.SyntaxHighlighter.HighlightAll('code');
</script>


10. Guarda la plantilla.

11. Ahora para publicar un post en el blog, se debe editar como HTML y colocar las siguientes etiquetas:

<pre name="code" class="java">


Aquí va el código


</pre>

12. Se puede configurar el lenguaje de programación para lo cual hay que sustituir la palabra java por alguna de las siguientes:
  • C++  se escribe cpp, c, c++
  • C#  se escribe    c#, c-sharp, csharp
  • CSS  se escribe  css
  • Delphi se escribe delphi, pascal
  • Java    se escribe       java
  • Java Script se escribe js, jscript, javascript
  • PHP se escribe  php
  • Python se escribe py, python
  • Ruby se escribe rb, ruby, rails, ror
  • Sql se escribe sql
  • VB se escribe vb, vb.net
  • XML/HTML se escribe xml, html, xhtml, xslt

Listo es todo.

12/9/10

Comunicar controles de usuario en silverlight

Quiero que quede huella de cómo comunicar 2 Controles de usuario (User control) en un proyecto en Silverlight utilizando Visual Studio 2010 y C#

Primero quiero tener un control de usuario que lea una cadena de texto, esta cadena de texto debe enviarse a un segundo control de usuario que la muestre en un Textbox.

Tal vez no tenga un uso práctico pero es sencillo para que quede clara la forma de enviar objetos entre controles de usuario.

Empecemos agregando 2 controles de tipo Border en el MainPage contendrán los controles de usuario

---Código XAML del MainPage----
< UserControl x:Class="SilverlightApplication2.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400" >

    < Grid x:Name="LayoutRoot" Background="White" >
        < Border BorderBrush="Silver" BorderThickness="1" Height="152" HorizontalAlignment="Left" Name="border1" VerticalAlignment="Top" Width="400" / >
        < Border BorderBrush="Silver" BorderThickness="1" Height="150" HorizontalAlignment="Left" Margin="0,150,0,0" Name="border2" VerticalAlignment="Top" Width="400" />
    < / Grid >
< / UserControl >
---Fin del Código XAML del MainPage----

Ahora creemos el primer control de usuario que contendrá un TextBox donde escribiremos la cadena que se enviará sl control de usuario 2. También le pondremos un botón para enviar la cadena al segundo control de usuario después de escribirla.
 

---Código XAML del Control de usuario 1----
< UserControl x:Class="SilverlightApplication2.UserControl1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400" >
   
    < Grid x:Name="LayoutRoot" Background="White" >
        < TextBox Height="23" HorizontalAlignment="Left" Margin="12,12,0,0" Name="txtbxCadena" VerticalAlignment="Top" Width="120" / >
        < Button Content="Enviar" Height="23" HorizontalAlignment="Left" Margin="34,41,0,0" Name="btnEnviar" VerticalAlignment="Top" Width="75" Click="btnEnviar_Click" / >
    < / Grid >
< / UserControl >
---Fin del Código XAML del Control de usuario 1----
 

Ahora crearemos un segundo control de usuario que contendrá un TextBlock que mostrará la cadena recibida por el primero control de usuario.

--- Código XAML del Control de usuario 2----

< UserControl x:Class="SilverlightApplication2.UserControl2"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400" >
   
    < Grid x:Name="LayoutRoot" Background="White" >
        < TextBlock Height="22" HorizontalAlignment="Left" Margin="12,12,0,0" Name="txtblockCadenaRec" Text="Aun no me llega nada" VerticalAlignment="Top" Width="293" / >
    < / Grid >
< / UserControl >
---Fin del Código XAML del Control de usuario 2----

Hasta aquí tenemos los XAML de los 2 controles de usuario y del MainPage, ahora a programar.

Primero en el Control de usuario 1 (donde tenemos el textBox y el Botón) debemos crear un delegado encargado de disparar un evento y debemos declarar el evento que se debe disparar.


----Código C# del primer control de usuario----
public partial class UserControl1 : UserControl
    {
        public UserControl1()
        {
            InitializeComponent();
        }
        public delegate void delegadoEnviaCadena(string cadena); /*
es el delegado que se encarga de disparar el evento. Le decimos que el evento se llama delegadoEnviaCadena y recibe una cadena*/
        public event delegadoEnviaCadena enviaCadena;/*Es el evento que se va a disparar. Declaramos el evento del delegado, el evento se llama enviaCadena sin embargo el código de este evento no está en este control de usuario, este evento se desarrolla en el MainPage*/

        private void btnEnviar_Click(object sender, RoutedEventArgs e)
        {
            enviaCadena(txtbxCadena.Text); /*El evento enviaCadena se dispara enviándole el texto escrito, pero el código de lo que hace está en el MainPage.xaml.cs*/
        }  
    }
----Fin del código C# del primer control de usuario-----

 

Con el código anterior declaramos un delegado y un evento que se va a disparar cuando se da clic sobre el botón y envía la cadena.
 

Ahora falta escribir el código del evento que se dispara cuando hacen clic en el botón.

-----Código C# del MainPage-------
public partial class MainPage : UserControl
    {
        UserControl1 uc1; //declaramos el control de usuario 1
        UserControl2 uc2; //declaramos el control de usuario 2
        public MainPage()
        {
            InitializeComponent();
            uc1 = new UserControl1(); //creamos el control de usuario 1
            border1.Child = uc1;     //se lo asignamos al border 1
            uc2 = new UserControl2();  //creamos el control de usuario 2
            border2.Child = uc2;       //se lo asignamos al border 2
            this.uc1.enviaCadena += new UserControl1.delegadoEnviaCadena(recibeMainYEnviaCtrolUser2); /*Le asigna al evento enviaCadena el método recibeMainYEnviaCtrolUser2 con los mismos parámetros*/
        }

        void recibeMainYEnviaCtrolUser2(string cadena)
        {
            uc2.recibeCadena(cadena);  /*le envía la cadena al control de usuario 2 que debe tener un método que reciba los parámetros que deseamos enviarle*/
        }
    }

-----Fin del código C# del MainPage-------

 

Finalmente en el Control de usuario 2 debemos declarar el método que reciba el parámetro que nos envían del primer control de usuario.

----Código C# del segundo control de usuario-----


public partial class UserControl2 : UserControl
    {
        public UserControl2()
        {
            InitializeComponent();
        }

        public void recibeCadena(String cadena)/* el método que recibe el parámetro que nos envían del primer control de usuario*/
        {
            txtblockCadenaRec.Text = cadena;
        }

    }

----Fin del código C# del segundo control de usuario-----

 

En este ejemplo se envía una cadena, pero se puede enviar cualquier objeto, únicamente hay que cambiar la palabra string por el tipo del objeto y listo.

23/8/10

Ecuación paramétrica de la circunferencia

Por el tipo de aplicaciones que desarrollo es común requerir dibujar circunferencias, algo que es muy sencillo en los lenguajes en que lo he hecho, ya sea la instrucción “Circle” o “Ellipse” ya sea que reciba de parámetros el alto y ancho de la circunferencia, o ya sea que solicite el centro y el radio pero no es más que eso.

Sin embargo, también he tenido la necesidad de dibujar segmentos de circunferencias o tener que obtener N puntos que pertenezcan a la circunferencia algo que los lenguajes ya no proporcionan.

En al menos 4 ocasiones he programado la ecuación paramétrica de la circunferencia para obtener los puntos de una circunferencia o para agregarlos como lista de puntos. El proyecto en el que actualmente estoy trabajando lo vuelve a necesitar y aprovecharé para redactarlo aquí.

Empecemos imaginando que deseamos una circunferencia con centro en el punto (a,b) y radio r.
Esto se puede expresar en funciones trigonométricas de la siguiente forma:
x = a + r * cos (u)
y = b + r *sen (u)
“x” y “y” son las coordenada que deseamos obtener.
“a” es la coordenada x del centro de la circunferencia.
“b” es la coordenada y del centro de la circunferencia.
“r” es el radio.
“u” es el ángulo y va de [0,2PI] ; Es decir la circunferencia completa son 2 PI entonces dividimos 2PI para obtener algún punto en específico



Ahora que esto quedó claro vayamos al lenguaje de programación.
En esta ocasión utilizaré Silverlight y C# con Visual Studio 2010.

1. Creamos un proyecto nuevo
2. Dentro del Grid “LayoutRoot” vamos a agreagar un Grid llamado gridCirc y que tiene 80 de alto y 80 ancho.
3. Ahora agregamos un botón que mandará pintar nuestro semicírculo y le ponemos de nombre btnCirc con el texto Semicírculo
Va a quedar el MainPage.xaml así:


<     Grid x:Name="LayoutRoot" Background="White"      >
        <      Grid Height="80" HorizontalAlignment="Left" Margin="12,12,0,0" Name="gridCirc" VerticalAlignment="Top" Width="80" /         >
        <    Button Content="Pinta semicírculo" Height="24" HorizontalAlignment="Left" Margin="98,12,0,0" Name="btnCirc" VerticalAlignment="Top" Width="117" Click="btnCirc_Click" /       >
    <        /          Grid           >

4. Le damos doble clic al botón para que nos cree el método btnCirc_Click(object sender, RoutedEventArgs e) y podamos agregar nuestro código.
5. Agregamos un Polygon que contendrá los puntos de nuestra circunferencia y definimos el color y el color del contorno quedando así:


Polygon ptosCirc = new Polygon(); // El polígono que contendrá los puntos de la circunferencia
ptosCirc.Fill = new SolidColorBrush(Colors.Red); //el color de relleno
ptosCirc.Stroke = new SolidColorBrush(Colors.Black); // el color del contorno


6. Ahora necesitamos un PointCollection para almacenar los puntos que después le pasaremos al Polígono.


PointCollection ptosColeccion = new PointCollection(); 


7. Definimos cuantos puntos vamos a querer que tenga nuestra circunferencia, en este ejemplo 20.


int numPtos = 20;


8. Ahora necesitamos saber cada cuántos grados queremos un punto, es decir una circunferencia son 2 Pi, entonces tendremos que dividir los 2Pi entre el número de puntos, pero esto es para crear una circunferencia completa, en nuestro caso únicamente queremos media circunferencia entonces dividiremos Pi entre el número de puntos.


double siguiente = Math.PI / numPtos;

9. Definimos el centro de nuestra circunferencia:


System.Windows.Point centro = new System.Windows.Point(gridCirc.Width / 2, gridCirc.Height / 2);


10. Luego definimos donde queremos que inicie nuestra semicircunferencia, esto lo hacemos de nuevo dividiendo Pi.


double u = Math.PI + (Math.PI / 2); // esto iniciará como a las 12:00 es decir un la parte superior de la circunferencia.


11. Ahora vamos a recorrer los 20 puntos para calcular las x´s y las y´s de todos los puntos.


for (int i = 0; i <= numPtos; i++, u += siguiente)
{
System.Windows.Point Punto = new System.Windows.Point(centro.X + (gridCirc.Width / 2) * Math.Cos(u), centro.Y + (gridCirc.Height / 2) * Math.Sin(u));
ptosColeccion.Add(Punto);
}


12. Finalmente agregamos los puntos al polígono.


ptosCirc.Points = ptosColeccion;
gridCirc.Children.Add(ptosCirc);


13. Compilamos.

Ahora para el que lo quiere todo junto para copiar y pegar ahí les va como quedó el método:


private void btnCirc_Click(object sender, RoutedEventArgs e)
{
Polygon ptosCirc = new Polygon();
ptosCirc.Fill = new SolidColorBrush(Colors.Red);
ptosCirc.Stroke = new SolidColorBrush(Colors.Black);
PointCollection ptosColeccion = new PointCollection();
int numPtos = 20;
double siguiente = Math.PI / numPtos
System.Windows.Point centro = new System.Windows.Point(gridCirc.Width / 2, gridCirc.Height / 2);
double u = Math.PI + (Math.PI / 2
for (int i = 0; i <= numPtos; i++, u += siguiente)
{
System.Windows.Point Punto = new System.Windows.Point(centro.X + (gridCirc.Width / 2) * Math.Cos(u), centro.Y + (gridCirc.Height / 2) * Math.Sin(u));
ptosColeccion.Add(Punto);
}
ptosCirc.Points = ptosColeccion;
gridCirc.Children.Add(ptosCirc);
}

Al compilar y darle clic al botón les debe de pintar algo así:






FIN.

10/8/10

Envíar múltiples correos personalizados

Cada día utilizo menos el e-mail como medio de comunicación, sin embargo, a pesar del poco uso que le doy estoy consciente que algunas ocasiones es la única manera de comunicarme con ciertas personas. Mi primer cuenta de correo la obtuve hace casi 12 o 13 años, gracias al proveedor de Internet que contraté en ese entonces, luego obtuve una cuenta gratuita de Correoweb ahora desaparecido, y después obtuve mi primer cuenta de Hotmail que me quitaron por hacer mal uso de ella. Hace 7 años obtuve otra cuenta de Hotmail que es la que actualmente, pero nunca tuve la necesidad de enviar correos a más de 300 personas, que los correos salieran de una cuenta de Hotmail y que además estuvieran personalizados.

Hoy surgió ese reto que yo pensé sería más complicado pero no, en realidad es sencillísimo y únicamente necesité mi cuenta de Hotmail, Word 2007 y Outlook 2007.

NOTA: No sé si funcione con versiones anteriores ya que nunca había tenido la necesidad de hacer esto, además el office que tengo instalado está en Español por lo que no sé en otros idiomas como vengan las opciones.

Reto: Mandar cartas a 300 destinatarios desde una cuenta de Hotmail y que cada carta tuviera el nombre de la persona y una clave única entre otros datos personales. La carta debe tener un contenido que sea el mismo para todos exceptuando los datos citados anteriormente. Evitar tener que escribir 300 veces la misma carta y colocar el nombre de la persona.

Solución:
Antes de empezar a dar la solución debo advertir que la lista de destinatarios estaba en una hoja de Excel. En la primer columna contenía el nombre del destinatario, en la segunda columna tenía el correo electrónico, en la tercer columna tenía su clave única y en la cuarta columna tenía el nombre del lugar de exposiciones en el que conocí a la persona.

Así tenía el archivo de Excel


Paso 1. Abrir Outlook (si ya has abierto Outlook puedes saltarte este paso Ja ja ja)

Paso 2. Dar clic en la opción Outlook Connector y seleccionar la opción Agregar una cuenta nueva

Paso 3. Escribir la dirección de Hotmail y la contraseña, así como el nombre que quieras que aparezca al destinatario cada que recibe un correo tuyo y dar clic en Aceptar

Paso 4. En el menú Herramientas dar clic en Opciones y después en la pestaña Configuración de correo. Encontrarás un botón con la leyenda Cuentas de correo electrónico

Paso 5. Ahora la nueva cuenta que agregaste debe quedar hasta arriba en la lista para que sea la predeterminada y cuando se envíen los correos salgan por la cuenta de Hotmail.

Paso 6. Hasta aquí quedó configurado Outlook para que puedas enviar y recibir correo desde Hotmail. Ahora abrimos Word y buscamos la pestaña Correspondencia que en lo personal nunca había visto y no había tenido tiempo si quiera de picarle ni por error.
Paso 7. Damos clic en Iniciar combinación de correspondencia y seleccionamos Mensajes de correo electrónico

Paso 8. En la opción Seleccionar destinatarios debemos dar clic en Usar lista existente y seleccionamos el archivo de Excel que tiene las claves de los destinatarios
Paso 9. Nos solicitará que seleccionemos la hoja que contiene los correos, en mi caso fue la hoja 1

Paso 10. Damos clic en Insertar línea de saludo y la configuramos diciéndole que la primer columna contiene el nombre de la persona.
Paso 11. Redactar el mensaje que es común para todos y en caso de desear agregar algún dato en particular que está contenido en la hoja de Excel únicamente damos clic en Insertar campo combinado y seleccionamos el dato que deseamos agregar. En mi caso seleccione clave única que es un dato particular para cada destinatario.
Paso 12. Finalmente después de terminar el contenido del mensaje damos clic en Finalizar y combinar y seleccionamos Enviar mensajes de correo electrónico.
Paso 13. en la ventana que se abre seleccionamos la columna que contiene el correo, el asunto del correo y damos clic en Aceptar.
Ya puedes dejar de leer, reto terminado. FIN

8/8/10

Empezando la memoria

Este blog se crea con el propósito de servirme de memoria sobre temas que me entretienen, no pretendo escribir cosas que le sirva a la gente, únicamente escribir sobre mis pasatiempos que con el tiempo van cambiando por lo cual me interesa tener un baúl donde guarde todas esas locuras.
 
Algunas veces tambien escribiré pequeños programas en diferentes lenguajes de programación ya que es otro de mis pasatiempos. Esto lo hago principalmente porque desde hace años desarrollo programitas que se pierden con el tiempo y son irrecuperables.