Archivos de los Ejemplos de Eventos del Teclado en WindowsForms

Octavio Telis Aynés — Thu, 31 May 2007 07:28:00 GMT

Hola… ¿Qué tal? En el artículo que publiqué anteriormente referente al uso de los eventos del teclado hay dos ligas a los ejemplos que acompañan al artículo, son las ligas a archivos comprimidos, uno para el ejemplo en VB.NET y otro para el ejemplo en...(read more)

Eventos del teclado en WindowsForms

Octavio Telis Aynés — Fri, 06 Apr 2007 05:38:00 GMT

Hace algún tiempo escribí este artículo, quisiera compartirlo para los principiantes, cada día hay uno nuevo rondando por la red.

Usos de los eventos del teclado

Octavio Telis Aynés
Tutordes

Junio 2004

Resumen: Durante el desarrollo de aplicaciones es común que surja la necesidad de aplicar combinaciones de teclas o identificar alguna tecla presionada por el usuario con el objetivo de realizar alguna tarea o para dotar de accesos directos que provean de funcionalidad extendida a las aplicaciones. Este artículo muestra de una manera introductoria y práctica el modo de utilizar los eventos de teclado para "atrapar" la combinación de teclas deseado o identificar la tecla presionada y ejecutar una acción determinada.

Contenido

Introducción
Uso del evento KeyDown y KeyPress para navegar entre controles
Uso del evento KeyUp para detectar la combinación de teclas

Introducción

Los controles para Windows Forms proveen de eventos para el manejo de las acciones del usuario con el teclado, estos eventos llegan a ser un poco diferentes entre sí dependiendo de la acción realizada por el usuario. Dichos eventos son KeyPress, KeyDown y KeyUp, la diferencia entre estos son los argumentos que reciben, para el primero se recibe la información del evento en una argumento del tipo System.Windows.Forms.KeyPressEventArgs, que expone métodos y propiedades para saber si el evento ha sido manejado (handled) o el caracter que devuelve la tecla presionada (KeyChar), este evento es útil cuando se desea obtener el caracter que fue presionado, por ejemplo para manejar la tecla Enter. Los otros dos eventos, KeyDown y KeyPress tienen firmas idénticas, sin embargo, KeyDown sucede al momento de presionar una tecla (cuando la tecla va hacia abajo) y KeyUp sucede al momento de soltar la tecla (cuando la tecla va hacia arriba), ambos reciben información del evento por medio de un argumento del tipo System.Windows.Forms.KeyEventArgs, a diferencia de KeyPressEventArgs, este tipo expone más información sobre la acción del usuario, esta información está contenida en distintas propiedades, por ejemplo Alt que indica si se presionó la tecla "alt" análogamente se comportan las propiedades Control, Shift, etc. La secuencia en que se lanzan los eventos es empezando por el KeyDown seguido el KeyPress y para finalizar el KeyUp, es importante hacer notar que estos eventos se lanzan cada vez que una tecla es presionada.

Podemos utilizar los eventos del teclado para distintas tareas, simplemente hay que tener en cuenta en qué momento debemos evaluar la acción del usuario para tener una ejecución en el tiempo exacto y de manera transparente.

Uso de los eventos KeyDown y KeyPress para navegar entre controles

En este ejemplo se muestra el uso del evento KeyDown y KeyPress para cambiar el foco de un control a otro usando la tecla Enter en lugar de la tecla de tabulación (Tab).

El código de este ejemplo está disponible en VB.NET y VC#.

Comúnmente es típico escuchar sobre la navegación entre controles de texto en aplicaciones y no es extraño encontrarse preguntas sobre el tema en los newsgroups y foros de discusión de .net, pues bien, como un intento de documentar de manera práctica el caso, en esta sección se muestra la manera común de hacerlo, es obvio que puede ser mejorado y que de acuerdo al interés y necesidades del desarrollador también podría ser modificado para responder a necesidades más específicas.

