Apuntes de un Estudiante

Cómo accesar a un servidor corriendo en VirtualBox

2011-12-04T17:34:00.000-08:00

Cuando instalamos una máquina virtual en VirtualBox tenemos acceso a internet sin problemas pero no podemos accesar desde la máquina host(la que alberga al equipo Guest o máquina virtual). Si tenemos un servidor corriendo en el equipo Guest y queremos accesar desde el equipo host debemos configurar algunas cosas con VBoxManage.

Ejecutaremos VBoxManage desde la consola o ventana de comandos, así que la abrimos y nos vamos al directorio donde se instaló VirtualBox, en mi caso:

cd C:\Program Files\Oracle\VirtualBox

Obtenemos el nombre del equipo Guest:

VBoxManage list vms

En mi caso obtendría:

"Debian_VBox" {...}

Ahora nos aseguramos que el equipo Guest esté apagado, y luego le agregaremos unos datos extra a su configuración:

VBoxManage setextradata "[nombreEquipoGuest]" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/[servicio]/HostPort" [puertoHost]
VBoxManage setextradata "[nombreEquipoGuest]" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/[servicio]/GuestPort" [puertoGuest]
VBoxManage setextradata "[nombreEquipoGuest]" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/[servicio]/Protocol" [protocolo]

Donde:
[nombreEquipoGuest] es, como bien dice, el nombre del equipo Guest o Máquina Virtual.

[servicio] es el nombre del servicio que se expone en el equipo Guest y al que queremos acceder, puede ser el nombre que nosotros elijamos.

[puertoHost] es el puerto mediante el cual accederemos al servicio desde la máquina Host, es de nuestra elección, sólo debemos verificar que no esté coupado.

[puertoGuest] es el puerto que usa el servicio en el equipo Guest.

[protocolo] es el protocolo del servicio.

En mi caso tengo un servidor web más SSL(puerto 443) en el equipo Guest y quisiera ingresar desde el equipo Host usando el puerto 8877, los 3 comandos a ejecutar serían:

VBoxManage setextradata "Debian_VBox" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/apache/HostPort" 8877
VBoxManage setextradata "Debian_VBox" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/apache/GuestPort" 443
VBoxManage setextradata "Debian_VBox" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/apache/Protocol" TCP

Podemos ver la extradata agregada con el comando:

VBoxManage getextradata "Debian_VBox" enumerate

Luego Abrimos VirtualBox, vamos a Configuración/Red/Adaptador 1/Avanzadas/Tipo de Adaptador y elegimos:

PCnet-PCI II

Ahora puedo ingresar desde el equiipo Host al servidor web instalado en el equipo Guest con la dirección:

https://localhost:8877

VirtualBox se encargará de redireccionar mi petición al servidor de la máquina virtual.

Si quisieramos revertir estos cambios podemos hacerlo ejecutando los mismos comandos pero omitiendo los valores de [puertoHost], [puertoGuest] y [protocolo], por ejemplo si quisieramos quitar el puerto asignado al equipo Host:

VBoxManage setextradata "Debian_VBox" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/apache/HostPort"

Llamar función de ventana padre desde iframe en Fancybox

2011-11-28T17:56:00.000-08:00

Para poder llamar una función de la página padre desde un iframe es necesario agregar una función al plugin.
Primero, descargamos el plugin desde su sitio web.

El archivo a modificar debe ser:

jquery.fancybox-1.3.4.js

Agregaremos la función myCustomCallback, la pondremos al final, después de la declaración de defaults:


//....

$.fn.fancybox.defaults = {
//...
};
/*=========================================================*/     
$.fancybox.myCustomCallback = function(param) {
        
 selectedOpts.customCallbackObject.proccessOperation(param);
     
};
/*========================================================*/

//...

Crearemos nuestros ejemplos usando jquery en su versión actual, aunque la que viene con fancybox también sirve.

Código de la ventana padre:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <title>Parent Window</title>
    <script type="text/javascript" src="./jquery-1.4.3.min.js"></script>
    <script type="text/javascript" src="./fancybox/jquery.mousewheel-3.0.4.pack.js"></script>
    <script type="text/javascript" src="./fancybox/jquery.fancybox-1.3.4.js"></script>
    <link rel="stylesheet" type="text/css" href="./fancybox/jquery.fancybox-1.3.4.css" media="screen" />
    
    <script type="text/javascript">
        $(document).ready(function(){
            
            var myRefObject = {};
            myRefObject.proccessOperation = function(param){ 
                                            SetContainer(param); 
                                            };
            
            $(".fancybox-iframe").fancybox({
                    'type': 'iframe',
                    'customCallbackObject': myRefObject
                });
        });
        
        function SetContainer(param)
        {
            $("#container").append("<p><strong>" + param + "</strong></p>");
        }
    </script>
</head>
<body>
    <div class="">
        <a href="ChildWindow.html" class="fancybox-iframe">
            Mostrar página hija en un iframe
        </a>
    </div>
    
    <div id="container">
        
    </div>
</body>
</html>

Código de la ventana que será levantada en un iframe:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <title>Child Window</title>
    <script type="text/javascript">
        function SendMessageToParentWindow()
        {
            var message = document.getElementById("txtMessage").value;
            parent.$.fancybox.myCustomCallback(message);
        }
    </script>
</head>
<body>
    <div class="">
        <label for="txtMensaje">Escribe un texto</label>
        <input type="text" id="txtMessage" />
    </div>
    
    <div>
        <a href="javascript:SendMessageToParentWindow()">
            Enviar mensaje a la página padre
        </a>
    </div>
    
</body>
</html>

Lo que hacemos es enviarle la referencia(los objetos son tipos de referencia) al objeto myRefObject que sí tiene acceso al método SetContainer() y por tanto lo ejecuta.

Captura:

Convertir archivos .flac a .ogg en Ubuntu

2011-10-09T14:25:00.000-07:00

Para convertir un archivo .flac a usaremos el paquete oggenc que viene instalado por defecto en los sistemas Gnu/Linux, de no ser así procedemos a instalarlo:

sudo apt-get install vorbis-tools

Convertimos de .flac a .ogg:

oggenc -q 10 archivo-entrada.flac -o archivo-salida.ogg

Donde:
-q es la opción que recibe un valor de -1 a 10 que especifica la calidad, por ejemplo: -1(calidad muy baja), 3(valor por defecto), 10(calidad muy alta).

No sería muy cómo si quisieramos convertir un albúm completo a .ogg, para hacernos la vida más fácil crearemos un script al que le pasaremos como argumentos o parámetros el directorio donde se encuentran los archivos .flac y el directorio donde serán guardados los nuevos archivos .ogg respectivamente.
Creamos nuestro archivo .sh:

gedit /home/usuario/Documentos/flac2ogg.sh

En el editor de etexto que nos abrirá escribimos el siguiente script:

#!/bin/sh
cd $1;
for f in *.flac;
do
oggenc -q 10 "$f" -o $2"$f".ogg
done

Luego guardamos y cerramos, luego damos permisos de ejecución a nuestro script:

chmod + x /home/usuario/Documentos/flac2ogg.sh

Ahora ya podemos usar nuestro script:

/home/usuario/Documentos/flac2ogg.sh /home/usuario/DirectorioFLAC /home/usuario/DirectorioOGG

Donde:
/home/usuario/DirectorioFLAC : Es la ruta del directorio que contiene los archivos .flac
/home/usuario/DirectorioOGG : Es la ruta del directorio donde se guardarán los nuevos archivos .ogg
.
.
.
.

Extraer pistas de archivo flac o ape (Debian/Ubuntu)

2011-05-29T09:19:00.000-07:00

A veces tenemos un álbum en un único gran archivo, .flac o .ape, sí queremos extraer o separar las pistas necesitaremos el archivo .cue correspondiente. Un archivo .cue no es más que un archivo de texto plano que contiene la información o metadata del álbum y sus pistas, tales como el nombre de dicho álbum, duración de cada pista,etc.

Primero, instalamos los paquetes necesarios:

sudo apt-get install flac
sudo apt-get install wavpack
sudo apt-get install cuetools
sudo apt-get install shntool

Para poder trabajar con archivos .ape es necesario instalar dos paquetes que no se encuentran en los repositorios pero que pueden ser descargados desde la siguiente dirección:
http://debian-multimedia.org/pool/main/m/monkeys-audio/monkeys-audio.php
Los archivos a descargar son libmac2 y monkeys-audio y deben ser los más recientes.Primero debe instalarse el paquete libmac2 y luego el paquete monkeys-audio.

Extrayendo pistas en formato .flac desde un archivo(álbum) .flac

cuebreakpoints MiAlbum.cue | shnsplit -o flac MiAlbum.flac

Extrayendo pistas en formato .flac desde un archivo(álbum) .ape

cuebreakpoints MiAlbum.cue | shnsplit -o flac MiAlbum.ape

Es necesario señalar que si no se especifica el formato de salida, este será .wav. El formato de salida se especifica mediante la opción -o de shnsplit.

Pasando metadata a las pistas extraídas

cuetag MiAlbum.cue split-track*.flac

Se debe tener cuidado con los espacios en blanco, cuetag no maneja los nombres con espacios.

Documentos Presentables con LaTeX

2011-03-25T14:34:00.000-07:00

LaTeX es un sistema de composición de textos, orientado especialmente a la creación de libros, documentos científicos y técnicos que contengan fórmulas matemáticas.
Es muy utilizado para la composición de artículos académicos, tesis y libros técnicos, dado que la calidad tipográfica de los documentos realizados con LaTeX es comparable a la de una editorial científica de primera línea.

En realidad se puede hacer todo tipo de documentos, libros de cuentos, historia, poesía, trabajos de la u., cartas, etc.

Un Tutorial que hice: (con LaTeX)

Documentos LaTeX en Ubuntu y Windows

View more documents from jlrvpuma

Este visor pdf no permite ver bien la potencia de LaTeX, Adobe Reader renderea el archivo como se debe y se aprecia lo potente que es LateX, mucho mejor se ve el documento impreso.

El .pdf se puede descargar haciendo clic AQUÍ

.

Información de Hardware con dmidecode Ubuntu

2011-02-25T01:48:00.000-08:00

En los sistemas GNU/Linux existe una herramienta bastante útil a la hora de obtener información de nuestro hardware, se llama dmidecode.
Dmidecode nos permite ver la información de hardware de nuestra computadora de acuerdo al estándar SMBIOS/DMI. Esta información típicamente incluye fabricante, nombre del modelo, número de serie, versión del BIOS y más detalles. A menudo incluirá el estado de uso de los sockets del CPU, slots de expansión (AGP, PCI, ISA), slots de los módulos de memoria, y la lista de los puertos I/O ( serial, parallel, USB).

La especificación System Management BIOS(SMBIOS) define estructuras de datos y métodos de acceso en un BIOS permitiendo al usuario o a una aplicación almacenar y recuperar datos específicos de una computadora.
DMI(Desktop Management Interface) expone los datos del sistema incluyendo los datos de SMBIOS.

La información proporcionada por el DMI es usada para desactivar ciertas porciones de código del kernel dependiendo de tal o cuál hardware. Así, los desarrolladores del kernel usan dmidecode para detectar firmas o signatures de sistema y agregarlos a código fuente del kernel cuando es necesitado.

Dmidecode no escanea el hardware, sólo muestra lo que el BIOS le reporta.

Esta excelente herramienta fue desarrollada al principio por Alan Cox . Actualmente es mantenido y desarrollado por Jean Delvare.

Además, dmidecode viene con tres herramientas adicionales:
biosdecode: muestra toda la información relacionada al Bios.
ownership: muestra el "ownership tag" de las computadoras Compaq.
vpddecode: muestra la información "vital product data" que puede ser encontrada en casi todas las computadoras IBM.

Recuperando información de Hardware con dmidecode

Los datos en el DMI se clasifican en tipos(types) y cada uno de ellos se identifica con un número.


The SMBIOS specification defines the following DMI types:

       Type   Information
       ────────────────────────────────────────
          0   BIOS
          1   System
          2   Base Board
          3   Chassis
          4   Processor
          5   Memory Controller
          6   Memory Module
          7   Cache
          8   Port Connector
          9   System Slots
         10   On Board Devices
         11   OEM Strings
         12   System Configuration Options

         13   BIOS Language
         14   Group Associations
         15   System Event Log
         16   Physical Memory Array
         17   Memory Device
         18   32-bit Memory Error
         19   Memory Array Mapped Address
         20   Memory Device Mapped Address
         21   Built-in Pointing Device
         22   Portable Battery
         23   System Reset
         24   Hardware Security
         25   System Power Controls
         26   Voltage Probe
         27   Cooling Device
         28   Temperature Probe
         29   Electrical Current Probe
         30   Out-of-band Remote Access
         31   Boot Integrity Services
         32   System Boot
         33   64-bit Memory Error
         34   Management Device
         35   Management Device Component
         36   Management Device Threshold Data
         37   Memory Channel
         38   IPMI Device
         39   Power Supply

También se puede usar palabras clave(keyword), cada palabra clave tiene sus equivalentes en número:



       Keyword     Types
       ──────────────────────────────
       bios        0, 13
       system      1, 12, 15, 23, 32
       baseboard   2, 10
       chassis     3
       processor   4
       memory      5, 6, 16, 17
       cache       7
       connector   8
       slot        9

Para más información se puede recurrir a la documentación mediante el comando:

man dmidecode

Ahora sí, veamos cómo podemos obtener información de nuestro procesador; escribimos el comando:

sudo dmidecode --type processor

Es equivalente a:

sudo dmidecode -t 4

Información de la meoria RAM, slots ocupados, de cuánto cada slot, cuánto soporta:

sudo dmidecode --type memory

lo cual es equivalente a:

sudo dmidecode -t 5, 6, 16, 17

Como se puede apreciar es posible mostrar varios tipos a la vez, sólo hace falta separarlos por coma.
Si quisiéramos ser más específicos, por ejemplo saber sólo la capacidad de RAM que soporta la computadora:

sudo dmidecode -t 16

O el lenguaje soportado por nuestro BIOS:

sudo dmidecode -t 13

...Podemos probar con todos los tipos...

Cabe señalar que dmidecode esta disponible en los siguientes sistemas:
Linux i386, x86-64, ia64
FreeBSD i386, amd64
NetBSD i386, amd64
OpenBSD i386, amd64
BeOS i386
Cygwin i386
Solaris x86

Referencias:
http://www.nongnu.org/dmidecode/
http://julio-linux.esdebian.org/32607/herramienta-dmidecode

Devolver colección de objetos en formato JSON desde ASP.NET

2011-01-07T10:25:00.000-08:00

Para pasar una colección de objetos a formato JSON serializamos mediante la clase JavaScriptSerializer(contenida en System.Web.Script.Serialization):


