Curso de iniciación a la programación con Visual Basic .NET

Entrega número tres, (26/Oct/2001)
Publicada el 27/Oct/2001
Revisada el 24/Dic/2002
(13/Ene/02: algunas correcciones gramaticales y otras menores)

En esta tercera entrega del curso de iniciación a la programación con Visual Basic .NET vamos a seguir viendo algunas cosillas más del entorno integrado de Visual Studio .NET, en esta ocasión vamos a hacer que los controles que tengamos en un formulario se adapten de forma automática al nuevo tamaño de la ventana (formulario) así como a los distintos tamaños de fuentes que el usuario de nuestras aplicaciones .NET prefiera usar, ya que no todo el mundo usa la misma resolución que nosotros ni los mismos tamaños de letras.

Hacer esto con las versiones anteriores de Visual Basic era un trabajo duro y algunas veces bastante engorroso, que requería bastante código y casi nunca se lograba lo que queríamos... ¿que no sabes de qué estoy hablando? bueno, no te preocupes que, aunque ahora no sepas la utilidad de todo lo que te voy a explicar pueda tener, en algún momento lo necesitarás y aquí tendrás la explicación de cómo hacerlo.

Para entrar en calor, te expondré un caso típico:
El tamaño de una ventana de Windows, (que al fin y al cabo es un formulario), se puede hacer redimensionable, es decir que el usuario puede cambiar de tamaño, en estos casos, lo adecuado sería que los controles que dicho formulario contenga, se adapten al nuevo tamaño de la ventana, con idea de que no queden huecos vacíos al cambiar el tamaño de la ventana.

Por ejemplo, si tenemos esta ventana (o formulario):

Figura 1

y la agrandamos, por ejemplo para que tenga este otro aspecto:

Figura 2

comprobaremos que la ventana se ha agrandado, pero los controles que hay en ella siguen teniendo el mismo tamaño y la misma posición que en la ventana anterior.

Pues bien, la idea de lo que te quiero explicar es que al cambiar el tamaño de la ventana se ajusten los controles al nuevo tamaño, para que tuviesen este otro aspecto:

Figura 3

Para que esto sea posible de forma automática, hay que hacer unas cuantas asignaciones a los controles, de forma que podamos indicarle qué tienen que hacer cuando el tamaño de la ventana varíe.
En este ejemplo, lo correcto sería que:
- La caja de texto superior se agrandase hacia el lado derecho.
- El botón Añadir se moviese hacia el extremo derecho del formulario.
- La lista se ajustara al ancho y también al alto de la ventana.
Todo esto lo podemos hacer en tiempo de diseño, es decir cuando tenemos el formulario en el entorno integrado o bien lo podemos codificar dentro del propio formulario, dónde hacerlo queda a tu criterio, yo te voy a explicar cómo hacerlo en los dos casos y después tu decides cómo hacerlo.

Antes de empezar a explicarte, vamos a crear un nuevo proyecto.
Crea un proyecto del tipo Windows, (aplicación Windows o Windows Application), nómbralo como WinApp3.
Añade una etiqueta (Label), una caja de textos (TextBox), un botón (Button) y una lista (ListBox)
Deja los nombres que el IDE ha puesto, salvo para el botón, el cual se llamará cmdAdd.
(realmente puedes ponerles los nombres que quieras, pero los que yo voy a usar son: Label1, TextBox1, ListBox1 y cmdAdd)

Posiciona esos controles tal y como se muestra en la figura 1.

Selecciona la caja de textos (TextBox1) y en la ventana de propiedades, selecciona Anchor, verás que por defecto estarán los valores Left y Top, esto quiere decir que la caja de textos estará "anclada" a la izquierda y arriba, pero ahora vamos a seleccionar también la derecha. Cuando pulses en la lista desplegable verás que se muestra una imagen con cuatro líneas, (como la mostrada en la figura 4), dos de las cuales son obscuras (están seleccionadas) y las otras dos están blancas (no seleccionadas), pulsa en la línea de la derecha, para que se ponga gris, de esta forma estaremos indicándole que también se "ancle" a la derecha.