Este ejemplo utiliza TextBoxes para la demostración, no es raro que sean los que en este caso se utilicen ya que el objetivo de usar la navegación entre controles es para agilizar la captura de datos aprovechando la experiencia de un gran número de usuarios que utilizan la tecla Enter para pasar de un campo de captura a otro. Utilizaremos básicamente dos eventos de teclado, KeyDown será utilizado para pasar el enfoque del control en cuestión al siguiente control y el evento KeyPress se utilizará para eliminar el "beep" que sucede la usar la tecla Enter cuando la acción del usuario se ha manejado previamente en otro evento. También, aprovechando el camino que estamos trazando, veremos un principio básico de la reutilización de eventos para la misma familia de controles el mismo principio se aplica para la creación de componentes de procesos de interfase de usuario que en otra ocasión podremos discutir con más detalle.

Pues bien, debemos crear lo que será nuestro proyecto de prueba llamado Ejemplo01, utilizaremos Visual Studio® para crear un nuevo proyecto de aplicación para Windows.

Para crear el proyecto Ejemplo01

En el menú Archivo, seleccione Nuevo y después seleccione Proyecto para abrir la venta de Nuevo Proyecto.
Seleccione la plantilla de proyecto Aplicación para Windows en la lista de proyectos para Visual Basic o Visual C# y escriba Ejemplo01 en la caja de texto para el Nombre.
En el menú Archivo, elija Guardar Todo para guardar su proyecto

En el formulario que se crea predeterminadamente, dibujaremos tres controles TextBox emparejados con tres controles Label, también dibujaremos un control Button para tener una manera de salir del nuestra aplicación, la configuración de las propiedades de los controles se muestra en la tabla 1:

Control	Propiedad	Valor
Form	Name	Form1
	Text	"Ejemplo 01"
TextBox	Name	txtCampo1
	TabIndex	0
	Text	""
TextBox	Name	txtCampo2
	TabIndex	1
	Text	""
TextBox	Name	txtCampo3
	TabIndex	2
	Text	""
Label	Name	Label1
	Text	"Campo 1"
Label	Name	Label2
	Text	"Campo 2"
Label	Name	Label3
	Text	"Campo 3"
Button	Name	btnSalir
	TabIndex	3
	Text	Salir

Tabla 1.- Propiedades de controles

Una vez realizado esto, quedará un formulario parecido al de la figura 1. Es importante tener en cuenta el orden de los controles establecido por la propiedad TabIndex de cada TextBox, ya que de esta manera tendremos asegurado el orden al pasar de un TextBox a otro.

Figura 1.- Formulario de ejemplo

Pues bien, tenemos ya el formulario que usaremos en este ejemplo. podemos entonces continuar con el código.

Empecemos con lo siguiente, definamos los eventos KeyPress y KeyDown en la sección de código del formulario Form1. Para evitar repetir el mismo evento en cada uno de los controles de texto, declararemos un método que servirá de controlador de evento para los tres TextBoxes. Empecemos con el evento KeyPress.

Para crear los controladores de eventos

Por definición el evento KeyPress utiliza la firma de un delegado que contienen los siguientes argumentos; Object y System.Windows.Forms.KeyPressEventArgs, conociendo esto no nos será difícil crear el controlador del evento:

// Código en C#
private void txt_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
{

}

' Código en Visual Basic
Private Sub txt_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs)

End Sub

Continuando haremos lo mismo para el evento KeyDown, este evento utiliza la firma de un delegado con los siguientes argumentos; Object y System.Windows.Forms.KeyEventArgs, ahora que sabemos la firma, construir el controlador del evento será fácil y será tan simple como en el caso anterior del constructor del evento KeyPress. Veamos:
```
// Código en C#
private void txt_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
{

}

' Código en Visual Basic
Private Sub txt_KeyDown(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs)

End Sub
```
Hasta este momento tenemos declarados los controladores de los eventos, sin embargo, no serán lanzados al momento de realizar alguna acción con el teclado, esto es porque aun no se agregan los controladores de los eventos de cada TextBox a sus respectivos eventos, esto lo veremos más adelante, por el momento debemos darle la funcionalidad general requerida para poder utilizarlos en todos los controles de texto. Para esto definiremos en la primera línea dentro de cada método controlador lo siguiente:
```
// Código en C#
TextBox txt = sender as TextBox;

' Código en Visual Basic
Dim txt as TextBox = DirectCast (sender,TextBox)
```
Lo que se está haciendo en esta línea es convertir el objeto sender en TextBox, esto es porque al saber que el controlador será para el evento de un control TextBox, el sender será en todos los casos un TextBox. Claro que esto será siempre que el controlador sea agregado a los eventos de un TextBox en caso contrario se pueden presentar excepciones del tipo System.NullReferenceException o System.InvalidCastException así pues debemos tener en cuenta que serán controladores de eventos exclusivamente para TextBoxes.

