Programación con Visual Basic .
NET
Profesor Aneurys Báez
Parte 3
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.
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):
Vean 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 les 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, ejemplo esto:
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 (jajaja el terror según ustedes), dónde hacerlo queda a tu
criterio, yo te voy a explicar cómo hacerlo en los dos casos y después tú decides cómo hacerlo.
Antes de empezar a explicarte, vamos a crear un nuevo proyecto, un proyecto del tipo Windows, (aplicación Windows o
Windows Application), nómbralo como quieras.
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 y ustedes deberian son: (Label1,
TextBox1, ListBox1 y cmdAdd) para que se lo aprendan y no se confundan.
Posiciona esos controles tal y como se muestra en la imagen que les mostré ahí arriba.
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.
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... ¡JOAAAN! deja ya de jugar con la 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? ¿Qué quieres hacerlo por tu? Tato, mete mano y resuelve Estivens...
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.
Bueno, espero que lo hayas conseguido. Si no es así, no te preocupes, DIFO te explicara jajajajajajaja(Risa Malvada como
la de Jadelin), no mentira ya dejare el relajo.
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 [Link] 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?.. EH este…(Concho pa
que escribi eso…momento incomodo, di algo random rápido, rapidoooooo) Bueno porque :V Mee piide CLASE…
JAJAJA QUE PENSABAN.
Seguimos, 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.
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 palabrita... 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 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 impulso...
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 [Link] 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 enrerarte
más? ¿Que no has entendido lo que acabo de decir? Tranquilo Frandy, juan ven y explicale.
Juan: Pues lo siento por ti... pero no te lo voy a explicar mejor... (je, je, ¡que malo que soy!).
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 [Link], ByVal e As
[Link]) Handles [Link]
[Link] = ""
[Link] ()
‘Asignar los valores para "anclar" los controles al formulario
‘El TextBox1 se anclará a Arriba, Izquierda y Derecha
[Link] = [Link] Or [Link] Or
[Link]
‘El botón Añadir lo hará Arriba y a la derecha:
[Link] = [Link] Or [Link]
‘El listbox lo hará en los cuatro vértices:
[Link] = [Link] Or [Link] Or
[Link] Or [Link]
‘El botón cerrar sólo lo hará a la derecha y abajo
[Link] = [Link] Or [Link]
End Sub
Para ir terminando, 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), Pueden buscar la
documentación de Visual Basic para ayudarse.
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ía unas barras de desplazamiento
para que podamos ver los controles que están contenidos en el
formulario.
Elmozo verdad (e_e).
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).
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.
‘Asignamos True a la propiedad AutoScroll y dejamos los controles
‘como están por defecto:
[Link] = True
' El TextBox1 se anclará a Arriba, Izquierda y Derecha
[Link] = [Link] Or [Link]
‘El botón Añadir lo hará Arriba y a la derecha:
[Link] = [Link] Or [Link]
‘El listbox lo hará en los cuatro vértices:
[Link] = [Link] Or [Link]
‘El botón cerrar sólo lo hará a la derecha y abajo
[Link] = [Link] Or [Link]
¡UUF! QUE TAREA 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 Enter 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:
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:
[Link]()
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, se dieron cuenta que Add (Jeranny orgullosa ya saben ingles)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.
FIN.
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:
[Link]([Link])
Añadimos a Items el contenido de la caja de textos.
Veamos ahora cómo saber cuál es el elemento que se ha seleccionado de la lista y cómo asignarlo al TextBox:
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 [Link]), 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 KeyPress, tal y
como se muestra allí al lado, los eventos se
distinguen por el rayo que se muestra a la
izquierda del nombre del elemento...
Al seleccionar ese evento, se mostrará el siguiente código:
¿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
[Link]) Handles [Link]
If [Link] = [Link] Then
With [Link](.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 tarea... para que se quillen cuando veas que tardo en publicar
la siguiente tarea... 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.
Veamos primero el código que habría que usar y después lo comento.
La parte del If [Link] = [Link] Then ya la vimos antes, aunque no te expliqué qué es lo que significa esto...
bueno que es lo que significa sí 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... (Recordando Pseudocodigo), 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 [Link], que es la tecla
que has pulsado, es igual a [Link], é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 enredando? ¿Sí? Pues no desesperes Jadelin todo a su tiempo, dentro de un par de años acabarás por
comprenderlo... je, je... no, que no... que no será tanto tiempo, confía en mi...
For i = .[Link] - 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. (Aunque ya lo
hemos utilizado).
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.
.[Link](.[Link](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:
.[Link](.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.
¿De verdad piensas que no acabarás nunca aprendiendo?
Date una oportunidad y de paso dámela a mí 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:
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!
(Psssst! Profe... se te ha olvidado explicar lo de que al pulsar Enter sea como si hubiese pulsado en el botón Añadir y
al pulsar Esc como si hubiese pulsado en Cerrar)
(e_e) ya comenzaron ellos a joder no pueden hacerlos ellos…paciencia que pa eso te pagan…809-445-6493 pa la recarga VIvade 150. XD.
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 Enter, 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), selecciona cmdAdd y ya está.
Ahora al pulsar Enter es lo mismo que si pulsaras en el botón Añadir.
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é
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 Enter, 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 :D
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
TAREA:
1. Investigar que es una colección en visual Basic.
2. Mandar imágenes de su programa funcionando en caso de no tener pc, trabajar el
código en el cuaderno y simularlo en dibujos, cualquier cosa comuníquense con su
grupo para ayudarse.