Juego de dibujos para imprimir y recortar! (Pictonary)

 Adjunto el link para bajar el PDF para que lo pueda impimir y recortar.

A disfrutar!

Descargar el PDF

Tortitas Negras a la Rodrigo!

Estás son las tradicionales y deliciosas facturas tortitas negras en una versión mucho más fácil ya que están hechas sin levadura , pero resultan igualmente deliciosas !!!

Tiempo de preparación: 15 a 30 minutos
Tiempo de cocción: menos de 15 min.

Ingredientes

 400 de Harina Leudante
 100 de Manteca
 1 de Azúcar
 200 de Leche
 200 de Azúcar Negra
 2 de Harina


Preparación

Pisar los 100 gr. de manteca blanda con la cucharada de azúcar, agregar de a poco las 2 tazas de harina alternado con los 200cc. de leche, unir bien, volcar sobre la mesa enharinada y formar un bollo liso y tierno.
En un bol mezclar los 200 gr. de azúcar negra con 2 cucharadas de harina y reservar.
Estirar el bollo de masa sobre la mesa enharinada con el palo de amasar dejándola de 1 cm. de grosor y cortar medallones de 5 cm. de diámetro.
Colocar los medallones separados entre sí, sobre una placa previamente enmantecada y enharinada, espolvorear cada medallón de mas con harina y con un pincelito sacar el excedente hacia los costados, pincelar luego con agua y agregar con la mano el azúcar negra, aplastando apenas para que se adhiera bien.
Cocinar en horno precalentado medio a 190 grados hasta que están bien crecidas y doraditas en la base, 15 minutos aprox.

Acceder al ClientID de un control que está dentro de un UserControl desde Javascript

Hoy quiero comentarles la forma de acceder al ClientID de un control que está dentro de un UserControl en ASP.NET desde Javascript en el cliente. El ClienteID es el ID que genera ASP.NET al crear la página.

Me surgió la necesidad de acceder a un control que está dentro de un UserControl a través de Javascript o jQuery cuando estaba programando una página un tanto compleja. Estuve buscando una solución y la mayoría hacia una inyección de código Javascript en alguna parte del UserControl de una forma parecida a esta:

ClientScriptManager script = Page.ClientScript;
if (!script.IsClientScriptBlockRegistered(this.GetType(), "RegisterVariables"))
{
  StringBuilder scriptBlock = new StringBuilder();
  scriptBlock.AppendLine("<script type=text/javascript>");
  scriptBlock.AppendFormat("var someVar = {0}", TextBox1.ClientID);
  scriptBlock.AppendLine("</script>");


  script.RegisterClientScriptBlock(this.GetType(), "RegisterVariables", 
scriptBlock.ToString());
}

ver: http://forums.asp.net/t/1506954.aspx

Luego someVar al ser global puede ser accedida en cualquier parte de nuestro script.

Realmente me pareció una manera poco elegante de solucionar el problema. Cada vez que el UserControl es utilizado ese código es agregado a la página, se use o no se use.

Mi UserControl, llamado "SeleccionarEmpleados" tenía un listbox llamado "lsEmpleados". Decidí crear una propiedad pública en él de la siguiente forma:


public string lsEmpleados_ClientID
{
        get
        {
            return lsEmpleados.ClientID;
        }
}



Esta propiedad de  "SeleccionarEmpleados" devuelve el ClientID del listbox.

Luego en mi webform puedo acceder de esta forma:



var lst = document.getElementById('<%=SeleccionarEmpleados.lsEmpleados_ClientID%>');




De está forma no hay inyección de código innecesario para otras páginas que no necesiten la funcionalidad y además el código utilizado es mucho más simple y fácil de leer.

Espero que les haya servido!!

Acá estamos de vuelta

Luego de mucho tiempo vuelvo a escribir en el blog. Estaré posteando nuevas entradas acerca de características avanzadas de .net.

Diego Rivera

Este es otro de los íconos de la pintura mundial. Aca les dejo dos pinturas excelentes del pintor.

Para saber más: http://tierra.free-people.net/artes/pintura-diego-rivera.php

La clase game

Hoy vamos a ver un poco el tema de la clase Game que dejamos abierta en la publicación pasada.
Esta clase es la más importante de todas porque se ocupa de orquestar los distintos componentes del juego de manera tal que trabajen en sintonia.

Veamos un poco de código...