Figura 4

Vamos a comprobarlo. Pulsa F5 para ejecutar el proyecto.
Una vez que se muestre el formulario en ejecución, agrándalo hacia la derecha, verás que la caja de textos se adapta al nuevo tamaño. Ahora "achícalo", es decir haz que se haga más pequeño hacia la izquierda, incluso haz que no se vea el botón, comprobarás que la caja de texto sigue estando "proporcionalmente" igual de separada de los extremos superior, derecho e izquierdo y se adapta al tamaño de la ventana.
Incluso si intentas hacer la ventana muy pequeña, el ancho se quedará justo en la parte izquierda de la caja de texto, con el alto puedes hacer que casi desaparezca, (salvo el caption de la ventana, la barra de arriba, la cual se mantiene).

Ahora vamos a "anclar" el botón.
Una vez que hayas terminado de probar... vamos a seguir... ¡valeeee! deja ya de juguetear con la dichosa ventanita.

Ahora, de vuelta al IDE, selecciona el botón y en la ventana de propiedades selecciona la propiedad Anchor.
En este caso, lo que nos interesa es que el botón se desplace a la derecha, pero que no se haga más grande.
Para ello, debes seleccionar las líneas de la derecha y la de arriba.
Es decir: ánclate en la parte de arriba y en la derecha, de forma que si cambiamos el tamaño del formulario, el botón se desplazará a la derecha o a la izquierda, pero no cambiará de tamaño, como le ocurre al textbox.
Pulsa F5 y compruébalo. Agranda el formulario, (hacia la derecha) y achícalo, (hacia la izquierda), verás que el botón llegará casi a tocar el lado izquierdo del formulario y allí se quedará, no permitiendo que se haga más pequeño.

Por último vamos a anclar el listbox... ¿cómo? ¿que quieres intentarlo por tu cuenta? vale... me parece bien...
Sólo decirte que el listbox debe hacerse grande tanto hacia la derecha como hacia la izquierda e incluso cuando se estira el formulario desde la parte inferior, pero en la parte superior debe mantenerse en la misma posición.

Fíjate en la figura 3...

Bueno, espero que lo hayas conseguido. Si no es así, no te preocupes, ahora veremos la solución.

Vamos a complicar un poco más la cosa y vamos a añadirle otro botón. En este caso, dicho botón estará en la parte inferior derecha del formulario, será el botón cerrar y al pulsarlo hay que cerrar el formulario... ¿recuerdas cómo se hace?
¡Exacto! usando Me.Close en el evento Click de dicho botón, el cual yo voy a llamar cmdCerrar.
Como te decía, este botón se debería anclar en la parte inferior derecha, por tanto los valores que hay que asignar en Anchor son precisamente esos: Right y Botton (derecha y abajo).

Como habrás notado, con el Label1 no hay que hacer nada, ya que por defecto el tamaño se ajusta por la derecha y por abajo, por tanto se quedará en la misma posición... aunque realmente está anclada arriba y a la izquierda, que son los valores por defecto de la propiedad Anchor, por eso no es necesario asignarle nada.

Ahora vamos a ver cómo hacerlo mediante código... ¿que qué sentido tiene hacerlo por código? pues... esto... bueno, porque puede ser que quieras hacerlo... (je, je, ¡tan pillao guille!)

Haz que se muestre el formulario y haz doble-click en él, (no hagas doble-click en ninguno de los controles que tiene el formulario, sino en el propio formulario). Cuando estamos en el IDE y hacemos doble-click en el formulario  se muestra el evento Form_Load que es el que se ejecuta cuando el formulario "se carga" en la memoria, justo antes de mostrarse, por tanto aquí es un buen sitio para hacer algunas "inicializaciones" o asignaciones que nuestro formulario necesite.
Por ejemplo, podemos limpiar el contenido de la lista, el de la caja de texto, etc. e incluso hacer las asignaciones para que los controles se queden "anclados" en la posición que nosotros le indiquemos.