//Controlador .ashx
public void ProcessRequest (HttpContext context) {
//...

  List<Libro> lista = new List<Libro>()
  {
    new Libro(){ ISBN = "123456789", Titulo = "Cien Años de Soledad",Autor = "Gabriel García Márquez"},
    new Libro(){ISBN = "756753321",Titulo = "Pedro Páramo",Autor ="Juan Rulfo"},
    new Libro(){ISBN = "655902123",Titulo = "El Aleph",Autor ="Jorge Luis Borges"}
  };
  
  //Pasamos la colección a formato JSON. Se guardará en jsonLista:
  StringBuilder jsonLista = new StringBuilder();
  JavaScriptSerializer js = new JavaScriptSerializer();
  js.Serialize(lista, jsonLista);  
  
  //Devolvemos al cliente la colección:
  context.Response.ContentType = "text/plain";
  context.Response.Write(jsonLista.ToString());
}
...
//La clase Libro: 
public class Libro
{
   public string ISBN {get;set;}
   public string Titulo {get;set;}
   public string Autor {get;set;}
}

En el cliente, leemos la colección JSON devuelta por el servidor:


...

$.post("../Controladores/MiControlador.ashx", { Data: "ObtenerLibros"}, 
       function (response) {
            if (response.length > 0) {
                LeeColeccionJSON(response);
            }
}); 

...

function LeeColeccionJSON(response)
{
  //pasamos la colección JSON a un array de objetos javascript:
  var arr = eval(response);
  
  //Leyendo array:
  for(int i=0; i< arr.length; i++)
  {
    alert("Libro: " + arr[i].Titulo);    
  }
}

Enviar objeto JSON a un controlador genérico(.ashx) de ASP.NET con JQuery

2011-01-07T09:26:00.001-08:00

Se tiene el objeto javascript:


function Libro(isbn,titulo,autor)
{
  this.ISBN = isbn;
  this.Titulo = titulo;
  this.Autor = autor;
}

Mediante la librería JSON.js y su función stringify serializamos el objeto de javascript(JSON) y lo mandamos al controlador:


var libro = new Libro("9755420406824", "El Sueño del Celta","Mario Vargas Llosa");
//Serializamos el objeto JSON:
var jsonLibro = JSON.stringify(libro);

//Ahora mandamos el objeto serializado al controlador genérico:
$.post("../Controladores/MiControlador.ashx", { Data: jsonLibro }, 
       function (response) {
            if (response.length > 0) {
                alert(response);
            }
});

En el controlador, mediante la clase JavaScriptSerializer(contenida en System.Web.Script.Serialization), deserializamos el objeto JSON y obtenemos una instancia de la Clase libro; finalmente devolvemos al cliente un mensaje:


...
public void ProcessRequest (HttpContext context) {
   string mensaje = "";
   string jsonLibro = context.Request.Form["Data"];
   //deserializo:
   JavaScriptSerializer js = new JavaScriptSerializer();
   Libro libro = js.Deserialize<Libro>(jsonLibro );
   mensaje = "Recibido el libro: " + libro.Titulo;
   context.Response.ContentType = "text/plain";
   context.Response.Write(mensaje);
}
...

//La clase Libro: 
public class Libro
{
   public string ISBN {get;set;}
   public string Titulo {get;set;}
   public string Autor {get;set;}
}

Objetos con JavaScript (POO) III

2010-12-07T21:16:00.000-08:00

Anteriormente habíamos visto como crear un objeto con sus propiedades y métodos:


//My Object:
function Persona(nombre,apellido,edad)
{
  //Propiedades
  this.Nombre = nombre;
  this.Apellido = apellido;
  this.Edad = edad;
  //Metodo:
  this.GetNombreCompleto = GetNombreCompleto;
}

//Method
function GetNombreCompleto()
{
  var nombreCompleto = this.Nombre + " " + this.Apellido;
  return nombreCompleto;
}

El problema con el método GetNombreCompleto es que si lo quisiera usar con otro objeto reescribiría dicho metodo de Persona.
Para evitar esto podemos encapsular el método:


//My Object:
function Persona(nombre,apellido,edad)
{
  //Propiedades
  this.Nombre = nombre;
  this.Apellido = apellido;
  this.Edad = edad;
  //Metodo:
  this.GetNombreCompleto = function()
  {
     return this.Nombre + " " + this.Apellido;
  };
}

Objetos con JavaScript (POO) II

2010-12-07T20:16:00.000-08:00

Ya se vió en el post anterior cómo crear un objeto y sus propiedades con javascript, esta vez crearemos un objeto con propiedades y métodos(en este ejemplo sólo declararemos un método).
Para asignar un método a un objeto, primero declaramos el método:


//Method
function GetNombreCompleto()
{
var nombreCompleto = this.Nombre + " " + this.Apellido;
return nombreCompleto;
}

Como vemos este método hace uso de la palabra clave 'this', esto lo hace para acceder a los valores de las propiedades del objeto al que estará conectado.
Ahora asignamos el método a nuestro objeto


//My Object:
function Persona(nombre,apellido,edad)
{
this.Nombre = nombre;
this.Apellido = apellido;
this.Edad = edad;
//Metodo:
this.GetNombreCompleto = GetNombreCompleto;
}

Para llamar al método lo hacemos de la siguiente manera:


persona.GetNombreCompleto()

A continuación el código completo:


<html>
<head>
<title>Test JavaScript Objects</title>
<script type="text/javascript">
//My Object:
function Persona(nombre,apellido,edad)
{
this.Nombre = nombre;
this.Apellido = apellido;
this.Edad = edad;
//Metodo:
this.GetNombreCompleto = GetNombreCompleto;
}

//Method
function GetNombreCompleto()
{
var nombreCompleto = this.Nombre + " " + this.Apellido;
return nombreCompleto;
}

function TestMyObject()
{
var persona;
persona = GetPersona();
var msg = "Nombre: " + persona.Nombre + "\n" + "Apellido: ";
msg += persona.Apellido + "\n" + "Edad: " + persona.Edad + "\nNombreCompleto: " + persona.GetNombreCompleto();
alert(msg);

}

function GetPersona()
{
var persona = new Persona("Pedro","Picapiedra",40);
return persona;
}

</script>
</head>
<body>
<div style="width:300px;height:50px;background:#aaccdd;" onclick="TestMyObject()">
 Test Object (clic aquí)
</div>

</body>
</html>

Objetos con JavaScript (POO) I

2010-12-07T19:46:00.000-08:00

Delaramos al objeto usando una función, dentro de ésta declaramos las propiedades.Las propiedades van precedidas de la palabra clave 'this' y seguidamente '.'(punto):


//My Object:
function Persona(nombre,apellido,edad)
{
 this.Nombre = nombre;
 this.Apellido = apellido;
 this.Edad = edad;
}

Como vemos, el objeto Persona tendrá 3 propiedades: Nombre, Apellido y Edad.
Veamos cómo podemos acceder a las propiedades:


<html>
<head>
<title>Test JavaScript Objects</title>
<script type="text/javascript">
//My Object:
function Persona(nombre,apellido,edad)
{
 this.Nombre = nombre;
 this.Apellido = apellido;
 this.Edad = edad;
}

function TestMyObject()
{
 var persona;
 persona = GetPersona();
 var msg = "Nombre: " + persona.Nombre + "\n" + "Apellido: ";
 msg += persona.Apellido + "\n" + "Edad: " + persona.Edad;
 alert(msg);

}

function GetPersona()
{
 var persona = new Persona("Pedro","Picapiedra",40);
 return persona;
}
</script>
</head>
<body>
 <div style="width:300px;height:50px;background:#aaccdd;" onclick="TestMyObject()">
  Test Object (clic aquí)
 </div>
</body>
</html>

Ahora veamos un ejemplo con un array de objetos Persona :


<html>
<head>
<title>Test JavaScript Objects</title>
<script type="text/javascript">
//My Object:
function Persona(nombre,apellido,edad)
{
 this.Nombre = nombre;
 this.Apellido = apellido;
 this.Edad = edad;
}

function TestArrayObjects()
{
 var myObjects = new Array();
 myObjects = GetArrayPersonas();
 var persona;
 var msg = "";
 for(var i=0;i<myObjects.length;i++)
 {
    persona = myObjects[i];
    msg = "Nombre: " + persona.Nombre + "\n" + "Apellido: ";
    msg += persona.Apellido + "\n" + "Edad: " + persona.Edad;
    alert(msg);
 }   
}

function GetArrayPersonas()
{
 var size = 4;
 var myarray = new Array(size);
 for(var i=0;i<size;i++)
 {
    var persona = new Persona(("Pedro "+i),("Picapiedra "+i),(40+i));
    myarray[i] = persona;
 }
 return myarray;
}
</script>
</head>
<body>
 <div style="width:300px;height:50px;background:#eeffaa;margin-top:30px;" onclick="TestArrayObjects()">
  Test Array Objects (clic aquí)
 </div>
</body>
</html>

Insertar dinamicamente en Tabla Temporal ORACLE

2010-11-04T15:42:00.000-07:00

Las tablas temporales en ORACLE no son como en SQLServer.
La definición de una tabla temporal se almacena en el sistema, como con la de las tablas permanentes, pero los datos permanecerán sólo durante la sesión o transacción, lo cual podemos definir mediante la clausula:


/*Los datos no se eliminan mientras no acabe la sesión:*/
ON COMMIT PRESERVE ROWS

/*O bien:
*Los datos se eliminan al finalizar la transacción*/
ON COMMIT DELETE ROWS

Cabe señalar que, aunque el mismo usuario se conecte dos veces simultaneamente o mientras uno de ellos no termine la sesión, ambas sesiones serán tratadas independientemente,de esta forma lo que un usuario haga en la tabla no le afecta al otro.
Hay buena información en este post:
Tablas temporales en las bases de datos Oracle
Creando una tabla Temporal cuyos datos no se eliminarán mientras la sesión no termine:


CREATE GLOBAL TEMPORARY TABLE TEMP_TABLA
(
NOMBRE VARCHAR2(50),
APELLIDO VARCHAR2(100)
)
ON COMMIT PRESERVE ROWS

Creando una tabla temporal idéntica a una tabla existente:


CREATE GLOBAL TEMPORARY TABLE TEMP_TABLA
ON COMMIT PRESERVE ROWS
AS SELECT * FROM TABLA_EXISTENTE WHERE 1=0;

Insertando dinamicamente en la tabla temporal:
Un stored procedure que recorre una tabla LIST_TABLAS que contiene en su columna NOM_TABLA el nombre de tabla existente de la cual se extraeran los datos a insertar en la tabla temporal.Recordar que la tabla temporal es identica a la tabla que se consultará por los datos.Finalmente se hace un select en la tabla temporal:


/*LA TABLA LIST_TABLAS tiene las columnas:
*NOM_TABLA y FECHA_CREACION*/

CREATE OR REPLACE PROCEDURE SP_INSERTINTEMTABLA
(
    fechaIni IN DATE,
    fechaFin IN DATE,
    curQuery IN OUT SYS_REFCURSOR
)
AS
    querySQL varchar2(1000) :=''; nomTabla varchar2(100) := '';
    cursor_ Integer; numeroMovidos INTEGER;
    CURSOR CUR_LIST_TABLA IS
    SELECT NOM_TABLA FROM LIST_TABLA WHERE TRUNC(FECHA_CREACION) BETWEEN TRUNC(fechaIni) AND TRUNC(fechaFin);
BEGIN
    FOR TA IN CUR_LIST_TABLA
    LOOP
        nomTabla := LTRIM(RTRIM(TA.NOM_TABLA));
        querySQL := 'INSERT INTO TEMP_TABLA ' || 'SELECT * FROM ' || nomTabla;
        cursor_ := dbms_sql.open_cursor;
        dbms_sql.parse (cursor_, querySQL, dbms_sql.native);
        numeroMovidos  := dbms_sql.execute (cursor_);
        dbms_sql.close_cursor (cursor_);
    END LOOP;
    OPEN curQuery FOR
    SELECT * FROM TEMP_TABLA;
END;

Obtener Icono de Aplicación Mediante Path o Ruta de Ejecutable

2010-08-21T08:37:00.001-07:00

Una forma de obtener el ícono de una applicación es mediante el path o ruta de ejecutable de la aplicación, llamando a la función ExtractIconEx la cual se encuentra en la librería shell32.dll.
Dicha función obtiene el handle del ícono de una aplicación mediante la ruta de su ejecutable.La firma de la función ExtractIconEx es :


UINT WINAPI ExtractIconEx(
 __in       LPCTSTR lpszFile,
 __in       int nIconIndex,
 __out_opt  HICON *phiconLarge,
 __out_opt  HICON *phiconSmall,
 __in       UINT nIcons
);


//Para obtener un solo ícono
[DllImport("shell32.dll", CharSet=CharSet.Auto)]
internal static extern int ExtractIconEx(string stExeFileName, int nIconIndex, ref IntPtr phiconLarge, ref IntPtr phiconSmall, int nIcons);

//Para obtener un array de íconos
[DllImport("shell32.dll", CharSet=CharSet.Auto)]
internal static extern int ExtractIconEx(string stExeFileName, int nIconIndex, IntPtr[] phiconLarge, IntPtr[] phiconSmall, int nIcons);

Donde:
- lpszFile: indica el path del ejecutable de la aplicación.
-nIconIndex : Índice del icono a obtener.Si es cero se obtendrá el primer ícono
-*phiconLarge : un Array de handles dónde serán almacenados los iconos extraídos.También puede ser un solo handle.Si es null ningun ícono 'large' será extraído.
-*phiconSmall : un Array de handles dónde serán almacenados los iconos extraídos.También puede ser un solo handle.Si es null ningun ícono 'small' será extraído.
-nIcons :Número de íconos a ser extraídos.

En un post anterior ya se ha visto cómo recuperar la ruta o path del ejecutable de una aplicación mediante el Handle de ventana. A continuación muestro un método que retorna el handle del Icono de la aplicación:


private static IntPtr GetHicon(string exePath)
{
//sólo obtendré el largeIcon
IntPtr largeIcon = IntPtr.Zero;
IntPtr smallIcon = IntPtr.Zero;
ExtractIconExA(exePath, 0, ref largeIcon, ref smallIcon, 1);

DestroyIcon(smallIcon);

return largeIcon;
}

Captura:

Bajar solución completa AQUÍ.(VS2008/WPF)

Obtener ruta o path de Ejecutable mediante Handle de Ventana y API's

2010-08-18T10:50:00.000-07:00

Una forma de hacer esto es llamando a la función GetModuleFileNameEx contenida en la librería Psapi.dll. La firma de esta función :


DWORD WINAPI GetModuleFileNameEx(
__in      HANDLE hProcess,
__in_opt  HMODULE hModule,
__out     LPTSTR lpFilename,
__in      DWORD nSize
);

//Declarado en c#:
[DllImport("Psapi.dll")]
public static extern uint GetModuleFileNameEx(IntPtr hProcess, IntPtr hModule, [Out] StringBuilder lpBaseName, [In] [MarshalAs(UnmanagedType.U4)] int nSize);

Donde:
-hProcess : Handle del proceso
-hModule : Handle al modulo.Si es NULL retornará la ruta del archivo ejecutable del proceso especificado en hProcess
-Puntero al buffer que reibirá la ruta del ejecutable.
-nSize : El tamaño del buffer, en caracteres.

Como ya vimos, el primer parametro(hProcess) es un handle de proceso y no un handle de ventana.
Para obtener un handle de proceso mediante el handle de ventana, es necesario abrir el proceso, obtener el handle(de proceso), usarlo para obtener la ruta del ejecutable y cerrar el proceso.
Primero, para abrir un proceso, necesito llamar a la función OpenProcess que se encuentra en la librería kernel32.dll. La firma de la función es:


HANDLE WINAPI OpenProcess(
__in  DWORD dwDesiredAccess,
__in  BOOL bInheritHandle,
__in  DWORD dwProcessId
);


//Declarado en c#:
[DllImport("kernel32.dll")]
public static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Int32 bInheritHandle, UInt32 dwProcessId);

Donde:
-dwDesiredAccess : acceso al proceso, Ver valores AQUI
-bInheritHandle : Si es true los procesos creados por este proceso heredarán el handle.
-dwProcessId : Id del proceso a ser abierto.

Aquí se presenta otro incoveniente, para abrir un proceso se necesita su identificador o Id y sólo contamos con el handle de ventana.
Para Obtener el id de un proceso mediante el handle de ventana llamamos a la función GetWindowThreadProcessId, el cual se encuentra en la librería Psapi.dll :


DWORD WINAPI GetWindowThreadProcessId(
__in       HWND hWnd,
__out_opt  LPDWORD lpdwProcessId
);


//Declarado en C# :
[DllImport("Psapi.dll")]
public static extern uint GetModuleFileNameEx(IntPtr hProcess, IntPtr hModule, [Out] StringBuilder lpBaseName, [In] [MarshalAs(UnmanagedType.U4)] int nSize);

Donde :
-hWnd : Handle de la ventana
-lpdwProcessId : Puntero a una variable dónde se almacenará el Id del proceso

Ya tenemos declaradas casi todas las funciones que usaremos,antes de comenzar on el código c# veamos la declaración de la función que nos falta, CloseHandle, esta se encarga de cerrar un proceso abierto :


BOOL WINAPI CloseHandle(
__in  HANDLE hObject
);

//Declarada en C# :
[DllImport("kernel32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool CloseHandle(IntPtr hObject);

Donde :
-hObject : Handle del proceso a cerrar.

En un post anterior ya se ha visto como obtener el handle de una ventana, incluso los handles de todas las ventanas.
Aqui una clase con un Método que retorna la ruta del ejecutable mediante el handle de la ventana que recibe como parámetro:


using System;
using System.Collections.Generic;
using System.Text;

//Requerido para las API´s:
using System.Runtime.InteropServices;

namespace GetIcon_Win_APIs
{
public class WinApis
{
   [DllImport("user32.dll")]
   public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);

    [DllImport("kernel32.dll")]
   public static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Int32 bInheritHandle, UInt32 dwProcessId);

   [DllImport("kernel32.dll")]
   [return: MarshalAs(UnmanagedType.Bool)]
   public static extern bool CloseHandle(IntPtr hObject);

    [DllImport("Psapi.dll")]
   public static extern uint GetModuleFileNameEx(IntPtr hProcess, IntPtr hModule, [Out] StringBuilder lpBaseName, [In] [MarshalAs(UnmanagedType.U4)] int nSize);


   public static string GetExePath(IntPtr hwnd)
   {
       //recupero el id del proceso
       uint idProc = 0;
       GetWindowThreadProcessId(hwnd, out idProc);

       //obtengo el path del ejecutable de la aplicacion
       StringBuilder path = new StringBuilder(1024);

       //abro el proceso obteniendo el handle
       IntPtr hProcess = OpenProcess(1040, 0, idProc);

       //recupero la ruta o path del ejecutable
       GetModuleFileNameEx(hProcess, IntPtr.Zero, path, path.Capacity);

       //cierro el proceso abierto
       CloseHandle(hProcess);

       return path.ToString();
   }


}

}//namespace

Observaciones:
En Windows Vista y 7 algunos procesos no pueden ser abiertos y en consecuencia no se puede obtener la ruta del ejecutable, esto se debe a los permisos.Lo mencionado no sucede si se corre el VS o la aplicación(ésta) como administrador.Pero esto sólo con algunas aplicaciones que incluso para ponerlas a correr normalmente ocupan permisos y piden confirmacion(sólo en Vista y 7).

Instalar Oracle XE 10g en Ubuntu 9.10

2010-06-06T12:33:00.000-07:00

Primero que nada, debemos fijarnos en cuánta SWAP o memoria de intercambio tenemos, si es mayor o igual a 1024MB esta bien, en caso contrario habrá que incrementar la SWAP(Ver AQUI).
Una vez que tengamos el tamaño de SWAP requerido, procedemos a instalar Oracle XE 10g.

Primero debemos agregar lso repositorios de Oracle a nuestra lista de repositorios, para eso debemos editar el arhivo /etc/apt/sources.list, asi que lo abrimos como root:
sudo gedit /etc/apt/sources.list
Agregamos lo siguiente al final del archivo:

### REPOSITORIO ORACLE ######
deb http://oss.oracle.com/debian unstable main non-free

Guardamos y cerramos.
Luego,agregamos la clave GPG:
wget http://oss.oracle.com/el4/RPM-GPG-KEY-oracle -O- | sudo apt-key add -

Actualizamos la lista de repositorios:
sudo apt-get update

Ahora ya podemos instalar, instalaremos el servidor y el cliente:
sudo aptitude install oracle-xe oracle-xe-client
Nos preguntará si deseamos instalar los paquetes, así que le decimos que sí.

Después de la instalación es necesario configurar nuestro servidor oracle, para eso:
sudo /etc/init.d/oracle-xe configure
Ahora sólo debemos asignar valores a lo que nos presenta, debemos asignar el puerto HTTP(8080), el puerto del listener de la base de datos(1521), una contraseña para el usuario sys o system y finalmente preguntará si se desea que el servidor Oracle XE se inicie al inicio del sistema.
A continuación una captura de mi configuración(clic sobre la imagen para verla más clara):

Para ingresar a la base de datos a través de su navegador web, escribimos la dirección que se muestra en la última línea de la configuración, en mi caso:
http://127.0.0.1:8080/apex

O podemos ir a Aplicaciones/Oracle DataBase 10g Express Edition/Ir a Página Inicial de Base de Datos
La página que se nos muestra es como esta(clic en la imagen):
Nos logeamos con el nombre se usuario sys o system, escribimos el password que asignamos en la configuración.Y se nos mostrará la página desde donde podemos administrar nuestra base de datos:
Como no es recomendable trabajar directamente con el usuario sys o system, debemos crear un nuevo usuario. Oracle trae un usuario de ejemplo, el usuario HR, pero debemos desbloquearlo, para eso, hacemos clic el Administration, luego en DataBase Users, luego clic sobre HR y lo desbloqueamos y asignamos algunos privilegios:

Una ves desbloqueado el usuario HR, podemos cerrar la sesion(log out) y logearnos con el usuario HR.

Podrán ver que el usuario HR ya trae su propio schema. Para ver las tablas, clic en :
Object Browser/Browse/Tables, nos mostrará las tablas:

Incrementar SWAP o Memoria de Intercambio en Ubuntu 9.10

2010-06-06T11:54:00.000-07:00

Creamos un archivo del tamaño que queramos, por ejemplo de 512MB:
sudo dd if=/dev/zero of=/mnt/512Mb.swap bs=1M count=512
Donde: count=512 significa que queremos que nuestro archivo contenga 512 bloques donde el tamaño de bloque(block size) sea de 1 mebibyte: bs=1M.

Luego, formateamos el archivo para crear un dispositivo swap:
sudo mkswap /mnt/512Mb.swap

Añadimos la SWAP al sistema:
sudo swapon /mnt/512Mb.swap

Para hacer permanente este cambio, debemos editar el archivo fstab, para eso lo abrimos como root con nuestro editor de texto preferido, lo abriré con gedit que es el editor que se instala por defecto en ubuntu:
gksudo gedit /etc/fstab
Ahora agegamos estas líneas al final del archivo:

### Nuevo SWAP ####
/mnt/512Mb.swap  none  swap  sw  0 0

Guardamos los cambios y cerramos.
Luego, Reiniciamos el sistema y ya podremos ver si se ha incrementado nuestra swap o memoria de intercambio.

Deshacer Cambios:
Si se quiere deshacer los cambios se debe seguir los mismos pasos pero en sentido inverso.
Primero abrimos el archivo fstab y borramos las última líneas agregadas:

### Nuevo SWAP ####
/mnt/512Mb.swap  none  swap  sw  0 0

Guardamos y cerramos.
Luego, removemos la SWAP del sistema:
sudo swapoff /mnt/512Mb.swap
Finalmente, removemos el archivo que creamos al principio:
sudo rm /mnt/512Mb.swap

Y eso es todo,no se necesita reiniciar.

Fuente:https://help.ubuntu.com/community/SwapFaq

Firefox Lento con ASP.NET Development Server - Solucion

2010-05-02T01:08:00.000-07:00

En las últimas versiones de Mozilla las páginas cargan muy lentamente al correr una aplicación web desde Visual Studio.
Se debe al conocido asunto de IPv6 con Firefox.Mas Información AQUI.
La solucion es cambiar algunos parametros en la configuración de Mozilla.
Primero, escribiir en la barra de navegación:
about:config
Luego, cambiar el valor de network.dns.disableIPv6 a true, sin embargo, esto deshabilitará el soporte IPv6 para todos los sitios, de manera que lo recomendable sería sólo cambiar el valor de network.dns.ipv4OnlyDomains a localhost.
Y listo, funciona!.

Fuente: dotnetslackers.com

Cómo saber si es Insert o Update Trigger AFTER INSERT,UPDATE - SQL SERVER

2010-03-02T21:35:00.000-08:00

Se tien dos tablas:Empleado y Empleado_Log, se quiere que cada vez que se haga un cambio o una nueva inserción de registro en la tabla Empleado se guarde el nuevo registro o el modificado en la tabla Empleado_Log se debe especificar si fue un insert o un update en una de las columnas, la cual en este ejemplo se llama: "accion".

Ejemplo:


--TABLAS:
create table Empleado(
                        id int not null,
                        nombre varchar(20),
                        apellido varchar(20),
                        edad int,
                        editable varchar(2)
                    )
--tabla log
create table Empleado_Log(
                            idEmpleado int,
                            nombre varchar(20),
                            apellido varchar(20),
                            edad int,
                            editable varchar(2),
                            accion varchar(20)
                          )

--trigger que se disparará cuando se haga un insert o un update
create trigger trg_Example
on Empleado
after insert,update
as
begin
    declare
    @idEmp int,
    @nombre varchar(20),
    @apellido varchar(20),
    @edad int,
    @editable varchar(2),
    @accion varchar (20)

    select @idEmp=id,@nombre=nombre,@apellido=apellido,@edad=edad,
            @editable=editable
            from inserted
    begin
        --Si hay valores en la tabla deleted y además todos(excepto 
        --editable y id) son diferentes a los nuevos valores insertados,
        --significa que ha habido un update
        if exists(select * from deleted d join inserted i on 
                    d.id=i.id where d.nombre != i.nombre or 
                    d.apellido != i.apellido or d.edad != i.edad)
        begin
            set @accion ='record updated'
            insert into Empleado_Log values(@idEmp,@nombre,@apellido,
                                            @edad,@editable,@accion)
        end
        --Si no ha habido un update hay valores sólo en la tabla inserted
        --y eso significa que ha habido un insert.No se debe olvidar
        --que un update es un delete y un insert.
        else if exists(select id from inserted) 
                            and not exists(select id from deleted)
        begin
            set @accion ='record inserted'
            insert into Empleado_Log values(@idEmp,@nombre,@apellido,
                                                @edad,@editable,@accion)
        end
    end
end

--probando
insert into Empleado values (1,'pedro','sanchez',30,'si')

insert into Empleado values (2,'Luis','Perez',32,'no')

update Empleado set nombre='josse',apellido='diaz',
                    edad=21,editable='si' where id=1

update Empleado set nombre='Juan' where id=2

delete from Empleado_Log

select * from Empleado_Log

--borrando tablas y trigger
drop table Empleado_Log
drop table Empleado
drop trigger trg_Example

Trigger After Insert Update - SQL SERVER

2010-02-03T19:01:00.000-08:00


/*Creo la Tabla Empleado*/

create table Empleado(
nombre varchar(20),
apellido varchar(20))


/*En esta se guardará automaticamente lo que se guardo en 
la Tabla Empleado*/

create table Empleado_Log(
nombre varchar(20),
apellido varchar(20),
direccion varchar(100),
edad int)


/*Creo Trigger, se ejecutará después de insertar o actualizar la 
tabla Empleado e insertará los neuvos datos insertados en Empleado
en la tabla Empleado_Log*/

Create trigger trg_Empleado_Log
on Empleado
after insert,update
as
BEGIN

    set nocount on;

    declare
    @nombre varchar(20),
    @apellido varchar(20)

    select @nombre = nombre,@apellido = apellido 
    from inserted

    declare
    @direccion varchar(100),
    @edad int

    set @direccion='Av 15, Santa Marina'
    set @edad = 22

    begin
        insert into Empleado_Log values(@nombre,@apellido,@direccion,@edad )
    end
END



/*Probando*/

insert into Empleado values('Pedro','Casas')
select * from Empleado
select * from Empleado_Log

update Empleado set nombre = 'Carlos'
select * from Empleado
select * from Empleado_Log

Oracle - Crear Tablas desde archivo .sql

2010-01-18T21:57:00.000-08:00

El comando para ejecutar un archivo sql sería:


@archivo.sql;

o bien


@C:\Cualquier\Ruta\archivo.sql;

Desde luego que la unidad puede variar y no necesariamente tiene que ser la unidad C.

Ahora bien, si ejecutamos esta sentencia desde la Página inicial de Base de Datos; es decir la interfaz Web, obtendremos el error:


 ORA-00900: invalid SQL statement

Al menos con al version oracle xe 10g express me dió este error.

Oracle dice al respecto de este error:

ORA-00900 invalid SQL statement
Cause: The statement is not recognized as a valid SQL statement. This error can occur if the Procedural Option is not installed and a SQL statement is issued that requires this option (for example, a CREATE PROCEDURE statement). You can determine if the Procedural Option is installed by starting SQL*Plus. If the PL/SQL banner is not displayed, then the option is not installed.

Action: Correct the syntax or install the Procedural Option.

Por el momento no nos complicamos la vida y nos conectamos mediante el editor SQL PLUS (se instaló con Oracle developer).
Cuando nos hemos conectado escribimos el comando:


@C:\Cualquier\Ruta\archivo.sql;

Y ¡Sí! ha funcionado.

Oracle - Trigger y algunas cosas básicas

2010-01-16T19:41:00.000-08:00

No es case sensitive.
No existe el: on update cascade.
Para crear una tabla:


create table Producto(
id number not null constraint d_pk primary key,
precio number,
stock number);

/*otra tabla*/
create table Pedidos(
idprod number not null,
unidades number,
foreign key (idprod) references producto(id));

Insertando a las tablas:


/*insertando a la tabla producto*/
insert into Producto values(1,350,10);

/*insertando a la tabla pedidos*/
insert into Pedidos values(1,8);

Haciendo Select en las tablas:


select *  from Pedidos order by idprod asc;
select * from Producto order by id asc;
/*Esta última consulta nos mostrará el valor '10' en el campo 'stock' aún cuando ya
se ha hecho el pedido de '8' productos.*/