import javax.microedition.lcdui.*;
import javax.microedition.media.*;
import javax.microedition.media.control.*;
import java.io.*;
import java.util.*;
import javax.microedition.lcdui.game.*;

class Game extends Canvas implements Runnable
{

public Game()
{
}

static long FPS=14;

public void run()
{
setState(Estados.Load);
setFullScreenMode(true);
while (true)
{
try
{
long FPS_Timer = System.currentTimeMillis();
Update();
draw();
repaint();
serviceRepaints();
GameTimer++;
while ((System.currentTimeMillis()-FPS_Timer)<1000/FPS)
Thread.sleep(1);
}
catch (InterruptedException e)
{
//System.out.println(e.toString());
}
catch (Exception e)
{
//e.printStackTrace();
//System.out.println(e.toString());
}
}
}

public void hideNotify ()
{ }

public void showNotify()
{ }

}

Como ya hemos dicho la clase game hereda de Canvas una clase muy importante para los midlets. pueden encontrar mucha info de ella en la red. Lo que no habíamos dicho era que implementa la interfaz Runnable
Esta interfaz lo que permite es correr la clase game en un nuevo hilo. Esencial para hacer el game loop.

Cuando se implementa esta interfaz se debe agregar un método run a la clase. Este método se ejecutará cuando se dispare el hilo.

En este método setearemos el estado incial y que se utilice la pantalla completa de celular.
además crearemos un while para crear el game loop.

Aquí llamaremos a varios métodos muy importantes para nuestro juego (update, draw, etc que aún no están implementados y sirven para actualizar estados y dibujar la animación) y calcularemos los cuadros por segundo. Repaint y serviceRepaints son métodos de canvas que sirven para pintar en la pantalla.

Bueno... ya tenemos lo básico. la estructura. Aunque todavia no hace ni pinta nada ya hemos comenzado...

Video juegos para móviles!!

Hace un tiempo que he incursionado en el área de los video juegos para móviles.
Estuve desarrollando un juego de aventura muy simple al mejor estilo Super Mario Bros.

Como saben (o no) los móviles usan j2me. Una versión reducida de java. hay mucha info al repsecto en la red.

Hoy voy a empezar dandoles la estructura básica de un midlet de un juego:
(si no entienden a priori no importa ya lo vamos a ir explicando...)


import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class gfx extends MIDlet
{
private Display display;
static Game game;
static gfx _instance;

public gfx()
{
display=Display.getDisplay(this);
_instance=this;
game=new Game();
new Thread(game).start();
}

public void startApp() throws MIDletStateChangeException
{
display.setCurrent(game);
}

public void pauseApp()
{}
public void destroyApp(boolean unconditional)
{}

}

Como verán lo primero que hago es heredar mi clase de midlet... muy importante. Sino no es un midlet.
Creo un display para mostrar el juego en pantalla, un Game que hereda de Canvas y que lo vamos a ver más a delante.
En el contructor creo las instancias de los distintos objetos y lanzó un hilo que ejecuta Game.
En el método startApp() le digo a display que canvas dibujar y como Game hereda de canvas le paso esa instancia.

Es mul sencillo. Ahora el tema de como implementar la clase Game es bastante más complejo. lo iremos viendo en varias entragas más.

Estoy de vuelta

Hola!

Hace un tiempo que no he tenido tiempo de crear nuevas entradas. En adelante trateré de hacerlo más seguido. :)

FTP con C#