Para agregar los métodos controladores a los eventos

Teniendo en cuenta lo anterior, definamos un método para agregar los controladores de eventos a los eventos de teclado de cada TextBox. Este método tendrá que ser invocado inmediatamente después del método InitializeComponent() dentro del constructor del formulario, definamos pues nuestro método InitializeEvents():

// Código en C#
private void InitializeEvents() 
{ 
    //
    // txtCampo1
    //
    this.txtCampo1.KeyPress += new KeyPressEventHandler(txt_KeyPress);
    this.txtCampo1.KeyDown += new KeyEventHandler(txt_KeyDown);
    //
    // txtCampo2
    //
    this.txtCampo2.KeyPress += new KeyPressEventHandler(txt_KeyPress);
    this.txtCampo2.KeyDown += new KeyEventHandler(txt_KeyDown);
    //
    // txtCampo3
    //
    this.txtCampo3.KeyPress += new KeyPressEventHandler(txt_KeyPress);
    this.txtCampo3.KeyDown += new KeyEventHandler(txt_KeyDown);
}

' Código en Visual Basic
Private Sub InitializeEvents()
    '
    'txtCampo1
    '
    AddHandler Me.txtCampo1.KeyPress, AddressOf txt_KeyPress
    AddHandler Me.txtCampo1.KeyDown, AddressOf txt_KeyDown
    '
    'txtCampo2
    '
    AddHandler Me.txtCampo2.KeyPress, AddressOf txt_KeyPress
    AddHandler Me.txtCampo2.KeyDown, AddressOf txt_KeyDown
    '
    'txtCampo3
    '
    AddHandler Me.txtCampo3.KeyPress, AddressOf txt_KeyPress
    AddHandler Me.txtCampo3.KeyDown, AddressOf txt_KeyDown
End Sub

Hasta este momento hemos asignado los controladores de eventos a los eventos de nuestros controles y para que esto suceda en modo de ejecución no debemos olvidarnos de invocar el método InitializeEvents() inmediatamente después del método InitializeComponent(), esto se hará en el constructor del formulario, como se muestra a continuación:
```
// Código en C#
public Form1()
{
    InitializeComponent();
    InitializeEvents();
}

' Código en Visual Basic
Private Sub New()
    MyBase.New()
    InitializeComponent()
    InitializeEvents()
End Sub 
```

Para agregar la funcionalidad

Bien, ahora continuemos con la funcionalidad que queremos agregarle a nuestro formulario, será simple y en un instante estará listo. Agregaremos al controlador del evento KeyDown las siguientes líneas de código, este código nos servirá para identificar si la tecla Enter ha sido presionada por el usuario, seguido de esto enviaremos el foco al siguiente control con el método SelectNextControl() del formulario:
```
// Código C#
if(e.KeyCode == Keys.Enter)
{
   this.SelectNextControl(txt,true,true,false,false);
}

' Código en Visual Basic
If e.KeyCode = Keys.Enter Then
   Me.SelectNextControl(txt, True, True, False, False)
End If
```
Pues bien, ya solo queda ejecutar el proyecto y hacer las pruebas correspondientes. Con esto concluye el ejemplo sobre la navegación entre controles, espero en lo personal que sea útil y satisfaga una de las dudas más frecuentes sobre la navegación de controles.

Para probar el proyecto

En el menú Depurar, elija Iniciar.
El formulario Form1 se abre como se muestra en la figura 1.
Presione la tecla Enter.
Note que el foco del control txtCampo1 se va al siguiente control de texto según el orden que se estableció en la propiedad TabIndex de cada uno de estos.