Lo ideal sería que cuando se hagan pedidos el numero de estos sea restado al campo 'stock' de la tabla Producto.

En ese caso podemos crear un trigger en el que especificaremos que cada vez que se haga un 'insert', un 'update' o un 'delete', el valor en el campo 'stock' de la tabla Poducto se actualize.

Creando el trigger 'calculastock':


create o replace trigger calculastock
after insert or delete or update
on Pedidos
for each row
begin
if(inserting or updating)
then
update Producto
set stock = stock - :new.unidades
where Producto.id = :new.idprod;
end if;
if(updating or deleting)
then
update Producto
set stock = stock + :old.unidades
where Producto.id = :old.idprod;
end if;
end;

Las variables 'old' y 'new' no necesitan declararse, son tipo tipo %ROWTYPE , y contienen una copia del registro 'antes'(old) y 'después'(new) de la acción sql(insert, update,delete).

Cómo obtener lista de ventanas mediante API´s

2009-12-12T17:52:00.000-08:00

Para obtener los manejadores o handles delas ventanas abiertas se puede hacer llamando a la función GetWindow, pero es mas seguro hacerlo mediante la función EnumWindows ya que GetWindow puede refenciar a un handle de una ventana ya destruida o quedarse en un loop`o ciclo infinito, es fácil darse cuenta de esto último mediante el debugger.
La funcion EnumWindows esta contenida en la librería user32.dll y su sintaxis es la siguiente:

BOOL EnumWindows(
WNDENUMPROC lpEnumFunc,
LPARAM lParam
);

El primer parámetro es un puntero a una función callback.
El segundo parámetro de la función es un valor definido por la aplicación; es decir que puedo mandar cualquier parámetro que me sea necesario usar en la función callback.

Para el primer parámetro debemos declarar un delegado. Antes de hacerlo veamos como debe ser la función callback(EnumWindowsProc):

BOOL CALLBACK EnumWindowsProc(
HWND hwnd,
LPARAM lParam
);

El primer parámetro es el handle de la ventana, lo recibirá de su llamador,la función EnumWindows.
El segundo parámetro es un valor definido por la aplicación,lo recibirá de su llamador,la función EnumWindows.
Debe retornar TRUE para seguir enumerando, de lo contrario no lo hará.

Antes es necesario saber que para poder acceder a las API's es necesario agregar la directiva:
using System.Runtime.InteropServices;

Entonces declaramos el delegado y de una vez la función EnumWindows:


//declaro el delegado para la función callback
private delegate bool EnumWindowsCallback(IntPtr hwnd, IntPtr lParam);

//Declaro la función EnumWindows
private static extern bool EnumWindows(EnumWindowsCallback Callback, IntPtr lParam);

Ahora creamos el método al que apuntará el delegado EnumWindowsCallback y El método público que llamará a la función EnumWindows :



//Metodo al que apunta el delegado EnumWinodwsCallback
private static bool Callback(IntPtr hwnd, IntPtr lParam)
{
hwndList.Add(hwnd);

return true; //continua la enumeración
}

//aqui se guradara la lista de handle's
private static List<IntPtr> hwndList;

public static List<IntPtr> GetWindowsList()
{
hwndList = new List<IntPtr>();

EnumWindowsCallback MyCallback = Callback;

bool val = EnumWindows(MyCallback, IntPtr.Zero);

/*retorno la lista de handle's*/
return hwndList;

}

Se recuperará todos los handle's de todas las ventanas abiertas, que son muchas.Si lo que se quiere es recuperar sólo las ventanas con borde y visibles -que en su mayoría son las que tienen los programas o aplicaciones mas comunes y de uso diario- se debe llamar a la función GetWindowLong para saber los estilos de la ventana; es decir, si tiene borde y si es visible, entre otros valores que se pueden consultar.
La función GetWindowLong recupera información de una ventana especificada.
Su sintaxis:

LONG GetWindowLong(
HWND hWnd,
int nIndex

);

El primer parámetro es el handle una ventana especificada, de la que se quiere saber su estilo.
El segundo parámetro sera el valor de GWL_STYLE, pues para este ejemplo es necesario.
En esta página se pueden ver las los valores de sus constantes.
El msdn dice que para que nuestro código sea compatible con 32bits y 64bits debemos llamar a la función GetWindowLongPtr que es prácticamente lo mismo que GetWindowLong -en su declaración-.Sin embargo, en Windows Vista Ultimate de 32bits la función GetWindowLonPtr no funciona, no existe.En cambio GetWindowLongA corre sin problemas en el S.O mencionado.Acerca de ésta dice el msdn que provee un comportamiento mas consistente entre los S.O's Windows. Así que para este ejemplo se llamara a la funcion GetWindowLongA, por lo que la función callback quedará:


//El valor standard de GWL_STYLE es -16
static readonly int GWL_STYLE = -16;
static readonly ulong WS_VISIBLE = 0x10000000;
static readonly ulong WS_BORDER = 0x00800000;
static readonly ulong TARGETWINDOW = WS_BORDER | WS_VISIBLE;

//Declaro la funcion GetWindowLongA
[DllImport("user32.dll")]
private static extern ulong GetWindowLongA(IntPtr hWnd, int nIndex);

//Metodo al que apunta el delegado EnumWinodwsCallback
private static bool Callback(IntPtr hwnd, IntPtr lParam)
{
  //agrego ventanas visibles con borde
  if ((GetWindowLongA(hwnd, GWL_STYLE) & TARGETWINDOW) == TARGETWINDOW)
  {

      hwndList.Add(hwnd);
  }

  return true; //continua la enumeración
}

if ((GetWindowLongA(hwnd, GWL_STYLE) & TARGETWINDOW) == TARGETWINDOW)
   {

       hwndList.Add(hwnd);
   }

le decimos si la ventana tiene bordes y es visible que agregue a la lista genérica hwndList.

Para hacer mas intersante la aplicación podemos recuperar también los titulos de las ventanas cuyos handle's hemos recuperado. Esto lo hacemos mediante la función GetWindowText contenida en la librería user32.dll :


/*Declaro la función GetWindowText*/

/// <summary>
/// Recupera el título de un
a ventana(de la barra de título), si es que tiene.
/// </summary>
/// <param name="hWnd">Handle de la ventana de la que se quiere recuperar el título.</param>
/// <param name="lpString">[out]Puntero al buffer que recibe el texto.Si el texto es
/// más largo que el buffer será truncado y terminado con caracter NULL.</param>
/// <param name="nMaxCount">Especifica el maximo´número de caracteres a escribir en
/// el buffer</param>
[DllImport("user32.dll")]
private static extern void GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);

Para que se vea mas ordenado en una clase estática pondré las llamadas a las API's y mostraré en un listbox(WPF) los titulos de ventanas obtenidos.
Clase APICalls.cs :


using System;
using System.Collections.Generic;
using System.Text;

//Requerido para las API´s:
using System.Runtime.InteropServices;

namespace GettingWindows
{
public static class ApiCalls
{
 //aqui se guradara la lista de handle´s
 private static List<IntPtr> hwndList;

 //El valor standard de GWL_STYLE
 static readonly int GWL_STYLE = -16;
 static readonly ulong WS_VISIBLE = 0x10000000;
 static readonly ulong WS_BORDER = 0x00800000;
 static readonly ulong TARGETWINDOW = WS_BORDER | WS_VISIBLE;


 /// <summary>
 /// Enumera todas las ventanas de la pantalla.Para eso llama a la función
 /// Callback.La funcion continua llamandose hasta
 /// que EnumWindowsCallback retorne false.
 /// </summary>
 /// <param name="lpEnumFunc">Puntero a la funcion EnumWindowsCallback</param>
 /// <param name="lParam"></param>
 /// <returns></returns>
 [DllImport("user32.dll")]
 private static extern bool EnumWindows(EnumWindowsCallback Callback, IntPtr lParam);
 /// <summary>
 /// Defino EnumWindowsCallback a traves de un delegado.
 /// Ver el metodo privado estatico Callback.
 /// </summary>
 /// <param name="hwnd">Handle de la ventana top-level que esta enumerando </param>
 /// <param name="lParam"></param>
 /// <returns>Para continuar enumeando debe retornar TRUE</returns>
 private delegate bool EnumWindowsCallback(IntPtr hwnd, IntPtr lParam);

 /// <summary>
 /// Recupera la información de una ventana especifica
 /// </summary>
 /// <param name="hWnd">Handle a la ventana y-indirectamente- a la clase a la cual
 /// pertenece la ventana.</param>
 /// <param name="nIndex"></param>
 /// <returns>retorna cero(0) si la funcion falla</returns>
 [DllImport("user32.dll")]
 private static extern ulong GetWindowLongA(IntPtr hWnd, int nIndex);

 /***/
 /// <summary>
 /// Recupera el título de una ventana(de la barra de título), si es que tiene.
 /// </summary>
 /// <param name="hWnd">Handle de la ventana de la que se quiere recuperar el título.</param>
 /// <param name="lpString">[out]Puntero al buffer que recibe el texto.Si el texto es
 /// más largo que el buffer será truncado y terminado con caracter NULL.</param>
 /// <param name="nMaxCount">Especifica el maximo número de caracteres a escribir en
 /// el buffer</param>
 [DllImport("user32.dll")]
 private static extern void GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);


 /**************************************************************************************/

 //Metodo al que apunta el delegado EnumWinodwsCallback
 private static bool Callback(IntPtr hwnd, IntPtr lParam)
 {
     //agrego ventanas visibles con borde
     if ((GetWindowLongA(hwnd, GWL_STYLE) & TARGETWINDOW) == TARGETWINDOW)
     {

         hwndList.Add(hwnd);
     }

     return true; //continua la enumeración
 }



 public static List<string> GetWindowsList()
 {
     List<string> wndTitles = new List<string>() ;
     StringBuilder sb = new StringBuilder(256);

     hwndList = new List<IntPtr>();

     EnumWindowsCallback MyCallback = Callback;

     EnumWindows(MyCallback, IntPtr.Zero);

     /*ya llena la lista de handle´s obtengo el titulo de cada ventana*/
     foreach (IntPtr h in hwndList)
     {
         GetWindowText(h, sb, sb.Capacity);

         wndTitles.Add(sb.ToString());
     }

     /*retorno la lista de titulos de ventanas*/
     return wndTitles;

 }
}
}

Código de la ventana MainWindow.xaml(en XAML):


<Window x:Class="GettingWindows.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MainWindow" Height="363" Width="322">
<Grid>
 <Button Height="27" Margin="26,29,133,0" Name="btnGetList" VerticalAlignment="Top" Click="btnGetList_Click">Mostrar lista de ventanas</Button>
 <ListBox Margin="26,80,19,18" Name="lbxList" />
</Grid>
</Window>

Código de MainWindow.cs :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;

namespace GettingWindows
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
 public MainWindow()
 {
     InitializeComponent();
 }

 private void btnGetList_Click(object sender, RoutedEventArgs e)
 {
     lbxList.ItemsSource = ApiCalls.GetWindowsList();

 }
}
}

Una captura:

Delegados C#

2009-12-03T16:21:00.000-08:00

Un delegado o delegate es un tipo que hace referencia a un método.Cualquier método que coincida con la firma del delegado puede asignarse al delegado.Veamos un ejemplo:


  //Declaro un delegado
        public delegate int DelCalculo(int a,int b);

        //Creo un Metodo para el delegado DelCalculo.
        /*Nótese que coincide con la firma del delegado,
         *tanto por el tipo de valor devuelto como por los
         *tipos de los parametros*/
        public static int Suma(int a, int b)
        {
            return (a + b);
        }

/******************************************************************************/
/*Creo una instancia del delegado asignándole
             * el metodo al que hará referencia*/
            DelCalculo obj = Suma;

            /*Llamo al delegado*/
            int val = obj(3, 4);

            /*Muestro en pantalla el valor devuelo:
             *El valor devuelto es : 7 */
            Console.WriteLine("El valor devuelto es : {0}",val);

Desde la versión 2.0 de C# se puede hacer uso de los métodos anónimos,esto es pasar un bloque de código como parámetro de delegado, de esta forma no tendría que crear un método para asignárselo en la instanciación del delegado como lo hice en el código mostrado lineas arriba.A continuación instaciaré al delegado usando un método anónimo y en vez de devolver la suma de los parámetros, devolverá la diferencia:


 /*Creo instancia del delegado usando un metodo anonimo*/
            DelCalculo obj2 = delegate(int a, int b) { return (a - b); };

            /*llamo al delegado*/
            val = obj2(10, 5);

            /*Muestro en pantalla el valor devuelto:
             *El valor devuelto por obj2 es : 5 */
            Console.WriteLine("El valor devuelto por obj2 es : {0}", val);

Desde la versión 3.0 del framework .net es posible hacer uso de expresiones Lambda.A continuación instaciaré al delegado usando expresiones lambda y retornará el producto de sus parametros :


/*instanciando delegado usando expresiones lambda*/
            DelCalculo obj3 = (int a, int b) => { return (a * b); };

            /*llamando al delegado*/
            val = obj3(6, 8);

            Console.WriteLine("El valor devuelto por obj3 es : {0}", val);

            /*Salida en pantalla: El valor devuelto por obj3 es : 48 */

Dado que un delegado con instancias es un objeto, se puede pasar como parámetro a un metodo para ser llamado posteriormente, lo que se conoce como devolución de llamada asincrónica.Veamos un ejmplo:


 /*Utiliza el delegado DelCalculo como parámetro y lo invoca*/
        public static void MetodoConCallBack(int x, int y, DelCalculo callback)
        {
            int val = callback(x,y);
            Console.WriteLine("El resultado es : {0}",val);
        }

/*llamo al método pasándole como parámetro una instancia del
* delegado DelCalculo, en este caso: obj*/

            MetodoConCallBack(5, 4, obj);

/*La salida en pantalla será: El resultado es : 9 */

Un delegado puede llamar a mas de un método cuando se invoca.Sólo es necesario agregar los delegados -que llaman a los otros metodos- a su lista de invocación mediante el operador de suma "+" o "+=".Para el siguiente ejemplo crearé una nueva clase que contendrá dos metodos y tambien crearé un nuevo delegado que hará referencia a esos metodos:


using System;

namespace TestingDelegates
{
    class MisMetodos
    {
        public void Metodo1(string cad)
        {
            Console.WriteLine(cad+" : Metodo1" );
        }

        public void Metodo2(string cad)
        {
            Console.WriteLine(cad + " : Metodo2");
        }
    }
}

/***********************************************************/

/*instancia de clase MisMetodos*/
       public static MisMetodos metodos = new MisMetodos();
        /*Delegado para metodos de MisMetodos*/
        public delegate void nuevoDel(string cad);

/*asignando*/
            nuevoDel del1 = metodos.Metodo1;
            nuevoDel del2 = metodos.Metodo2;

            nuevoDel contenedorDel = del1 + del2;

            /*Invocando al delegado que llamará a los métodos*/
            contenedorDel("Metodo ejecutado");

/*La salida será : 
*Metodo ejecutado : Metodo1
*Metodo ejecutado : Metodo2*/

También se pueden quitar métodos de la lista de invocación.A continuación quitaré el método Metodo1:


 /*quitando el metodo Metodo1 de la lista de invocación*/
            contenedorDel -= metodos.Metodo1;

            contenedorDel("Metodo ejecutado");

/*La salida será:
*Metodo ejecutado : Metodo2 */

Al principio decía que el método debe coincidir con la firma del delegado, en realidad no tienen que coincidir exactamente, esto se debe a la covarianza y contravarianza:

La covarianza permite que un método tenga un tipo de valor devuelto más derivado que lo que se define en el delegado. La contravarianza permite un método con tipos de parámetro que se deriven menos que en el tipo de delegado.

Veamos:


/*Tengo dos clases, una base y otra derivada:*/
     public class ClasePadre
    {
       
    }

    public class ClaseHija : ClasePadre
    {
        
    }

/***********************************************************************/

/*declaro un delegado para mostrar la Covarianza*/
        public delegate ClasePadre CovarianzaDel();

        /*declaro un delegado para mostrar la Contravarianza*/
        public delegate void ContravarianzaDel(ClasePadre padre);

/************************************************************************/
//USANDO EXPRESIONES LAMBDA:

 /*la covarianza nos permite esto:
  *devolver un tipo derivado del tipo que especifica el delegado*/
            CovarianzaDel cov = () => { return new ClaseHija(); };



  ContravarianzaDel contrav = (ClasePadre padre) => {/*...*/};

            ClaseHija hija = new ClaseHija();

   /*La contravarianza nos permite mandar como parametro una 
    *instancia de la clase derivada 
    *de la que se especifica en el delegado*/

            contrav(hija);

MySQL (en Ubuntu) - Guía rápida

2009-11-01T18:09:00.000-08:00

Nota:
Toda sentencia en MySQL debe terminar con un punto y coma (;).
El símbolo $ indica el símbolo de comando del interprete de comandos; por ejemplo,
en Windows es c:\>.El símbolo mysql> es el símbolo de comandos de MySQL. No se deben escribir con el comando ya que son auto-generados, al igual que el símbolo -> .

Instalación:
$sudo apt-get install mysql-server-5.1
Durante la instalación pedirá que se ingrese una contraseña para el root de mysql.
Vamos a crear una base de datos y un usuario con el que vamos a trabajar y que tendrá acceso a la nueva base de datos.
Para eso debemos conectarnos al servidor mysql mediante el comando:
$mysql -u nombredeusuario -p
Dado que en este momento sólo existe el usuario root; entonces, desde la consola o terminal escribimos el comando:
$mysql -u root -p
Nos pedirá la contraseña , así que la escribimos. Es de recordar que en la consola no aparecerá nada mientras escribimos la contraseña, así se evita que alguien más pueda verla.
Establecida la conexión aparecerá el símbolo de comandos:
mysql>
Creamos la nueva base de datos:


mysql>CREATE DATABASE newdb;

Creamos el usuario jlrvpuma y le damos permiso completo de acceso a la nueva base de datos newdb:


mysql>GRANT ALL ON newdb.* to jlrvpuma@localhost  IDENTIFIED BY 'password';

Se ha creado al usuario “jlrvpuma” con contraseña “password” -puede ser cualquier cadena- y que tiene todos los permisos para la base de datos newdb y que se conectará a ella desde localhost.Si la conexión del cliente al servidor no fuera desde localhost, entonces se deberá cambiar localhost por el nombre del equipo pertinente.
A partir de este momento nos conectaremos a la base de datos con el usuario jlrvpuma:
$mysql -u jlrvpuma -p
Le indicamos a MySQL que vamos a utilizar la base de datos newdb:


mysql>USE newdb;

Creando una tabla:
Se usa la instrucción CREATE TABLE:


mysql> CREATE TABLE new_table(
-> user_id INT,
-> name VARCHAR(30),
-> last_name VARCHAR(40));

Visualizando tablas:
Se usa la instrucción SHOW TABLES :


mysql>SHOW TABLES;

Visualizando la estructura de una tabla:
Se usa la instrucción DECRIBE :


mysql>DESCRIBE new_table;

Insertando nuevos registros en una tabla:
Se utiliza la instrucción INSERT:


mysql> INSERT INTO new_table(user_id,name,last_name) VALUES(1,'Carlos','Villa');

También se puede hacer de una forma más sencilla:


mysql>INSERT INTO new_table VALUES(2,'Maritza','Rodriguez');

Pero se debe estar seguro del orden de los campos en la tabla, ya que se podría insertar datos en campos equivocados. Es recomendable usar la primera forma, de esa manera se reducen las posibilidades de errores, pues se puede apreciar el orden en que están siendo ingresados los campos.

Cambiando registros en una tabla:
Se usa instrucción UPDATE:


mysql>UPDATE new_table SET name='Yuri' WHERE user_id=2;

Eliminando registros en una tabla:
Se usa la instrucción DELETE:


mysql>DELETE FROM new_table WHERE user_id=4;

Se debe tener cuidado, ya que si no se especifica mediante WHERE qué registro debe ser eliminado, se borrarán todos los registros de la tabla.

Recuperando información de una tabla(o haciendo consultas):
Se usa la instrucción SELECT. Por ejemplo, si se quiere recuperar todos los campos, se usa el comodin *:


mysql> SELECT * FROM new_table;

O bien, si se quiere sólo algunos campos:


mysql> SELECT name,last_name FROM new_table;

usando la clausula WHERE:


mysql> SELECT name FROM new_table WHERE user_id=1;

Usando la instrucción LIKE y el comodín % :


mysql>SELECT * FROM new_table WHERE name LIKE 'Car%';

El símbolo % significa 0(cero) o más caracteres después de la cadena 'Car'.En otras palabras se recuperará los registros cuyo campo name empiece por 'Car'.
La instrucción :


mysql>SELECT * FROM new_table WHERE name LIKE '%r%';

recuperará todos los registros cuyo campo name empiece y termine por cualquier cadena pero que contenga la letra 'r'.
La instrucción :


mysql>SELECT * FROM new_table WHERE name LIKE 'M%a';

recuperará todos los registros cuyo campo name empiece con 'M' y termine en 'a'.

Usando la clausula ORDER BY:
También podemos combinar con la clausula ORDER BY para ordenar los resultado y podemos usar las palabras clave ASC y/o DESC para ordenar los resultados en orden ascendente o descendente respectivamente:


mysql> SELECT * FROM new_table ORDER BY name DESC;
mysql> SELECT * FROM new_table ORDER BY name ASC;

o bien:


mysql> SELECT *  FROM new_table ORDER BY name ASC, last_name DESC;

Usando la instrucción DISTINCT :
Útil cuando tenemos valores repetidos en dos o más campos y queremos los resultados sin repeticiones:


mysql> SELECT DISTINCT name FROM new_table;

Usando la clausula LIMIT:
Permite limitar el numero de resultados o limite de fila, además permite establecer el desplazamiento; es decir el numero de fila desde dónde empezará a contar, la estructura sería mas o menos: LIMIT desplazamiento,límite de fila
La instrucción :


mysql>SELECT * FROM new_table LIMIT 1,2;

recuperará la segunda y tercera fila. El primer valor, a la izquierda de la coma, en la clausula LIMIT, se refiere al desplazamiento, en este ejemplo, al ser su valor 1, empezará a contar desde la segunda fila ya que se empieza a contar desde 0(cero). Se puede omitir el valor de desplazamiento, poniendo sólo el valor de la derecha o límite de fila, MySQL asumirá el valor 0(cero) como valor de desplazamiento predeterminado. La siguiente instrucción recuperará las dos primeras filas :


mysql>SELECT *  FROM new_table LIMIT 2;

Usando funciones COUNT(), MAX(), MIN(),SUM(),AVG():
Para obtener el número de filas o registros:


mysql> SELECT COUNT(name) FROM new_table;

O bien si se quiere saber cuantos nombres diferentes hay:


mysql> SELECT COUNT(DISTINCT name) FROM new_table;

Para recuperar el mayor valor de un campo:


mysql> SELECT MAX(user_id) FROM new_table;

Para recuperar el menor valor de un campo:


mysql> SELECT MIN(user_id) FROM new_table;

Para recuperar la media :


mysql> SELECT AVG(user_id) FROM new_table;

Para recuperar el total de la suma de todos los valores de un campo:


mysql> SELECT SUM(user_id) FROM new_table;

Diagramas de interacción

2009-10-28T06:12:00.000-07:00

Diagramas De Interaccion

View more documents from jlrvpuma.

Casos de Uso

2009-10-13T22:26:00.000-07:00

Los casos de uso no son parte del diseño (Cómo) sino parte del análisis (Qué), de manera que nos ayudan a describir qué es lo que el sistema debe hacer. Cada caso de uso proporciona uno o más escenarios que indican cómo debería interactuar el sistema con el usuario o con otro sistema para conseguir un objetivo específico.Considérese un procesador de texto, dos casos de uso típico serían: "poner texto en negrita" y "crear índice" , por medio de estos ejemplos , se puede uno dar una idea de ciertas propiedades de los casos de uso :

El caso de uso capta alguna función visible para el usuario.
El caso de uso puede ser pequeño o grande.
El caso de uso logra un objetivo discreto para el usuario.

En su forma más simple el caso de uso se obtiene hablando con los usuarios habituales y analizando con ellos las distintas cosas que deseen hacer con el sistema.
Se debe abordar cada cosa discreta que quieran , darle un nombre y escribir un testo descriptivo breve (sólo unos cuantos párrafos).
No trate de obtener todos los detalles justo desde el principio, los podrá obtener cuando los necesite.
Sin embargo, si considera que un caso de uso dado tiene ramificaciones arquitectónicas de importancia, necesitará más detalles a la mano.
Lo realmente útil de los casos de uso es el documento que describe el caso de uso, en este documento se explica la forma de interactuar entre el sistema y el usuario.
Siguiendo con el procesador de texto, este podría ser el caso de uso de guardar un documento:

Nombre:	Guardar Documento
Autor:	jlrvpuma
Fecha:	14/10/2009
Descripción: Permite guardar un documento en el disco duro o cualquier medio de almacenamiento
Actores: Usuario del procesador de texto
Precondiciones: El usuario debe haber creado el documento
Flujo Normal: El actor pulsa sobre el botón para guardar el documento El sistema muestra una caja de texto para introducir el título del documento y una zona de mayor tamaño donde se muestra el árbol de directorios del sistema para elegir el directorio dónde sera guardado el documento El actor introduce el título del documento y elige el directorio donde se guardará el documento. El sistema comprueba la validez de los datos y los almacena.
Flujo Alternativo: El sistema comprueba la validez de los datos, si los datos no son correctos, se avisa al actor de ello permitiéndole que los corrija
Poscondiciones: El documento ha sido almacenado o guardado

Me he saltado los campos Nombre,Autor,Fecha,Descripción ya que son evidentes y no necesitan explicación
Los actores son aquellos que interactúan con el sistema. Las precondiciones son los hechos que se han de cumplir para que el flujo de evento se pueda llevar a cabo.El flujo normal corresponde a la ejecución normal y exitosa del caso de uso.Los flujos alternativos permiten indicar que es lo que hará el sistema en situaciones anormales o inesperadas.Por ultimo, las poscondiciones son los hechos que se han de cumplir si el el flujo de eventos normal se ha ejecutado normalmente.
Los casos de uso se pueden detallar mas o menos dependiendo del problema.
Cabe señalar que el documento del caso de uso mostrado es incompleto, puedes ver una plantilla de caso de uso completa AQUI, se les suele llamar casos de uso "full-dressed".

Diagramas de Casos de Uso

UML define una notación gráfica para realizar diagramas de casos de uso.Los diagramas de casos de uso son a menudo confundidos con los casos de uso. Mientras los dos conceptos están relacionados, los casos de uso son mucho más detallados que los diagramas de casos de uso.Cuando empiezas a tener un número considerable de casos de uso como el anterior, no resulta nada fácil situarlos y relacionarlos. Entonces empiezas a tener la necesidad de una visión general del asunto, y ahora si, es cuando los diagramas de casos de uso son de utilidad.
Los casos de uso están representados por elipses y los actores están representados por las figuras humanas, estas son al notación estándar de los actores, sin embargo, algunos utilizan otras figuras como una imagen de un computador por ejemplo, para representar un actor.
La figura siguiente muestra algunos de los casos de uso de un sistema de financiamiento : (extraído del libro UML Gota a Gota)

Hay cuatro actores en la figura: el gerente de comercio, el comerciante, el agente de ventas y el sistema de contabilidad.En la mencionada organización probablemente habrá diversos comerciantes.Además, un usuario puede desempeñar varios papeles.Por ejemplo, un comerciante de edad madura podría desempeñar el papel de gerente de comercio y además ser un comerciante normal.Por otra parte, un comerciante puede ser también agente de ventas.Cuando se trata con actores, conviene pensar en los papeles o roles, no en las personas ni en los títulos de sus puestos.
Los actores llevan a cabo casos de uso.Un mismo actor puede realizar muchos casos de uso;a la inversa, un caso de uso puede ser realizado por varios actores.Obsérvese que no es necesario que los actores sean seres humanos, a pesar que estén representados por figuras humanas en el diagrama del caso de uso.El actor puede ser también un sistema externo que necesita información del sistema actual.En la figura se puede apreciar la necesidad de actualizar cuentas (caso de uso: actualiza cuentas) del sistema de contabilidad.
Además de los vínculos entre los actores y los casos de uso, hay otros tipos de vínculos en el diagrama de casos de uso del sistema de financiamiento.Estos representan las relaciones de uses y extends entre los casos de uso.

Se usa la relación uses cuando es necesario que el caso de uso original haga uso de otro caso de uso, como en la figura de arriba, tenemos el caso de uso Analiza Riesgo, este caso de uso hace uso del caso de uso Valuación, le es necesario para cumplir su tarea, bien podría ir Valuación dentro de Analiza Riesgo, es decir hacer un solo caso de uso, pero eso hará mas oscuro el caso de uso y lo que se busca es simplificar.
La relación extends se usa cuando el caso de uso original tiene como extensión otro caso de uso, sin necesario su utilización, se podría decir que enriquece al caso de uso original; piénsese, para darse una idea, en las extensiones de firefox...

UML - Análisis y diseño

2009-10-13T22:23:00.000-07:00

El Lenguaje Unificado de Modelado o UML (Unified Modeling Language, por sus siglas en inglés) es como su nombre lo dice un lenguaje de modelado de sistemas de software, es decir Análisis y Diseño de sistemas de software, con el se construyen sistemas por medio de conceptos orientados a objetos :
¿Cómo deberían asignarse las responsabilidades a las clases de objetos?, ¿Cómo deberían interactuar éstos?, ¿Qué papel debe destinársele a cada clase?...Estas son preguntas muy importantes cuando se diseña un sistema.
Tambien se podrá decir de UML que es un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema de software.
Lo más importante en el analisis y el diseño orientados a objetos es asignar eficientemente las responsabildades a los componentes de software;el hecho de saber asignar responsabilidades es lo que en definitiva hace o destruye a un sistema.
Para crear una aplicacion de software hay que describir el problemas y las necesidades o requerimientos, es deicr en qué consiste el problema y ue debe hacerse.

El Análisis se centra en la investigación del problema y no la manera de definir una solución, por ejemplo, se quiere un sistema de inventario de una tienda, la pregunta a formularse en esta fase sería :¿Cuáles procesos de la tienda se relacionan con su uso(del sistema)? para asi identificar los objetos -o conceptos- dentro del dominio del problema,por ejemplo en el caso del sist. de inventario se identifican el concepto u objeto : Producto

El Diseño pone de relieve una solución lógica, cómo el sistema cumple con los requerimeintos, en esta fase se procura definir los objetos lógicos del software que finalmente seran implementados en un lenguaje de programacion orientado a objetos.Los objetos tienen atributos y metodos.Des esta forma el objeto Producto un atributo precio y un método calcularImpuesto.

Finalmente durante la construcción o programacón orientada a objetos se implementan los componentes del diseño, como una clase Producto, por ejemplo.

La orientación a objetos se centra en la representación de objetos

Modelado de Negocios

2009-10-13T22:18:00.000-07:00

Toda aplicación proporciona un servicio a su entorno. Este entorno es conocido como el dominio de la aplicación. El conocimiento del dominio de una aplicación es considerado como un factor crítico de éxito para el desarrollo de la aplicación; pues,es a partir de este conocimiento que los requisitos de la aplicación pueden ser definidos con mayor precisión.
El Modelado de Negocios es un proceso que permite modelar el entorno de una aplicación y, por ende, ganar un conocimiento profundo de los elementos conceptuales que integran ese entorno. Este proceso es, hoy en día, incorporado en la mayoría de méodos, como la primera actividad técnica que debe realizarse durante el desarrollo de software.

Cuanto mas se conozca del entorno mejor se podrá abarcar el modelado del problema o la Gestión de Requisitos y a su vez se abarcará el o losproblemascon un óptimo modelo de Solución.

Como en la figura de abajo, para tener un Modelo de Solución se debe tener un Modelo del Problema, si no lo hay o si este esta mal diseñado, la solución será un desastre, y para tener un modelo del problema o una buena gestión de requisitos se debe tener un buen modelo de negocios,es decir, un óptimo conocimiento del dominio de la aplicación,de lo contrario no habría un modelado de problemas y mucho menos un modelado de la Solución...

En otras palabras, si lo que se necesitas es:

Entender la estructura y dinámica de la organización para el cual se desarrollará un sistema.
Entender problema actuales en la organización e identificar mejoras potenciales.
Asegurar que el cliente, usuarios, y desarrolladores tienen un entendimiento común de la organización.
Derivar los requerimientos de sistema requeridos para soportar a la organización.[f]

entonces se debe realizar el Modelado de negocios.

Obteniendo Handle de una ventana mediante API´s - Windows

2009-10-04T10:57:00.000-07:00

Se puede obtener el handle de una ventana mediante su título o nombre de clase a la que pertenece llamando a la función FindWindow contenida en la librería user32.dll.Para poder acceder a la función es necesario agregar la directiva:
using System.Runtime.InteropServices;

Declarar la función aplicando el atributo DllImport(definido en System.Runtime.InteropServices).Ademas, notar el modificador extern:


[DllImport("user32.dll")]
public static extern IntPtr FindWindow(string lpClassName, string lpWindowTitle);

Ahora podemos llamarla.Por ejemplo, abrimos el Bloc de notas, nos fijamos en el título de la ventana:
Sin título - Bloc de notas
(Depende en qué idioma esté el S.O)

Para obtener el handle de esta ventana llamamos a la función FindWindow ya declarada mandando como parámetro el titulo del Bloc de notas y al otro parámetro le enviamos un valor null:
IntPtr hWndNotepad = FindWindow(null,"Sin título - Bloc de notas");

Notar que el handle se recibe en un tipo IntPtr.Además, si la función falla retorna un valor Null.

Para comprobar que, efectivamente, hemos obtenido el handle de la ventana requerida haremos una prueba:Cambiar el titulo de la ventana.
Para cambiar el título de una ventana haré uso de la función SetWindowText contenida en la librería user32.dll.Así que la declaro como hice con FindWindow :

[DllImport("user32.dll")]
public static extern bool SetWindowText(IntPtr hWnd, string newTitle);

Ahora ya puedo cambiar el titulo del Bloc de notas, mando como parametro el handle de la ventana y un string con el nuevo titulo:
bool v = SetWindowText(hWndNotepad, "¡¡¡¡¡¡ esto funciona !!!!!!");

Para obtener el handle de la ventana en la que se trabaja; es decir, la activa,es necesario llamar a la función GetForegroundWindow, también contenida en la librería user32.dll.Así que la declaramos como las demás:


 [DllImport("user32.dll")]
public static extern IntPtr GetForegroundWindow();

Llamamos a la función:


IntPtr hWndActual=GetForegroundWindow();

Al final el código quedaría:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//para llamar a apis:
using System.Runtime.InteropServices;

namespace APIsExamples
{
    class Program
    {
        [DllImport("user32.dll")]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowTitle);
        [DllImport("user32.dll")]
        public static extern bool SetWindowText(IntPtr hWnd, string newTitle);
        [DllImport("user32.dll")]
        public static extern IntPtr GetForegroundWindow();
       
        static void Main(string[] args)
        {
            IntPtr hWndNotepad = FindWindow(null, "Sin título - Bloc de notas");
            IntPtr hWndActual = GetForegroundWindow();
            Console.WriteLine("El handle del Bloc de notas es {0}", hWndNotepad);
            Console.WriteLine("El handle de la ventana activa es {0}", hWndActual);
            Console.WriteLine("\nCambiando el titulo de ventana del Bloc de notas...");
            bool v = SetWindowText(hWndNotepad, "¡¡¡¡¡¡ esto funciona !!!!!!");
            Console.WriteLine("\nListo.La opreación ha devuelto un valor {0}",v);

            Console.ReadKey();

        }
    }
}

Se puede recuperar los handle´s de las ventanas abiertas mediante la función GetWindow, aunque es mas eficiente hacerlo mediante la función EnumWindows.Esto se verá en otro post.

Montar Partición Windows en Ubuntu

2009-07-10T20:21:00.001-07:00

Primero hay que asegurarse de que el paquete ntfs-3g este instalado, de no ser asi procedemos a instalarlo, ya sea desde el gestor de paquetes synaptic que se encuentra en el menu de la barra de tareas superior, la ruta sería:
Sistema/Administración/Gestor de paquetes Synaptic

O bien procedemos a instalarlo desde la consola o terminal,con el comando:
sudo apt-get install ntfs-3g

Si ya esta instalado nos avisará que ya lo está.

El paquete ntfs-3g permite poder escribir y borrar en particiones con formato NTFS.

Luego, vemos en donde se encuentra la partición de windows, para eso escribimos en la consola o terminal:
sudo sfdisk -l
Lo que nos arrojará una lista, mas o menos así:

/dev/sda1  1    34    273456  83  NTFS
/dev/sda2  35   522   273456  83  LINUX

En vez de "sda" puede ser "hda" u otro valor.Por el momento asumiremos que windows se encuentra en sda1, ya que es la que tiene formato NTFS(el que usa windows).

Creamos un directorio, donde será montada la particionde windows.La crearemos en /home/usuario y la llamaremos Windows. Escribimos en consola:
sudo mkdir /home/usuario/Windows

Luego, montamos la partición en el directorio creado:
sudo mount -t ntfs-3g /dev/sda1 /home/usuario/Windows

Ahora, ya tenemos acceso a la partición de windows desde el directorio Windows.

Montando Particiones al arranque:

Si se quiere montar las particiones desde el arranque es necesario modificar el archivo fstab.Para eso lo abrimos con nuestro deitor de texto favorito.A continuación usaremos Gedit ya que viene instalado por defecto en Ubuntu.Escribimos en consola:
sudo gedit /etc/fstab
Se abrirá un archivo de texto con algunos datos.Asi que al final de todo escribimos esto:
/dev/sda1 /home/usuario/Windows ntfs-3g defaults 0 0

Guardamos los cambios y cerramos.A continuación escribimos en la consola:
sudo mount -a

Con esto ya deberíamos poder usar nuestra recien montada partición de windows.

Cabe aclarar que "usuario", en las rutas o path´s usados líneas arriba, se refiere al nombre de usuario del sistema; así, si el usuario es luis, entonces una ruta sería: /home/luis/Windows.

Data Binding V - LaTeX

2009-06-21T17:47:00.000-07:00

Código LaTeX

Ejemplo usando MultiBinding y MultiValueConverter .Lo que muestra es el código para generar una tabla en LaTeX:

Descargar
Nota: Se requiere el framework 3.5

Data Binding IV

2009-06-18T19:19:00.000-07:00

Multi Binding - IMultiValueConverter :
MultiBinding :
La clase MultiBinding describe una colección de objetos Binding asociados a una sola propiedad de destino de enlace.
MultiBinding permite enlazar una propiedad del destino de enlace a una lista de propiedades de origen y, a continuación, aplicar la lógica para generar un valor con las entradas indicadas.

IMultiValueConverter:
Proporciona una forma de aplicar la lógica personalizada a una clase MultiBinding.
Para asociar un convertidor a una clase MultiBinding, se debe crear una clase que implemente la interfaz IMultiValueConverter y, a continuación, los métodos Convert y ConvertBack.

En otras palabras, podemos tener múltiples propiedades de origen de enlace para una propiedad de destino de enlace.Sin embargo, la propiedad de destino de enlace sólo recibe una propiedad que no necesariamente es una de las de origen de enlace, sino el resultado de la lógica de conversion implementada en una clase que implementa la interfaz IMultiValueConverter.

Por ejemplo, la propiedad RenderTransform de un objeto Image recibe un objeto Transform que puede ser un ScaleTransform,RotateTransform,etc...
Para instanciar la clase RotateTransform se requieren -no necesariamente- tres valores de tipo double(angulo,coordenada X i Y del punto central de la rotación), los cuales se envían como parámetro a su constructor.

Ahora bien, Qué hago si tuviera una objeto Image al cual quisiera rotar de manera que el angulo de rotación y las coordenadas X i Y cambien en función de otros procesos?.

Pues, la respuesta es: MultiBinding + IMultiValueConverter.

Para hecerlo mas comprensivo he hecho un pequeño ejemplo.Una pequeña aplicación que rota un objeto Image en base a los valores de tipo double de la propiedad Value de tres Slider´s.
La propiedad RenderTransform(destino de enlace) del objeto Image, enlaza a tres propiedades de origen de enlace: la propiedad Value de cada Slider(líneas 33,34 y 35).

Muestro el código XAML :

   1:  <Window x:Class="TestWPF_Data_Binding_II.DataBinding_MultiBinding"

   2:      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:      xmlns:local="clr-namespace:TestWPF_Data_Binding_II"

   5:      Title="DataBinding_MultiBinding" Height="740" Width="768">

   6:      <Window.Resources>

   7:          <local:DoubleRotateTransform x:Key="Convertidor"/>

   8:      </Window.Resources>

   9:      <Grid>

  10:          <Grid.RowDefinitions>

  11:          <RowDefinition Height="57*" />

  12:          <RowDefinition Height="124*" />

  13:          <RowDefinition Height="521*" />

  14:          </Grid.RowDefinitions>

15:

  16:          <TextBlock Text="MultiBinding" FontSize="22" Grid.Row="0" HorizontalAlignment="Center"/>

17:

18:

  19:          <Slider Grid.Row="1" Margin="53,11,125,0" Name="slider1"  VerticalAlignment="Top"

  20:                  Minimum="0" Maximum="1000"

  21:                  ToolTip="{Binding RelativeSource={RelativeSource Self}, Path=Value}"/>

22:

  23:          <Slider Grid.Row="1" Margin="53,50,125,52" Name="slider2" Minimum="0" Maximum="1000"

  24:                  ToolTip="{Binding RelativeSource={RelativeSource Self}, Path=Value}" />

25:

  26:         <Slider Grid.Row="1" Height="21" Margin="53,0,125,18"

  27:                Name="slider3" VerticalAlignment="Bottom" Minimum="0" Maximum="360"

  28:                 ToolTip="{Binding RelativeSource={RelativeSource Self}, Path=Value}"/>

29:

  30:         <Image Grid.Row="2" Margin="128,81,117,175" Name="image" Stretch="Fill" Source="/TestWPF_Data_Binding_II;component/rotsnake.gif">

  31:              <Image.RenderTransform>

  32:                      <MultiBinding Converter="{StaticResource Convertidor}">

  33:                          <Binding ElementName="slider1" Path="Value"/>

  34:                          <Binding ElementName="slider2" Path="Value"/>

  35:                          <Binding ElementName="slider3" Path="Value"/>

  36:                      </MultiBinding>

  37:              </Image.RenderTransform>

  38:          </Image>

39:

  40:      </Grid>

  41:  </Window>

Vemos que, entre las lineas 32 y 38, se han enlazado tres propiedades de origen de enlace, las propiedades Value de tres Slider´s, para una sola propiedad destino de enlace.Además, notamos que, en la línea 33, se especifica la propiedad Converter para el MultiBinding :
Converter="{StaticResource Convertidor}"
Esto significa que el recurso estático Convertidor esta apuntando a una clase que implementa la interfaz IMultiValueConverter.En efecto, la clase se llama DoubleToRotateTransform.Ha sido instanciada en la línea 7.

En el método Convert se desarrolla la lógica de conversion de los tres valores de tipo double de la propiedad Value de cada Slider y se retorna un objeto RotateTransform, el cuál si admite la propiedad RenderTransform del objeto Image.
Es conveniente señalar que, debido a que el modo del binding es OneWay,sólo es necesario implementar el metodo Convert.

A continuación la clase DoubleToRotateTransform :


using System;
//requerido para IMultiValueConverter:
using System.Windows.Data;
//requerido para ScaleTransform:
using System.Windows.Media;
//requerido para CultureInfo culture:
using System.Globalization;

namespace TestWPF_Data_Binding_II
{
public class DoubleToRotateTransform:IMultiValueConverter
{
  /// <summary>
  /// Metodo que recibe dos valores de tipo double
  /// y retorna un ScaleTransform
  /// </summary>
  /// <param name="values">Colección de dos valores de tipo double</param>
  /// <param name="targetType"></param>
  /// <param name="parameter"></param>
  /// <param name="culture"></param>
   /// <returns>Retorna un ScaleTransform para la prop. RenderTransform de un image</returns>
  public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
  {
      double coorX = (double)values[0], coorY = (double)values[1], angulo=(double)values[2];
 
      RotateTransform rt = new RotateTransform(angulo,coorX, coorY);
      return rt;
  }

  public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
  {
      //Hacer conversiones si el modo es TWOWAY
      throw new NotSupportedException("No se puede convertir");
  }
}
}

Como se darán cuenta, los valores de las propiedades de origen de enlace pasan al metodo Convert como una colección de objetos(primer parámetro):
objetct[] values
Además, en la colección, estan en el orden en que fueron declarados en el enlace.Así, en la posición cero esta el valor dela propiedad Value de slider1; luego, en la posicion1, slider2 y finalmente slider3.

Nota: Cada propiedad Tooltip de cada Slider esta enlazando a la propiedad Value del mismo objeto al que pertenecen(líneas 21, 24 y 28):
ToolTip="{Binding RelativeSource={RelativeSource Self}, Path=Value}"

Captura :

Data Binding WPF III

2009-06-14T12:20:00.000-07:00

Cómo enlazar un Método :
El propósito del método es convertir Millas a Kilómetros. Recibe dos parámetros, un double especificando el valor de la distancia y un TipoDistancia especificando el tipo(Millas o Kilómetros).Retorna un String con el resultado de la conversión.
El metodo se llama Convertir y para eso he creado una clase llamada ConvertidorDistancia y también he creado la enumeración TipoDistancia:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestWPF_Data_Binding_II
{
public enum TipoDistancia
{
    Millas,
    Kilometros
}
public class ConvertidorDistancia
{
    /// <summary>
    /// Convierte Millas a Kilometros y viceversa.
    /// </summary>
    /// <param name="valorDist">Valor a convertir</param>
    /// <param name="tipoDistancia">Tipo de Distancia</param>
    /// <returns>Un string conteniendo el valor convertido</returns>
    public string Convertir(double valorDist, TipoDistancia tipoDistancia)
    {
        if (tipoDistancia == TipoDistancia.Millas)
        {
            return (valorDist * 1.609344).ToString("0.##") + " km";
        }
        if (tipoDistancia == TipoDistancia.Kilometros)
        {
            return (valorDist * 0.621371192).ToString("0.##") + " m";
        }
        throw new ArgumentOutOfRangeException("tipoDistancia");
    }

}

}

Para poder enlazar el método Convertir es necesario crear una instancia de la clase ConvertidorDistancia.Antes de hacerlo debemos agregar una referencia al espacio de nombre(namespace) donde se encuentra la Clase.En nuestro código Xaml sería la línea 4:

xmlns:local="clr-namespace:TestWPF_Data_Binding_II"

Donde local hace referencia al espacio de nombre TestWPF_Data_Binding_II.
Además he agregado system como referencia al espacio de nombres System(línea 5), pues ocuparé un objeto de tipo Double(línea 19).

   1:  <Window x:Class="TestWPF_Data_Binding_II.DataBinding_Method"

   2:      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml
"

   4:      xmlns:local="clr-namespace:TestWPF_Data_Binding_II"

   5:      xmlns:system="clr-namespace:System;assembly=mscorlib"

   6:      Title="DataBinding_Method" Height="300" Width="300">

   7:      <Window.Resources>

8:

   9:          <!-- Instancia de la clase DoubleToString que impl
ementa a IValueConverter -->

  10:          <local:DoubleToString x:Key="doubleToString" />

11:

  12:          <!-- ObjectDataProvider pone al metodo como fuente de datos(origen de enlace/binding source) -->

  13:              <ObjectDataProvider

  14:              x:Key="ConvertirDistancia"

  15:              ObjectType="{x:Type local:ConvertidorDistancia }"

  16:              MethodName="Convertir" >

  17:                  <!-- Declaramos los parametros que recibe el metodo Convertir-->

  18:                  <ObjectDataProvider.MethodParameters>

  19:                      <system:Double>10</system:Double>

  20:                      <local:TipoDistancia>Millas</local:TipoDistancia>

  21:                  </ObjectDataProvider.Method
Parameters>

  22:              </ObjectDataProvider>

  23:      </Window.Resources>

24:

  25:      <Grid Margin="10">

  26:          <Grid.ColumnDefinitions>

  27:              <
ColumnDefinition Width="0.5*"/>

  28:              <ColumnDefinition Width="0.5*"/>

  29:          </Grid.ColumnDefinitions>

  30:          <Grid.RowDefinitions>

  31:              <RowDefinition Height="31" />

  32:              <RowDefinition Height="31" />

  33:              <RowDefinition Height="31" />

  34:          </Grid.RowDefinitions>

35:

  36:          <TextBlock Margin="5" Grid.ColumnSpan="2"

  37:                     VerticalAlignment="Center"

  38:                     Text="Ingrese una distancia para convertir :"/>

39:

  40:          <!-- Este TextBox enlazara al primer parametro del metodo Convertir  -->

  41:          <TextBox

  42:              Grid.Row="1" Grid.Column="0" Margin="5"

  43:              Text ="{Binding Source={StaticResource ConvertirDistancia}, Path=MethodParameters[0],

  44:                      BindsDirectlyToSource=true, UpdateSourceTrigger=PropertyChanged,

  45:                      Converter={StaticResource doubleToString}}"/>

46:

  47:          <!-- Este ComboBox enlazara al segundo parametro del metodo Convertir -->

  48:          <ComboBox

  49:              Grid.Row="1" Grid.Column="1" Margin="5" Width="80"

  50:              HorizontalAlignment="Left"

  51:              SelectedValue="{Binding

  52:                              Source={StaticResource ConvertirDistancia},

  53:                              Path=MethodParameters[1],

  54:                              BindsDirectlyToSource=true}" >

  55:              <local:TipoDistancia>Millas</local:TipoDistancia>

  56:              <local:TipoDistancia>Kilometros</local:TipoDistancia>

  57:          </ComboBox>

  58:          <TextBlock Grid.Row="2" HorizontalAlignment="Right" Margin="5"

  59:                     Text="Resultado:"/>

60:

  61:          <!-- Este TextBlock enlaza al resultado del metodo Convertir, es decir, lo que retorna.-->

  62:          <TextBlock Grid.Row="2" Grid.Column="1" Margin="5"

  63:                     Text="{Binding Source={StaticResource ConvertirDistancia}}"/>

64:

  65:      </Grid>

  66:  </Window>

Ahora ya podemos instanciar la clase ConvertidorDistancia y tenerlo como recurso.Para eso debe ir dentro de:

<Window.Resources>

</Window.Resources>

.Y puesto que voy a enlazar el metodo Convertir debo instanciar la clase ConvertidorDistancia mediante la clase ObjectDataProvider.Esta clase ajusta y crea un objeto que se puede utilizar como origen de enlace.La operación comienza en la línea 13 y termina en la línea 22.
En la línea 14 le asignamos una clave a nuestro origen de enlace: x:Key="ConvertirDistancia"
En la línea 15 definimos el tipo de la instancia que creamos mediante el objeto ObjectType:
ObjectType="{x:Type local:ConvertidorDistancia }"
Mediante la propiedad MethodName definimos el metodo que es invocado por ObjectDataProvider:
MethodName="Convertir"
Dado que el metodo Convertir, el que enlazaremos, recibe dos parametros, los definimos mediante la propiedad de ObjectDataProvider: MethodParameters(Línea 18):
<ObjectDataProvider.MethodParameters>
Esta propiedad puede contener una colección de parametros.
Definimos el valor inicial del primer parametro.Será el valor 10 y será de tipo Double, ya que el primer parametro que recibe el metodo Convertir es un tipo Double(linea 19):
<system:Double>10</system:Double>
Tambien definimos el valr inicial del segundo parametro, el cual será Millas de tipo TipoDistancia(línea 20) :
<local:TipoDistancia>Millas</local:TipoDistancia>

Ya tengo listo el objeto para poder usarlo como origen de enlace.

Tenemos un TextBox(línea 41), un ComboBox(línea 48) y un TextBlock(línea 58).
La propiedad Text del TextBox enlazará al primer parametro del metodo Convertir.La propiedad SelectedValue del ComboBox enlazará al segundo parametro.La propiedad Text del TextBlock enlazará al metodo Convertir, es decir a su valor de retorno, el cual será un String.
En la línea 43 le decimos que nuestro origen de enlace(o fuente de datos) es el recurso estático llamado ConvertirDistancia.Recordemos que ConvertirDistancia es la clave del metodo Convertir,asi que apunta a este.Luego, definimos el valor de la propiedad Path.Aqui ocurre algo interesante.Vemos que la propiedad que queremos enlazar no es una propiedad del objeto que envuelve ObjectDataProvider(ConvertidorDistancia), sino que es una propiedad del mismo objeto ObjectDataProvider, la propiedad MethodParameters, y es el primer valor de la colección de parametros, osea el primer parametro, por eso la posicion cero:
Path=MethodParameters[0]
A continuacion vemos la propiedad BindsDirectlyToSource:
BindsDirectlyToSource=true
Esta propiedad establece un valor que indica si se va a evaluar la propiedad Path con respecto al elemento de datos(en este caso ConvertidorDistancia) o el objeto DataSourceProvider(en este caso ObjectDataProvider, ya que deriva de la clase abstracta DataSourceProvider).
El valor por defecto de esta propiedad es false.Cuando es false evalua la ruta de acceso con respecto al elemento de datos propiamente dicho; de lo contrario, es true, es decir, en nuestro caso evuluará la ruta de acceso respecto al obejto ObjectDataProvider.Esto debe ser así, ya que la propiedad Path tiene el valor de una propiedad de ObjectDataProvider(MethodParameters) y no del elemento de datos.
Luego tenemos la propiedad UpdateSourceTrigger:
UpdateSourceTrigger=PropertyChanged
Esto significa que desde el TextBox podremos actualizar el valor del origen de enlace, es decir el valor del primer parametro del metodo Convertir.El valor PropertyChanged significa que tan pronto haga un cambio en el TextBox actualizará el origen de enlace con el valor de la propiedad Text del TextBox.Finalmente tenemos la propiedad Converter del cual me ocuparé mas adelante.
En cuanto al ComboBox sucede casi lo mismo,excepto que va a enlazar al segundo parametro del metodo Convertir.Se definen los itemes de tipo TipoDistancia:

<local:TipoDistancia>Millas</local:TipoDistancia>
<local:TipoDistancia>Kilometros</local:TipoDistancia>

La propiedad Text del TextBlock enlaza al resultado del metodo Convertir, es decir a su valor de retorno:
Text="{Binding Source={StaticResource ConvertirDistancia}}"

La propiedad Source del Binding se usa para referenciar a una instancia de un objeto creado como recurso.

Propiedad Converter:
Se usa cuando es necesario convertir valores de propiedades antes de asignarse al destino de enlace o al origen de enlace.Para eso es necesario crear una clase que implemente la interfaz IValueConverter.La inetrfaz IValueConverter tiene dos metodos:
Convert y ConvertBack, donde podemos implementar cualquier conversion compleja.El metodo Convert es llamado cuando el modo de enlace es OneWay, es decir, cuando el origen de enlace modifica al destino de enlace(destino de datos).El metodo ConvertBack es llamado en el modo TwoWay, es decir, cuando el destino de enlace modifica el origen de enlace.
Cuando se especifica la propiedad Converter en un enlace o binding el valor del destino de enlace no se actualiza directamente desde el origen de enlace, sino que pasa primero por el método Convert, ahi se hace la conversion para retornar el valor apropiado que recibe el destino de enlace.
Para poder usarlo como un recurso es necesario instanciarlo.En nuestro ejemplo lo hicimos en la línea 10:
<local:DoubleToString x:Key="doubleToString" />
A continuación la clase que implementa a IValueConverter, se llama DoubleToString, aunque en el metodo ConvertBack mas bien convierte de string a Double:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//para implementar ivalueconverter
using System.Windows.Data;
//necersario para CultureInfo
using System.Globalization;

namespace TestWPF_Data_Binding_II
{ 

  [ValueConversion(typeof(double), typeof(String))]
  public class DoubleToString: IValueConverter
  {
      /// <summary>
      /// Convierte Double a String.Antes de actualizar el valor del destino de enlace
      ///el valor pasa por este metodo para ser convertido a String.
      /// </summary>
      /// <param name="value">Objeto double</param>
      /// <param name="targetType"></param>
      /// <param name="parameter"></param>
      /// <param name="culture"></param>
      /// <returns></returns>
      public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
      {
          double val = (double)value;
          return val.ToString();
      }

      /// <summary>
      /// Covierte String a Double.Antes de actualizar el valor del origen de enlace
      /// el valor pasa por este metodo para ser convertido a Double.
      /// </summary>
      /// <param name="value">Objeto string</param>
      /// <param name="targetType"></param>
      /// <param name="parameter"></param>
      /// <param name="culture"></param>
      /// <returns></returns>
      public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
      {
          //throw new NotImplementedException();-->cuando no es necesario implementar el metodo.
          double val = Double.Parse(value.ToString());
          return val;
      }


  }
}

En nuestro ejemplo, el TextBox que enlaza al primer parámetro del metodo Convertir, recibe un string, ya que su propiedad Text soporta el tipo String.El modo del enlace es TwoWay(recordar la propiedad UpdateSourceTrigger), ya que podemos modificar el primer parámetro del metodo Convertir desde el TextBox.Aquí surge un inconveniente, la propiedad Text del TextBox contiene un String y el primer parametro del metodo Convertir es un tipo Double.En este momento entra en acción el metodo ConvertBack, es decir, antes de actualizar el origen de enlace(el primer parametro del metodo Convertir) el valor del destino de enlace (propiedad Text del TextBox) pasa por el metodo ConvertBack.Como notarán, en ese método el string se convierte a Double y se retorna un Double.Este Double es el que actualiza finalmente el primer parámetro del metodo Convertir.
Recordaran que se le habia asignado un valor inicial a los parametros del metodo Convertir(linea 19 y 20).Ocupemonos del primer parámetro:
Vemos que es el valor 10 de tipo Double.Tambien vemos que la propiedad que se enlazo al TextBox fue el primer parametro, es decir, un valor de tipo Double.Aqui entra en acción el metodo Convert.Antes de actualizar el TextBox con un Double desde el origen de enlace, el valor Double pasa por el metodo Convert, ahi se convierte a String y devuelve un String.Pues la propiedad Text del TextBox admite el tipo String.

Esa magia se logra implementando IValueConverter y especificando la propiedad Converter en el enlace:
Converter={StaticResource doubleToString}}
Aqui le decimos que Converter igual al recurso estático llamado doubleToString.Ya sabemos que es la clave de la clase DoubleToString.

captura:

Data Binding WPF II

2009-06-13T23:32:00.000-07:00

Enlazando un XML:

El codigo XAML:
namespace :TestWPF_Data_Binding_II
nombre de la ventana :DataBinding_XMLData


<Window x:Class="TestWPF_Data_Binding_II.DataBinding_XMLData"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="DataBinding_XMLData" Height="300" Width="300">
    <Window.Resources>
        <!--Usar la propiedad Source de XmlDataProvider si tenemos el archivo xml
            referenciandolo con la Uri apropiada, como se muestra en el sgte codigo: -->
        <!--<XmlDataProvider x:Key="PerrosXML"
                             Source="Perros.xml"
                             XPath="Perros"/>-->
        
        <!-- O podemos embeber directamente el xml : -->
        <XmlDataProvider x:Key="PerrosXML">
            <x:XData>
                <!--Si -cuando el xml va embebido- no se deja vacío el atributo xmlns, se producirá un 
                    error, la salida será : "System.Windows.Data.Error exception has occurred"-->
                <Perros xmlns="" >
                    <Perro Nombre="Alco" Color="Blanco" />
                    <Perro Nombre="Güeso" Color="Gris" />
                    <Perro Nombre="Pellejo" Color="Negro" />
                </Perros>
            </x:XData>
        </XmlDataProvider>
    </Window.Resources>
    
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="80" />
            <RowDefinition />
        </Grid.RowDefinitions>
        
        <TextBlock Text="Bind To XML Data" FontSize="15"
                   HorizontalAlignment="Center" Grid.Row="0" Margin="3" />
        <TextBlock Text="Enlazando un archivo XML" FontSize="15"
                   HorizontalAlignment="Center" Grid.Row="0" Margin="29" />
        
        <ListBox
            ItemsSource="{Binding Source={StaticResource PerrosXML},
            XPath=/Perros/Perro/@Nombre}" Grid.Row="1" HorizontalAlignment="Center"/>
    </Grid>
</Window>

Data Binding WPF

2009-05-31T23:03:00.000-07:00

Explicación breve acerca de cómo usar data binding en wpf y ademas qué es data binding.
Disculpen las redundancias en la explicación, pero mejor dejar todo claro....

Modo One Way :

Modo Two Way :

Enlazar un objeto CLR - Modo Two Way :

Codigo - Visual Studio 2008:
Descargar

Patron de Creación Abstract Factory

2009-05-03T16:40:00.000-07:00

Abstract Factory -Design Pattern - GoF

View more presentations from jlrvpuma.

Código de ejemplo escrito en C# :
Descargar (VS2008)
Descargar (MonoDevelop)

Patron de comportamiento Chain Of Responsability

2009-05-02T11:17:00.000-07:00

Chain Of Responsability

View more presentations from jlrvpuma.

Código de ejemplo C#:
Descargar (Visual Studio)
Descargar (Monodevelop)

Patrón de estructura Facade

2009-05-02T10:59:00.000-07:00

Facade - Design Pattern - GoF

View more presentations from jlrvpuma.

Código de ejemplo en C#:
Descargar (Visual Studio)
Descargar (MonoDevelop)

Patrón de creación Bulider

2009-05-02T09:29:00.000-07:00

Builder - Design Pattern - GoF

View more presentations from jlrvpuma.

Código de ejemplo C# :
Descargar (Visual Studio)
Descargar (MonoDevelop)

Configurar APACHE 2 en Ubuntu Intrepid Ibex

2009-04-11T12:27:00.000-07:00

Despues de haber instalado Apache2 exitosamente, podemos probar si el servidor funciona.En nuestro navegador favorito, escribimos en la barra de direcciones:
http://localhost
Y obtendremos algo como esto:
Si algún error ocurre debemos editar el archivo de configuración apache2.conf con el editor de texto que se prefiera, en este caso usaremos gedit :
$sudo gedit /etc/apache2/apache2.conf

Agregamos la siguiente linea en cualquier lugar del archivo de configuración:
ServerName localhost

Guardamos los cambios y luego reiniciamos Apache :
$sudo /etc/init.d/apache2 restart

Ahora probamos con localhost y si obtenemos el: "It works!", estamos listos para configurar Apache para que nos sirva nuestro propio sitio.

Creamos un nuevo sitio

Podemos crear un directorio de nuestro sitio en cualquier parte, en este caso se creará en :
$mkdir /home/usuario/mi_website

Ahora crearemos el archivo de configuración para el nuevo sitio.Podemos hacerlo a partir del archivo de configuración del sitio por defecto. Al nuevo archivo lo llamaré miweb :
$sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/miweb

Abrimos el nuevo archivo de configuración:
$sudo gedit /etc/apache2/sites-available/miweb

Buscamos la línea:
DocumentRoot /var/www/

Y cambiamos la ruta por la del directorio que creamos anteriormente:
DocumentRoot /home/usuario/mi_website

Luego buscamos la línea :
Y modificamos la ruta, con lo que deberá quedar así:

Guardamos los cambios.
A continuación deshabilitamos el sitio por defecto, deshabilitando su archivo de configuración, el cual es default.Para eso usamos el script de Apache:
$sudo a2dissite default

Seguidamente activamos nuestro nuevo sitio, habilitando su archivo de configuración.Para eso usamos otro script de Apache:
$sudo a2ensite miweb

Finalmente reiniciamos apache:
$sudo /etc/init.d/apache2 restart

Para probar si todo ha salido bien podemos crear un archivo index.html y guardarlo en :
/home/usuario/mi_website

Antes de ingresar a nuestro nuevo sitio, limpiamos la cache del navegador, en Firefox esta en Herramientas/Limpiar datos privados.
Ahora ya podemos ingresar a nuestro nuevo sitio. Escribimos en el navegador:
http://localhost

Y Listo. Ya tenemos nuestro servidor funcionando.

Fuente : www.zaphu.com

Instalando AptanaStudio en Ubuntu Intrepid Ibex

2009-04-05T16:55:00.002-07:00

Antes de instalar AptanaStudio debemos instalar sus dependencias:
$sudo apt-get install sun-java6-jre sun-java6-plugin xulrunner

Luego, descargamos el paquete desde su página:
http://www.aptana.com/studio/download

El siguiente paso es descomprimir el archivo .zip.En mi caso he descomprimido en /opt :
$sudo unzip Aptana_Studio_Setup_Linux_1.2.5.zip -d /opt

por lo que en /opt obtendré el directorio aptana.Puede ser descomprido en cualquier lugar.

Una vez obtenido el directorio aptana, creamos un script que se encargara de iniciar ApatanaStudio.Otra vez, el script puede ser guardado donde se desee, en mi caso crearé un nuevo directorio llamado Scripts y dentro uno llamado Aptana, dentro de este último guardaré el script que iniciará AptanaStudio y lo llamaré iniciaAptana.sh.
Entoces, creo los directorios y me ubico en el directorio recien creado Aptana:
$mkdir /home/usuario/Scripts/Apatana && cd /home/usuario/Scripts/Aptana

Creo el archivo iniciaApatana.sh (notar que estoy aun en el directorio Aptana) :
$ sudo gedit iniciaApatana.sh

En el Editor de texto que se abre a continuación agrego las siguientes líneas:


#!/bin/bash
export MOZILLA_FIVE_HOME=/usr/lib/xulrunner
/opt/aptana/AptanaStudio  #ruta al archivo AptanaStudio, que esta dentro del directorio aptana

La penúltima linea del script:
/opt/aptana/AptanaStudio
es la ruta al archivo ejecutable de AptanaStudio y que tiene este mismo nombre, se encuentra en el directorio aptana.Como en mi caso extraje el directorio aptana en /opt, la ruta correspondiente seria la que se muestra en la ultima linea del script:
/opt/aptana/AptanaStudio

Ahora debemos darle permisos de ejecucion al nuestro script.Si estamos o no aun en el directorio Scripts:
$sudo chmod 777 /home/usuario/Scripts/Aptana/iniciaAptana.sh

Ahora solo basta con darle doble click al archivo iniciaAptana.sh y si sale un aviso, escogemos en sus opciones: Ejecutar.

O bien se puede iniciar desde la consola :
$/home/usuario/Scripts/Aptana/iniciaAptana.sh

En modo background para seguir usando la misma consola para otras cosas:
$(/home/usuario/Scripts/Aptana/iniciaAptana.sh)&

Pero para hacernos la vida mas fácil, vamos a crear un enlace directo en la barra de menú:
Primero descargamos los iconos oficiales de AptanaStudio desde Aqui.
Luego los descomprimimos en donde sea(un lugar seguro, para no borrralo sin darnos cuenta), en mi caso descomprimiré en /home/usuario/Scripts/Aptana, si, junto al script:
$unzip aptana_icons.zip -d /home/usuario/Scripts/Aptana

Luego:

clic derecho sobre Aplicaciones y escoger editar menús
En la Izquierda, en Menús, clic sobre Programación(o la sección que se desee)
A la derecha, escoger : + Elemento Nuevo
para escoger el icono, clic sobre el cuadro superior izquierdo.Clic examinar y buscamos en /home/usuario/Scripts/Aptana. Le damos Abrir y escogemos el icono.
Asi quedará al final:

Eso es es todo. Ahora podemos abrir ApatanaStudio desde el Menú:
Aplicaciones/Programación/Aptana Studio

Nota:
El simbolo "$" no debe ser incluido al momento de escribir los comandos.
Ademas "usuario" se refiere al usuario del sistema, así, si el usuario es luis, entonces una ruta seria: /home/luis/cualquier/directorio.

Montar Imagen de Nero NRG en Ubuntu

2009-04-02T23:22:00.000-07:00

Para montar una imagen de CD/DVD con formato .nrg(formato de Nero) en ubuntu, no es necesario instalar acetoneiso, ya que para que funcione bien hay que instalar sus dependencias...
Solo es necesario el paquete mount, que ya viene instalado por defecto en Ubuntu.

Ahora bien, digamos que se tiene el archivo imagen.nrg(la imagen de cd/dvd) en /home/user.
Nos colocamos en /home/user:
$cd /home/user

Para montar la imagen se crea un directorio, se llamará dirmontaje:
$sudo mkdir dirmontaje

Montamos la imagen en el directorio creado, aun estamos en /home/user:
$sudo mount -t iso9660 -o loop imagen.nrg /home/user/dirmontaje

Listo!. A Disfrutar.

Expresiones Regulares - Validar número de telefono

2009-03-17T20:51:00.001-07:00

¿Qué son expresiones regulares?,según la Wikipedia:

Una expresión regular, a menudo llamada también patrón, es una expresión que describe un conjunto de cadenas sin enumerar sus elementos.[...]Las expresiones regulares son un método por medio del cual se pueden realizar búsquedas dentro de cadenas de caracteres. Sin importar si la búsqueda requerida es de dos caracteres en una cadena de 10 o si es necesario encontrar todas las apariciones de un patrón definido de caracteres en un archivo de millones de caracteres, las expresiones regulares proporcionan una solución para el problema. Adicionalmente, un uso derivado de la búsqueda de patrones es la validación de un formato específico en una cadena de caracteres dada, como por ejemplo fechas, números de teléfono o identificadores.

A continuación los los caracteres comodín usados para crear las expresiones regulares:

Significado	Ejemplo	Resultado
\ Marca de carácter especial	/\$ftp/	Busca la palabra $ftp
^ Comienzo de una línea	/^-/	Líneas que comienzan por -
$ Final de una línea	/s$/	Líneas que terminan por s
. Cualquier carácter (menos salto de línea)	/\b.\b/	Palabras de una sóla letra
\| Indica opciones	/(L\|l\|f\|)ocal/	Busca Local, local, focal
( ) Agrupar caracteres	/(vocal)/	Busca vocal
[ ] Conjunto de caracteres opcionales	/escrib[aoe]/	Vale escriba, escribo, escribe

La tabla que sigue describe los modificadores que pueden usarse con los caracteres que forman el patrón.Cada modificador actúa sobre el carácter o el paréntesis inmediatamente anterior.

Símbolo	Descripción	Ejemplo	Resultado
*	Repetir 0 o más veces	/l*234/	Valen 234, 1234, 11234...
+	Repetir 1 o más veces	/a+mar/	Valen amar, aamar, aaamar...
?	Repetir 1 o 0 veces	/a?mar/	Valen amar, mar.
{n}	Exactamente n veces	/p{2}sado	Vale ppasado
{m,n}	Entre m y n veces	/car{1,3}o/	Vale caro, carro, carrro

Para validar un numero de telefono:


function ValidaTelef(string_numero)
{
/*creo la expresion regular y se la asigno a una variable
aceptará numeros como: 83294325,88173764,8... */

var filter = /^[8]{1}[1-9]{2}[0-9]{5}$/;

/*llamo a la funcion test pasandole la cadena numero
Devuelve true si el numero coincide y false en caso contrario*/

return filter.test(string_numero);
}

Cancelar tecla ENTER de un formulario mediante j avascript y jQuery

2009-03-16T22:20:00.000-07:00

A veces se tiene la necesidad de anular la tecla Enter de un formulario para evitar el submit.Para eso bien podría hacerse usando sólo javascript, sin embargo, en este ejemplo usaré la librería jQuery. Aquí explican que es jQuery y lo pueden descargar en su versión más reciente desde su página.
Para no mezclar el codigo HTML con javascript en unmismo documento, el codigo javacript lo hare otro aparte, al cual llamaré funciones.js y junto a este colocaré la libreria jQuery.

Código en funciones.js :


var x;

x=$(document);

x.ready(AnularEnter);



function AnularEnter()

{

var x;

x=$("#form1");

x.keypress(function(e){if(e == 13){return false;}});



/*para los textboxes*/

$("input[type=text]").keypress(function(e){

if(e.which == 13){ return false; } });



/*para los radio*/

$("input[type=radio]").keypress(function(e){

if(e.which == 13){ return false; } });



/*para los checkboxes*/

$("input[type=checkbox]").keypress(function(e){

if(e.which == 13){ return false; } });



}

Explicación

La librería jQuery nos facilita la vida al momento de escribir codigo, en el ejemplo anterior, en la línea:
x=$("#form1");
se obtiene al formulario mediante su Id, el cual en el ejemplo es form1.En javascript puro seria:
x= getElementById('form1');
Es decir, para seleccionar un elemento del DOM se usa la función $
Para seleccionar mediante el Id del elemento:
$("#elId");
Aunque en el ejemplo no se muestre, también se puede seleccionar mediante su clase:
$(".laClass");
Notar las diferencias: #(almohadilla) para Id y .(punto) para class.
Volviendo al ejemplo, tambien puedo seleccionar un elemento del DOM mediante su tipo:



$("input[type=text]");

Como se ve en el ejemplo anterior, se seleccionan todos los textbox, todos los radiobuttons y todos los checkboxes.

El numero 13 corresponde a la tecla Enter, asi que en:



$("input[type=text]").keypress(function(e){

if(e.which == 13){  return false;      }    });

le digo que si esta en un textbox y presiona(evento keypress) la tecla Enter, retorne un valor false, de esa forma la tecla Enter queda anulada y no se produce el submit.
De la misma forma funciona para los demás controles.
Notar que le paso como argumento e, e contiene las características del evento; es decir, tiene la información necesaria para ese evento.

También podemos prescindir de jquery y usar solo javascript,en este caso el evento sería onkeypress:


<html>

<head><title>Test-Submit</title>

<script type="text/javascript">

    function CancelSubmit(e)

    {

        var keynum

        if(window.event) // IE

        {

            keynum = e.keyCode

        }

        else if(e.which) // Netscape/Firefox/Opera

        {

            keynum = e.which

        }        

        return (keynum != 13);

    }

</script>

</head>

<body>

<h1>CANCELAR SUBMIT</h1>

<form method="post" action="Test-Submit.html">

  <input type="text" onkeypress="return CancelSubmit(event)" />

</form>

</body>

</html>

UML

2008-10-13T22:11:00.000-07:00

Modelado de Negocios

UML - Análisis y diseño

Casos de uso

Diagramas de Interacción

TortoiseSVN - Cliente de Subversion

2008-09-25T20:59:00.000-07:00

AVISO : Son autoejecutables de Adobe Captivate .

1 - Como Crear un repositorio y una copia local de trabajo:
Descargar

2 - Actualizar Repositorio(Commit) :
Descargar

3 - Crear Ficheros y directorios nuevos y subirlos al repositorio(Versionarlos):
Descargar

4 - Solucionar Conflictos con TortoiseSVN :
Descargar