La siguiente es una clase que hice para subir, bajar, eliminar y renombrar archivos y carpetas en un servidor FTP con c#.

    /// <summary>
    /// Clase para hacer uso de un servidor FTP
    /// </summary>
    /// <date>2007-07-11</date>
    /// <author>Rodrigo Barros Pascual</author>
    public class ManejadorFTP
    {
        #region <<Propiedades>>

        private String _usuario;

        /// <summary>
        /// Usuario FTP
        /// </summary>
        public String Usuario
        {
            get { return _usuario; }
            set { _usuario = value; }
        }

        private String _contraseña;
        /// <summary>
        /// Contraseña de Usuario FTP
        /// </summary>
        public String Contraseña
        {
            get { return _contraseña; }
            set { _contraseña = value; }
        }

        private String _servidor;

        /// <summary>
        /// URL servidor FTP
        /// </summary>
        public String Servidor
        {
            get { return _servidor; }
            set { _servidor = value; }
        }

             

        #endregion

        /// <summary>
        /// Sube Documentos al servidor FTP
        /// </summary>
        /// <param name=pPathDocumento">Path del Documento</param>"
        /// <param name=pNombreDocumento">Nombre del Documento</param>"
        /// <param name=pPathServidor">Path en el servidor donde se guardará el documento</param>"
        public void SubirDocumento(string pPathDocumento, string pNombreDocumento, string pPathServidor)
        {
            try
            {
                WebClient request = new WebClient();
                request.Credentials = new NetworkCredential(Usuario, Contraseña);
                request.UploadFile(Servidor + pPathServidor + pNombreDocumento, pPathDocumento + "\\" + pNombreDocumento);
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar subir el documento al servidor.", ex);
            }
        }

        /// <summary>
        /// Sube archivos al servidor FTP
        /// </summary>
        /// <param name=pPathDocumento">Path del Documento</param>"
        /// <param name=pNombreDocumento">Nombre del Documento</param>"
        public void SubirDocumento(string pPathDocumento, string pNombreDocumento)
        {
            SubirDocumento(pPathDocumento, pNombreDocumento, String.Empty);
        }

        /// <summary>
        /// Baja Documentos del servidor FTP
        /// </summary>
        /// <param name=pPathServidor">Ruta del Documento en el servidor</param>"
        /// <param name=pNombreDocumento">Nombre y extensión del Documento</param>"
        /// <param name=pPathFisico">Ruta del documento en el sistema de archivos</param>"
        /// <param name=pNombreFisico">Nombre y extensión que se le asignará al documento en el sistema de archivos</param>"
        public void BajarDocumento(string pPathServidor, string pNombreDocumento, string pPathFisico, string pNombreFisico)
        {
            try
            {
                WebClient request = new WebClient();
                request.Credentials = new NetworkCredential(Usuario, Contraseña);
                request.DownloadFile(Servidor + pPathServidor + pNombreDocumento, pPathFisico + "\\" + pNombreFisico);
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar bajar el documento del servidor.", ex);
            }
        }

        /// <summary>
        /// Baja Documentos del servidor FTP
        /// </summary>
        /// <param name=pNombreDocumento">Nombre y extensión del Documento situado en el directorio raíz</param>"
        /// <param name=pPathFisico">Ruta del documento en el sistema de archivos</param>"
        /// <param name=pNombreFisico">Nombre y extensión que se le asignará al documento en el sistema de archivos</param>"
        public void BajarDocumento(string pNombreDocumento, string pPathFisico, string pNombreFisico)
        {
            BajarDocumento(String.Empty, pNombreDocumento, pPathFisico, pNombreFisico);
        }

        /// <summary>
        /// Crea directorios en el servidor FTP
        /// </summary>
        /// <param name=pPathDirectorio">Path del directorio</param>"
        /// <param name=pNombreDirectorio">Nombre del directorio</param>"
        public String CrearDirectorio(string pPathDirectorio, string pNombreDirectorio)
        {
            try
            {
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPathDirectorio + "/" + pNombreDirectorio);
                ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
                ftp.KeepAlive = false;
                ftp.Method = WebRequestMethods.Ftp.MakeDirectory;
                ftp.Proxy = null;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                return response.StatusDescription;
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar crear el directorio en el servidor.", ex);
            }
        }

        /// <summary>
        /// Crea directorios en el servidor FTP
        /// </summary>
        /// <param name=pNombreDirectorio">Nombre del directorio que se agregará al directorio raíz</param>"
        public String CrearDirectorio(string pNombreDirectorio)
        {
            return CrearDirectorio(String.Empty, pNombreDirectorio);
        }

        /// <summary>
        /// Elimina directorios en el servidor FTP
        /// </summary>
        /// <param name=pPathDirectorio">Path del directorio</param>"
        /// <param name=pNombreDirectorio">Nombre del directorio</param>"
        public String EliminarDirectorio(string pPathDirectorio, string pNombreDirectorio)
        {
            try
            {
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPathDirectorio + "/" + pNombreDirectorio);
                ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
                ftp.KeepAlive = false;
                ftp.Method = WebRequestMethods.Ftp.RemoveDirectory;
                ftp.Proxy = null;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                return response.StatusDescription;
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar eliminar el directorio del servidor.", ex);
            }
        }

        /// <summary>
        /// Elimina directorios en el servidor FTP
        /// </summary>
        /// <param name=pNombreDirectorio">Nombre del directorio que se eliminará del directorio raíz</param>"
        public String EliminarDirectorio(string pNombreDirectorio)
        {
            return EliminarDirectorio(String.Empty, pNombreDirectorio);
        }

        /// <summary>
        /// Renombra directorios en el servidor FTP
        /// </summary>
        /// <param name=pPathDirectorio">Path del directorio</param>"
        /// <param name=pNombreDirectorio">Nombre del directorio</param>"
        /// <param name=pNuevoNombreDirectorio">Nombre con el que se renombrará</param>"
        public String RenombrarDirectorio(string pPathDirectorio, string pNombreDirectorio, string pNuevoNombreDirectorio)
        {
            return Renombrar(pPathDirectorio, pNombreDirectorio, pNuevoNombreDirectorio);
        }

        /// <summary>
        /// Renombra directorios en el servidor FTP
        /// </summary>
        /// <param name=pNombreDirectorio">Nombre del directorio</param>"
        /// <param name=pNuevoNombreDirectorio">Nombre con el que se renombrará</param>"
        public String RenombrarDirectorio(string pNombreDirectorio, string pNuevoNombreDirectorio)
        {
            return Renombrar(String.Empty, pNombreDirectorio, pNuevoNombreDirectorio);
        }

        /// <summary>
        /// Renombra Documentos en el servidor FTP
        /// </summary>
        /// <param name=pPathDocumento">Path del Documento</param>"
        /// <param name=pNombreDocumento">Nombre del Documento</param>"
        /// <param name=pNuevoNombreDocumento">Nombre con el que se renombrará</param>"
        public String RenombrarDocumento(string pPathDocumento, string pNombreDocumento, string pNuevoNombreDocumento)
        {
            return Renombrar(pPathDocumento, pNombreDocumento, pNuevoNombreDocumento);
        }

        /// <summary>
        /// Renombra Documentos en el servidor FTP
        /// </summary>
        /// <param name=pNombreDocumento">Nombre del Documento</param>"
        /// <param name=pNuevoNombreDocumento">Nombre con el que se renombrará</param>"
        public String RenombrarDocumento(string pNombreDocumento, string pNuevoNombreDocumento)
        {
            return Renombrar(String.Empty, pNombreDocumento, pNuevoNombreDocumento);
        }

        /// <summary>
        /// Renombra en el servidor FTP
        /// </summary>
        /// <param name=pPath">Path del directorio o documento</param>"
        /// <param name=pNombre">Nombre del directorio o documento</param>"
        /// <param name=pNuevoNombre">Nombre con el que se renombrará</param>"
        private String Renombrar(string pPath, string pNombre, string pNuevoNombre)
        {
            try
            {
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPath + "/" + pNombre);
                ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
                ftp.KeepAlive = false;
                ftp.Method = WebRequestMethods.Ftp.Rename;
                ftp.RenameTo = pNuevoNombre;
                ftp.Proxy = null;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                return response.StatusDescription;
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar renombrar en el servidor.", ex);
            }
        }

        /// <summary>
        /// Elimina documentos en el servidor FTP
        /// </summary>
        /// <param name=pPathDirectorio">Path del documento</param>"
        /// <param name=pNombreDirectorio">Nombre del documento</param>"
        public String EliminarDocumento(string pPathDocumento, string pNombreDocumento)
        {
            try
            {
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPathDocumento + "/" + pNombreDocumento);
                ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
                ftp.KeepAlive = false;
                ftp.Method = WebRequestMethods.Ftp.DeleteFile;
                ftp.Proxy = null;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                return response.StatusDescription;
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar eliminar el documento del servidor.", ex);
            }
        }

        /// <summary>
        /// Elimina documentos en el servidor FTP
        /// </summary>
        /// <param name=pNombreDirectorio">Nombre del documento</param>"
        public String EliminarDocumento(string pNombreDocumento)
        {
            return EliminarDocumento(String.Empty, pNombreDocumento);
        }

        /// <summary>
        /// Constructor por defecto.
        /// </summary>
        /// <param name=pUsuario">Usuario FTP</param>"
        /// <param name=pContraseña">Contraseña de usuario FTP</param>"
        /// <param name=pURLServidor">URL del servidor FTP</param>"
        public ManejadorFTP(String pUsuario, String pContraseña, String pURLServidor)
        {
            Usuario = pUsuario;
            Contraseña = pContraseña;
            Servidor = pURLServidor;
        }

    }

Espero que les sirva.