Uso del evento KeyUp para detectar la combinación de teclas

Otra funcionalidad que comúnmente se utiliza es la de detectar qué tecla o combinación de teclas fue presionada para responder con una acción a una condición dada, esto es, en ocasiones las aplicaciones requieren de mayor versatilidad y funcionalidad y para darles estas capacidades se puede incluir el uso de "atajos" para realizar alguna acción o tarea en particular. Dentro de los estándares que se manejan en Windows se encuentran distintas combinaciones, por ejemplo, al presionar Alt + F4 se cerrará la ventana activa, de igual manera se pueden definir combinaciones específicas para cada aplicación.

Seguiremos utilizando nuestro proyecto Ejemplo01 para mostrar una de las maneras de utilizar el evento KeyUp.

Para construir el evento KeyUp

El evento KeyUp es casi idéntico al evento KeyDown, la diferencia radica en el orden en que son lanzados, sabiendo esto, veremos que la firma del delegado es la misma que usamos con el evento KeyDown, así pues, no nos será difícil construir el controlador de nuestro evento:
```
// Código en C#
private void ctrl_KeyUp(object sender, System.Windows.Forms.KeyEventArgs e)
{

}

' Código en Visual Basic
Private Sub ctrl_KeyUp(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs)

End Sub
```
Como se puede apreciar, el evento ahora tiene el prefijo ctrl en vez de txt, y es con el objetivo de indicar que el controlador de evento podrá ser utilizado por cualquier control que soporte los eventos del teclado, ahora veremos cómo cambia la conversión de sender para que esto sea posible. Recordemos que los controles se crean a partir de clases heredadas de Control, esta clase expone la mayoría de las propiedades que se ven en los controles que utilizamos en nuestro proyecto de ejemplo, así pues, la conversión será más general.
```
// Código en C#
Control ctrl = sender as Control;

' Código en Visual Basic
Dim ctrl as Control = DirectCast (sender,Control)
```

Solo faltará agregar a nuestro método de inicialización de eventos el código necesario para agregar el controlador a los eventos correspondientes, en esta ocasión incluiremos a nuestro botón btnSalir para demostrar la manera en que trabajará el controlador del evento KeyUp con cualquier control:

// Código en C#
private void InitializeEvents()
{
    //
    // txtCampo1
    //
    this.txtCampo1.KeyPress +=new KeyPressEventHandler(txt_KeyPress);
    this.txtCampo1.KeyDown +=new KeyEventHandler(txt_KeyDown);
    this.txtCampo1.KeyUp +=new KeyEventHandler(ctrl_KeyUp);
    //
    // txtCampo2
    //
    this.txtCampo2.KeyPress +=new KeyPressEventHandler(txt_KeyPress);
    this.txtCampo2.KeyDown +=new KeyEventHandler(txt_KeyDown);
    this.txtCampo2.KeyUp +=new KeyEventHandler(ctrl_KeyUp);
    //
    // txtCampo3
    //
    this.txtCampo3.KeyPress +=new KeyPressEventHandler(txt_KeyPress);
    this.txtCampo3.KeyDown +=new KeyEventHandler(txt_KeyDown);
    this.txtCampo3.KeyUp +=new KeyEventHandler(ctrl_KeyUp);
    //
    // btnSalir
    //
    this.btnSalir.KeyUp +=new KeyEventHandler(ctrl_KeyUp);
}

' Código en Visual Basic
 Private Sub InitializeEvents()
    '
    'txtCampo1
    '
    AddHandler Me.txtCampo1.KeyPress, AddressOf txt_KeyPress
    AddHandler Me.txtCampo1.KeyDown, AddressOf txt_KeyDown
    AddHandler Me.txtCampo1.KeyUp, AddressOf ctrl_KeyUp
    '
    'txtCampo2
    '
    AddHandler Me.txtCampo2.KeyPress, AddressOf txt_KeyPress
    AddHandler Me.txtCampo2.KeyDown, AddressOf txt_KeyDown
    AddHandler Me.txtCampo2.KeyUp, AddressOf ctrl_KeyUp
    '
    'txtCampo3
    '
    AddHandler Me.txtCampo3.KeyPress, AddressOf txt_KeyPress
    AddHandler Me.txtCampo3.KeyDown, AddressOf txt_KeyDown
    AddHandler Me.txtCampo3.KeyUp, AddressOf ctrl_KeyUp
    '
    'btnSalir
    '
     AddHandler Me.btnSalir.KeyUp, AddressOf ctrl_KeyUp
 End Sub