Vamos a ver primero cómo se "declara" este evento, aunque el VB lo hace automáticamente por nosotros, es conveniente verlo para ir aclarando conceptos... que tal vez ahora no necesites, pero en un futuro casi seguro que te hubiese gustado haberlo sabido.

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
    Me.TextBox1.Text = ""
    Me.ListBox1.Items.Clear()
End Sub

Lo primero que hay que notar es que Handles es la palabra que le indica al compilador de Visual Basic .NET qué evento es el que "manipula" o maneja este procedimiento. Siempre lo digo... o lo pienso, que los anglosajones (los que hablan inglés) lo tienen muchísimo más fácil que los que no hablamos la lengua de Shakespeare, ya que para ellos eso de Handles es una palabra que tiene sentido y precisamente quiere decir eso "maneja", manipula, se encarga de , etc. con lo cual tienen superclaro que es lo que quiere decir esa palabreja... Esto, (la declaración del Sub), se encarga de manejar el evento Load del objeto MyBase.
Aunque también hay que decirlo... algunos de esos "hablantes" de inglés, aún a pesar de tener el lenguaje (idioma) a su favor... no tienen ni repajolera idea de Basic... en fin... ese consuelo nos queda... así que, no te desanimes y tira "pa lante", que "pa trás" no hay que ir ni para coger carrerilla...

El objeto MyBase se refiere al objeto base del que se deriva el formulario, recuerda que en .NET todo está basado en objetos y en programación orientada a objetos y todo objeto se deriva de un objeto básico o que está más bajo en la escala de las clases... es decir, un formulario se basa en la clase System.Windows.Forms.Form y a esa clase es a la que hace referencia el objeto MyBase, mientras que Me se refiere a la clase actual, la que se ha derivado de dicha clase Form o por extensión a cualquier clase, como veremos en futuras ocasiones.

¿Cómo? ¿que has acabado por liarte más? ¿que no has captado lo que acabo de decir?
Pues lo siento por ti... pero no te lo voy a explicar mejor... simplemente déjalo estar y poco a poco acabarás por comprenderlo... (je, je, ¡que malo que soy algunas veces!)

Veamos ahora el código prometido para hacer que los controles se anclen al formulario de forma que se adapten al nuevo tamaño del mismo:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
    Me.TextBox1.Text = ""
    Me.ListBox1.Items.Clear()
    ' Asignar los valores para "anclar" los controles al formulario
    ' El TextBox1 se anclará a Arriba, Izquierda y Derecha
    TextBox1.Anchor = AnchorStyles.Top Or AnchorStyles.Left Or AnchorStyles.Right
    ' El botón Añadir lo hará Arriba y a la derecha:
    cmdAdd.Anchor = AnchorStyles.Top Or AnchorStyles.Right
    ' El listbox lo hará en los cuatro vértices:
    ListBox1.Anchor = AnchorStyles.Top Or AnchorStyles.Left Or AnchorStyles.Right Or AnchorStyles.Bottom
    ' El botón cerrar sólo lo hará a la derecha y abajo
    cmdCerrar.Anchor = AnchorStyles.Right Or AnchorStyles.Bottom
End Sub

Para ir terminando la presente entrega, vamos a ver lo otro que comenté al principio, que el formulario y los controles se adapten también a otros tamaños de fuentes, no a los que nosotros tenemos en nuestro equipo... ya que hay gente que por necesidades tienen que poner tamaños de fuentes más grandes e incluso más pequeñas... que también hay quién tiene un monitor de 19 o 21 pulgadas y lo mismo tienen que usar letras de tamaños más pequeñín...

La propiedad que hace eso posible es AutoScale, esta propiedad sólo está disponible en los formularios y por defecto tiene el valor True (verdadero), por tanto los formularios, sin necesidad de que hagamos nada, se auto ajustarán al tamaño de las fuentes.
Esto no lo he comprobado, pero me fío de lo que dice la documentación, (aunque esté en inglés)