Agregar funcionalidad al evento

Solo faltará agregar alguna funcionalidad y alguna condición de combinación de teclas para mostrar como funciona el evento KeyUp. Para fines prácticos, capturaremos la combinación de las teclas Ctrl+Alt+B, con lo cual cambiaremos el color de fondo del control que tenga el foco, esto nos dará la oportunidad de ver la manera en que se toma al sender como Control para realizar el cambio a una propiedad común. Encontraremos diferencias más marcadas entre C# y VB.NET al momento de evaluar los valores de las teclas presionadas, debido a las dos propiedades de KeyEventArgs que utilizaremos; KeyData, que almacena la suma de los valores de las teclas presionadas (estos valores corresponden a las constantes declaradas en la enumeración System.Windows.Forms.Keys) y KeyCode para obtener el valor de las constantes de la enumeración Keys. Para el caso de C#, los valores se tomarán directo de la enumeración por ser miembros estáticos, además tendrán que convertirse a Int32 para ser evaluados, en el caso de Visual Basic es más evidente y lo podemos hacer de una manera más directa. Hay una segunda opción para validar la acción del usuario, esta es mediante la comparación lógica, esta opción es más eficiente pues evita el uso de la clase Convert, en este caso sería recomendable usar esta opción en lugar de la anterior.
```
// Código en C#
if (Convert.ToInt32(e.KeyData) == Convert.ToInt32(Keys.Alt) + Convert.ToInt32(Keys.Control) + Convert.ToInt32(Keys.B) )
{
    if(ctrl.BackColor.ToString() == Color.Navy.ToString())
    {
        ctrl.BackColor= new Color();
    }
    else
    {
        ctrl.BackColor = Color.Navy;
    }
}
// Segunda opción en C#
if (e.Alt && e.Control && e.KeyCode==Keys.B)
{
    if(ctrl.BackColor.ToString() == Color.Navy.ToString())
    {
        ctrl.BackColor= new Color();
    }
    else
    {
        ctrl.BackColor = Color.Navy;
    }
}

' Código en Visual Basic
If e.KeyData = e.KeyCode.Alt + e.KeyCode.Control + e.KeyCode.B Then
    If ctrl.BackColor.ToString() = System.Drawing.Color.Navy.ToString() Then
        ctrl.BackColor = New System.Drawing.Color
    Else
        ctrl.BackColor = System.Drawing.Color.Navy
    End If
End If
```

Para probar el proyecto

En el menú Depurar, elija Iniciar.
El formulario Form1 se abre como se muestra en la figura 1.
Presione las teclas Ctrl, Alt y B al mismo tiempo.
Note que el control que tenga en foco en ese momento cambiará el color de fondo a azul marino.

Conclusión

Hemos visto en este artículo la manera de utilizar los eventos del teclado para dar solución a aquellas preguntas que tanto se hacen en los foros. Debemos tener en consideración distintos aspectos, uno de ellos es tener cuidado de no utilizar combinaciones de teclas que utilice el sistema operativo como ctrl + alt + supr, ó alt + tab, también ver que combinaciones de teclas se utilizan para cierto caracteres, por ejemplo, ctrl + alt + Q (Esp. Latam) ó ctrl + alt + 2 (España) devuelven la arroba "@". Pues bien, teniendo en cuenta esto no creo que exista más problema, espero sea útil la información de este artículo.

.NET A new try... : WindowsForms

Archivos de los Ejemplos de Eventos del Teclado en WindowsForms

Eventos del teclado en WindowsForms

Usos de los eventos del teclado

Contenido

Introducción

Uso de los eventos KeyDown y KeyPress para navegar entre controles

Uso del evento KeyUp para detectar la combinación de teclas

Conclusión