Otra cosilla interesante que tienen los formularios es la propiedad AutoScroll. Si asignamos el valor True (verdadero) a esta propiedad, hacemos que cuando el formulario se haga muy pequeño o muy estrecho, se muestren unas barras de desplazamiento (scrolls) para que pulsando en ellas podamos ver el contenido del mismo.
Por ejemplo si no hubiésemos "anclado" nuestros controles, al hacer el formulario más estrecho se mostrarían unas barras de desplazamiento para que podamos ver los controles que están contenidos en el formulario.
 

Figura 5

Si quieres probarlo, quita el código que hemos añadido, o coméntalo todo, para ello selecciona todas las líneas que quieres comentar, las que asignan los valores a la propiedad Anchor y en el menú Edición, selecciona Avanzado y Comentar Selección, también puedes usar las teclas: Ctrl+K seguidas de Ctrl+C, (yo tengo las opciones de Comentar Selección y Quitar los comentarios puestas en la barra de herramientas, ya que de vez en cuando las utilizo para hacer alguna que otra prueba y no tener que borrar el texto que quiero quitar)
 

Figura 6

Lo dicho, comenta ese código y añade el siguiente, ejecuta la aplicación y pruébalo haciendo la ventana más pequeña, tal y como te muestro en la figura 5.

' Asignamos True a la propiedad AutoScroll y dejamos los controles 
' como están por defecto:
Me.AutoScroll = True
' El TextBox1 se anclará a Arriba, Izquierda y Derecha
TextBox1.Anchor = AnchorStyles.Top Or AnchorStyles.Left
' El botón Añadir lo hará Arriba y a la derecha:
cmdAdd.Anchor = AnchorStyles.Top Or AnchorStyles.Left
' El listbox lo hará en los cuatro vértices:
ListBox1.Anchor = AnchorStyles.Top Or AnchorStyles.Left
' El botón cerrar sólo lo hará a la derecha y abajo
cmdCerrar.Anchor = AnchorStyles.Top Or AnchorStyles.Left

Todas estas cosas ya nos hubiese gustado tenerlas en las versiones anteriores de Visual Basic, ya que para hacerlo o bien te tenías que "comer" el coco o bien te tenías que crear un control que hiciera ese trabajo...

Sólo comentarte que los Ors que se están utilizando sirven para "sumar" y el resultado sería el mismo que si usáramos el signo de suma, pero la razón de usar Or es porque lo que queremos hacer es una suma de bits... realmente da lo mismo usar la suma que Or en este caso, pero... dejemos el Or que es lo apropiado... y no me preguntes porqué... ya que, aunque no te hayas enterado, te lo acabo de explicar... je, je.

¡UF! vaya entrega más larga y en resumidas cuentas ¿qué es lo que has aprendido?
Sí... claro que no ha sido en vano... ¿te crees que iba a gastar yo tanto tiempo para explicarte algo que no sirve para nada...
De todas formas, vamos a ver algo de código para que no se te quede mal sabor de boca.

El código que te voy a mostrar hará lo siguiente:
- Al pulsar en el botón Añadir, se añadirá a la lista lo que hayas escrito en la caja de textos.
- Al pulsar Intro será como si hubieses pulsado en el botón Añadir.
- Al pulsar Esc es como si hubieses pulsado en el botón Cerrar.
- Al pulsar en uno de los elementos de la lista, éste se mostrará en la caja de textos.
- Al seleccionar un elemento de la lista y pulsar la tecla Supr (o Del si tu teclado está en inglés), dicho elemento se borrará de la lista, pero se quedará en la caja de textos, ya que al seleccionarlo para poder pulsar la tecla suprimir se habrá mostrado...

Veamos cómo hacer esto.
Lo de pulsar en Añadir y hacer algo, está claro: simplemente codificamos lo que haya que codificar en el evento Click del botón cmdAdd. Para que nos muestre ese evento, simplemente haz doble-click en el botón y el VB te mostrará el evento en cuestión, añade este código y ahora te lo explico:

Private Sub cmdAdd_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles cmdAdd.Click
    ListBox1.Items.Add(TextBox1.Text)
End Sub

Lo que te voy a explicar es lo que está dentro del evento Click, ya que lo de Handles te lo he explicado hace un rato.
Si te has fijado en el código que te mostré del evento Form_Load, seguramente habrás visto que teníamos:

Me.ListBox1.Items.Clear()

Me hace referencia a la clase actual, es decir al formulario.
Items son los elementos que tiene el objeto ListBox
Clear es un método de Items que se encarga de limpiar los elementos de la lista, es decir: los borra.
Por tanto esa línea lo que hace es borrar los elementos del listbox.

Ahora lo que necesitamos no es borrarlos, sino añadir nuevos elementos a la lista, por tanto, como ya sabemos que Items es el sitio en el que se guardan los elementos de la lista, lo único que tenemos que saber es ¿cómo se añaden nuevos elementos a dicha lista? y para eso estoy yo aquí: para contártelo; pero como me imagino que eres lo suficientemente observador, te habrás "percatado" que Add es lo que necesitamos para añadir elementos a la lista de un ListBox. Si no eres tan observador (u observadora) como yo me creía, te lo explico un poco:
Para añadir elementos a un listbox, se usa el método Add de Items.
Ya está dicho.

En la colección Items se puede añadir lo que queramos, cualquier objeto, en este caso lo que añadimos es el contenido (el texto) del TextBox, por eso es por lo que hacemos:
Items.Add(TextBox1.Text)
Añadimos a Items el contenido de la caja de textos.

¿Qué es una colección?
Realmente es una lista de objetos o elementos que están agrupados en un objeto, en este caso un objeto colección (o Collection), aunque en este caso Items no es del todo lo que en el VB de antes era una colección, ya que en vb.NET existen varios tipos de colecciones o arrays (¿arreglos?), pero no vamos a complicarnos la vida... Items es una colección de elementos, es decir los elementos están guardados en una "lista" de datos.
En su momento veremos los diferentes tipos de colecciones o listas.

Veamos ahora cómo saber cual es el elemento que se ha seleccionado de la lista y cómo asignarlo al TextBox:

Private Sub ListBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ListBox1.SelectedIndexChanged
    ' Cuando pulsamos en un elemento de la lista...
    With ListBox1
        TextBox1.Text = .GetItemText(.SelectedItem)
    End With
End Sub

Fíjate que en este caso no es el evento Click, como era de esperar (y como es en las versiones anteriores de VB, incluso como era en la Beta 1 de vb.NET), sino que el evento en cuestión es SelectedIndexChanged.
Ya te he comentado que lo que podemos añadir a los elementos del listbox son objetos, pero lo que a nosotros nos interesa mostrar es el "texto" de dicho elemento, ya que no nos interesa otra cosa, más que nada porque lo que hemos añadido son textos y no objetos... aunque, como ya te he comentado en otras ocasiones TODO lo que se maneja en .NET son objetos, incluso las cadenas de textos son objetos... pero... en fin... dejemos las cosas así por ahora.

Lo que en este evento hacemos es asignar a la caja de textos el texto del elemento seleccionado: la propiedad SelectedItem representa al elemento seleccionado y GetItemText es una función, (o método), que devuelve el texto (o la representación en formato texto del elemento indicado dentro de los paréntesis).

Este evento se consigue haciendo doble click en el listbox, pero...

¿Cómo hacemos para escribir código en otros eventos?
Para poder usar otros eventos de un objeto, muestra la ventana de código, de la lista desplegable de la izquierda, selecciona dicho objeto y en la lista desplegable de la derecha elige el evento que quieras usar, en nuestro próximo ejemplo será el evento KeyDown, tal y como se muestra en la figura 7, los eventos se distinguen por el rayo que se muestra a la izquierda del nombre del elemento...

Figura 7

 

Como dato curioso, en los formularios de C# se pueden seleccionar los eventos en la misma ventana de propiedades del formulario u objeto en cuestión, incluso a veces ocurre que en vb.NET se muestra ese símbolo en la mencionada ventana de propiedades, aunque no siempre y no sé exactamente porqué se muestra... pero espero y confío que en la versión definitiva de vb.NET dicha opción estará disponible, para facilitarnos un poco más el trabajo. A día de hoy (26/Oct/2001), aún no he visto la Release Candidate 1, pero según he leído en las páginas de Microsoft no se diferencia mucho de la Beta 2, (que es la que estoy usando en estos momentos), así que... me da mala espina esto de que aún no esté la opción de elegir eventos en la ventana de propiedades, pero esperemos y confiemos que algún día esté.

Nota del 24/Dic/2002:
Pues ni está en la versión final ni tampoco estará en la versión 2003

Al seleccionar ese evento, se mostrará el siguiente código:

Private Sub ListBox1_KeyDown(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles ListBox1.KeyDown

End Sub

¿Por qué he elegido KeyDown y no KeyUp o incluso KeyPress?
Porque la tecla Supr (Del) es una tecla especial y no se detecta en el evento KeyPress, podía haber usado KeyUp también, pero ese evento se produce cuando se suelta la tecla... (que sería lo lógico), pero yo siempre tengo la costumbre de interceptar esas pulsaciones en el evento KeyDown (cuando se empieza a pulsar la tecla) y es por ese motivo que voy a codificar el tema este de borrar un elemento de la lista en ese evento... cosas mías.

Este sería el código a usar para eliminar el elemento que está seleccionado:

Private Sub ListBox1_KeyDown(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles ListBox1.KeyDown
    If e.KeyCode = Keys.Delete Then
        With ListBox1
            .Items.Remove(.SelectedItem)
        End With
    End If
End Sub

Es decir, comprobamos si la tecla en cuestión es la de suprimir, si es así, eliminamos el elemento que está seleccionado.
Recuerda que SelectedItem nos indica el elemento que actualmente está seleccionado y usando el método Remove de la colección Items, lo quitamos de la lista.
Así de fácil.

Pero como no estoy dispuesto a terminar aún esta tercera entrega... para que te empaches y no te entre el mono cuando veas que tardo en publicar la siguiente entrega... vamos a permitir múltiple selección de elementos y vamos a ver cómo borraríamos los elementos que estén seleccionados.

Cuando permitimos múltiple selección en un ListBox, podemos seleccionar un elemento o varios.
Si son varios, estos pueden estar consecutivos o no.
Por ejemplo, si seleccionas un elemento de la lista y manteniendo pulsada la tecla Shift (mayúsculas), pulsas en otro que está más arriba o más abajo, se seleccionan todos los elementos intermedios, (esto deberías saberlo, ya que es una cosa habitual de Windows); también puedes seleccionar elementos no contiguos, si pulsas la tecla Control y con el ratón vas haciendo click en elementos no consecutivos.

Lo primero que necesitamos saber es:

¿Cómo hacer que un ListBox permita múltiple selección? ya que por defecto sólo se puede seleccionar un elemento a un mismo tiempo.

Para que un ListBox permita múltiple selección de elementos, hay que asignar a la propiedad SelectionMode el valor MultiExtended, por tanto selecciona el ListBox y en la ventana de propiedades, asigna dicho valor a la propiedad SelectionMode.

Ahora tenemos que hacer más cosas cuando se detecta la pulsación de la tecla suprimir en el evento KeyDown, ya que tenemos que saber qué elementos están seleccionados para poder borrarlos.
Lo primero que tenemos que hacer es recorrer todos los elementos del ListBox para saber si está o no seleccionado, pero ese recorrido hay que hacerlo desde atrás hacia adelante... ¿por qué? porque si lo hiciéramos desde el principio de la lista, al eliminar un elemento de dicha lista, el número de elementos variaría y tendríamos problemas cuando llegásemos al final, ya que no será el mismo número de elementos después de haber borrado alguno... mientras que al recorrer los elementos desde el final hacia adelante, no importará que borremos alguno del final, ya que el siguiente que comprobaremos estará más al principio que el recién borrado y no tendremos problemas... sé que no te has enterado, pero no importa, confía en mi, (¡que remedio te queda!), y ya tendrás tiempo de comprobarlo por tu cuenta.

Veamos primero el código que habría que usar y después lo comento.

Private Sub ListBox1_KeyDown(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles ListBox1.KeyDown
    If e.KeyCode = Keys.Delete Then
        ' Borrar las palabras seleccionadas del listbox
        Dim i As Integer
        '
        With ListBox1
            For i = .SelectedItems.Count - 1 To 0 Step -1
                .Items.Remove(.SelectedItems.Item(i))
            Next
        End With
    End If
End Sub

La parte del If e.KeyCode = Keys.Delete Then ya la vimos antes, aunque no te expliqué qué es lo que significa esto... bueno que es lo que significa si que te lo dije, lo que no te expliqué es porqué eso sirve para saber "qué es lo que significa".
Sólo decirte que IF... THEN... sirve para hacer comparaciones o para comprobar si una o más cosas están relacionadas de alguna forma, en este caso, queremos saber si el valor de e.KeyCode, que es la tecla que has pulsado, es igual a Keys.Delete, éste último valor es un valor "predefinido" que representa a la tecla suprimir.
Por tanto, si la tecla que hemos pulsado es igual a la tecla suprimir, entonces hacer lo que viene a continuación...
¿todo lo que viene a continuación?
NO, sólo hasta que encontremos End If, pero de esto ya hablaremos en otra ocasión.

Dim i As Integer esto le indica al VB que vamos a usar un número y que ese número lo guarde en la variable i, de esto también tendrás ocasión de enterarte mejor, por ahora dejémoslo así.

With ListBox1 el With se utiliza para simplificarnos las cosas y lo que viene a significar es que donde se tendría que usar el objeto ListBox1, se ponga un punto... más o menos... ahora veremos cómo se escribiría el código sin usar el With ListBox1.

¿Qué? ¿te estás liando? ¿Sí? Pues no desesperes, que aunque todo esto sea un follón, dentro de un par de años acabarás por comprenderlo... je, je... no, que no... que no será tanto tiempo, confía en el Guille...

For i = .SelectedItems.Count - 1 To 0 Step -1 con esto le estamos indicando que use la variable i para ir guardando los valores que resulten de contar desde el número de elementos que hay seleccionados hasta cero. El Step -1 se usa para contar hacia atrás, (de mayor a menor), pero eso, al igual que el For, también lo veremos más adelante.
SelectedItems es una colección en la cual están los elementos que hay seleccionados en el ListBox.
¿Recuerdas la colección Items? Pues en este caso, SelectedItems son los elementos seleccionados y para que lo sepas, todas las colecciones suelen tener un método Count que nos dice el número de elementos que hay en ellas.

.Items.Remove(.SelectedItems.Item(i)) Esto es parecido a lo visto antes, es decir, elimina el elemento que está seleccionado y que ocupa la posición i dentro de la colección de elementos seleccionados.
Esto también lo podríamos haber escrito de esta otra forma:
.Items.Remove(.SelectedItems(i)) que para el caso es lo mismo.
En su momento veremos porqué.
Por ahora quédate con la copla de que Item es la propiedad o método predeterminado de la colección SelectedItems.

Next indica que continúe el bucle o la cuenta que estamos llevando con la variable i.
De esta forma, al haber usado el Step -1, lo que hacemos es contar hacia atrás y si por ejemplo i valía 3, al llegar aquí, valdrá 2, es decir restamos 1: el valor indicado en Step

End With indica hasta dónde llega el tema ese del With ListBox1

End If le dice que hasta aquí llega la comprobación que hicimos de si la tecla pulsada era la de suprimir.

¡Menudo embrollo!
¿De verdad piensas que no acabarás nunca aprendiendo?
Date una oportunidad y de paso dámela a mi también... y confía, que dentro de poco todo esto te parecerá una tontería.

Vamos a ver qué significa eso de With.
Si no hubiésemos usado el With, ese código tendríamos que haberlo escrito de esta forma:

For i = ListBox1.SelectedItems.Count - 1 To 0 Step -1
    ListBox1.Items.Remove(ListBox1.SelectedItems.Item(i))
Next

Es decir, tendríamos que haber escrito el nombre del objeto en cada una de las partes correspondientes.
Por tanto, si usamos With Objeto, podemos sustituir a Objeto por el punto, siempre y cuando ese punto, (y la propiedad o método correspondiente), esté dentro del par With... End With.

Seguramente preferirás usarlo de esta otra forma, ya que se ve "claramente" que es lo que estamos haciendo, pero con el tiempo te acostumbrarás a usar With/End With, entre otras cosas porque yo los uso bastante y al final será como de la familia...

Y ahora sí que hemos terminado... ¡por fin!
(Pst! Guille... se te ha olvidado explicar lo de que al pulsar Intro sea como si hubiese pulsado en el botón Añadir y al pulsar Esc como si hubiese pulsado en Cerrar)
Pues sí... ¿en que estaría pensando?
Por suerte para tus neuronas, eso es más fácil de asimilar... je, je, je.

Para que un botón intercepte la tecla Intro, hay que decirle al VB que ese botón es el botón de aceptar, lo mismo ocurre con la "captura" de la tecla ESC, pero en lugar de ser el botón por defecto, será el botón de cancelación.
Selecciona el formulario y en la ventana de propiedades busca la propiedad AcceptButton, habrá una lista desplegable con los botones disponibles en el formulario, (tal y como te muestro en la figura 8), selecciona cmdAdd y ya está.
Ahora al pulsar Intro es lo mismo que si pulsaras en el botón Añadir.

Figura 8

Lo mismo para el de cancelar, pero en esta ocasión, la propiedad en cuestión es: CancelButton.
Por tanto, selecciona de la lista desplegable el botón cmdCerrar y así al pulsar Esc se cerrará la aplicación.

Nota: En las versiones anteriores de VB, esas propiedades pertenecían al propio botón, es decir, eran propiedades del objeto CommandButton. Aunque, al menos para mí, es más lógico que estén en el formulario, entre otras cosas porque sólo puede haber un botón de aceptar y uno de cancelar.

Pruébalo y así lo comprobarás.
Escribe algo en la caja de textos y pulsa Intro, verás que se añade a la lista, después pulsa ESC y verás que se cierra el formulario o ventana con lo que se da por terminada la aplicación.

Ahora sí. Ya hemos terminado por hoy.
La próxima vez veremos con más detalles qué es eso de las variables y puede que incluso veamos algo de lo que ya hemos visto aquí, pero con más detalles y mejor explicado. Pero eso será en la próxima entrega, que esta ya está bien servida.

Sólo me queda hacerte un "pequeño" resumen de lo que hemos visto en esta entrega:

- Usar la propiedad Anchor de los controles para que se ajusten automáticamente al cambiar el tamaño del formulario en el que están contenidos.
- Usar la propiedad AutoScale de los formularios para que los controles se ajusten al tamaño de la fuente predeterminada de Windows.
- Usar la propiedad AutoScroll de los formularios para mostrar las barras de desplazamiento (scroll) cuando el formulario se hace más pequeño y alguno de los controles queda oculto.
- Mención y pequeña descripción/explicación de las palabras MyBase, Me, Or, With, If, For...
- También hemos visto, aunque sea de pasada una variable para usarla en un bucle For.
- Qué es una colección, así como los métodos Clear, Count, Add, Remove e Item de las colecciones.
- Cómo asignar a un ListBox el contenido de un TextBox y viceversa:
- Cómo asignar a un TextBox el contenido del elemento seleccionado de un ListBox.
- Cómo saber cual es el elemento seleccionado de un ListBox.
- Cómo hacer que un ListBox permita múltiples selecciones de elementos.
- Cómo saber cuantos y cuales son los elementos que están seleccionados en el ListBox.
- Cómo eliminar el elemento que está actualmente seleccionado y
- Cómo eliminar todos los elementos que están seleccionados.
- Cómo hacer que un botón sea el botón predeterminado de aceptar de un formulario.
- Cómo hacer que un botón sea el botón predeterminado de cancelar de un formulario.
- Cómo seleccionar cualquier evento para un control determinado.
- Eventos vistos: Form_Load, Click, KeyDown, SelectedIndexChanged

Nos vemos.
Guillermo
Nerja, 26 de Octubre de 2001