A lo largo de este documento procuraremos familiarizarnos con el entorno Visual. En esta ocasión nos ha tocado introducirnos a la programación en Visual Basic.

Es posible que este curso resulte para algunos bastante simple, para otros estará bien, y para el resto les resultará un incentivo muy gratificante para meterse con la programación Visual profesional o para fortalecer sus conocimientos sobre este lenguaje.

El lenguaje Visual Basic es una de las formas más rápidas de hacer una aplicación Windows.

Su rápido desarrollo nos permitirá ganar mucho tiempo, dinero y recursos.

Este curso está enfocado al Visual Basic porque además de ser un lenguaje que yo domino, lo considero muy sencillo de usar y rápido de aprender.

Seguro que al final del curso todos, absolutamente todos estaréis de acuerdo conmigo. ;)

A lo largo de este curso empezaremos con una breve introducción del Visual Basic, para luego ir explicando las formas y ejemplos de trabajar y hacer aplicaciones Visual Basic.

Para este curso emplearé el Visual Basic 4.0 32 bits, y apenas tocaré el Visual Basic 3.0 porque aunque yo todavía lo use de vez en cuando, siento decir que trabajar con Visual Basic 3.0 resulta anticuado, ya que todas las empresas están comenzando a migrar a Windows NT 4.0 y Windows 95. Por tanto, si queremos desarrollar aplicaciones para clientes y no deseamos "quedarnos" con ellos, habrá que decirles que migren, pues la tendencia del mercado va por estos lados.

Además, existen nuevas funciones API (ya veremos lo que es) de 32 bits que nos facilitan mucho trabajo. Trabajo que antes con el Visual Basic 3.0 debíamos hacerlo todo mediante código. :(

Podremos ver como se utilizan los controles básicos de Visual Basic 4.0, ejemplos y trucos.

También tocaremos temas como las dudas más comunes, sacadas de las news de Visual Basic Forum de Internet, en Inglés, Español y el área Visual Basic de Fidonet, así como información variada de otros foros acerca del tema y de Microsoft Visual Basic.

Quizás a lo largo del curso comencemos otro curso de Controles Visuales (ActiveX Controls u OCX Controls), que son usados por lenguajes de programación como Visual Basic 4.0, Visual Basic 5.0, Delphi 2.0, Delphi 97 o Delphi 3.0 y Power Builder 5.0 entre otros, así como por los navegadores de Internet.

Nada más empezar con Visual Basic, veremos 5 pantallas principales :

El programa Visual Basic : (1)

El formulario : (2)

La ventana de proyectos : (3)

La ventana de propiedades : (4)

La caja de herramientas : (5)

En la ventana del programa (1), podemos hacer todas las funciones normales que nos permite el compilador Visual Basic.

Cierre todas las ventanas excepto el programa Visual Basic (1).

Pulse "Ctrl+R" (Ver -> Proyecto) y se abrirá la ventana de proyectos (3).

En esta ventana tenemos todos los ficheros del proyecto Visual Basic en el que vamos a trabajar.

Al principio y por defecto, el programa abre un formulario (2) con el nombre Form1 que es la ventana Windows de nuestra aplicación.

Podemos editar, abrir y cerrar la ventana, pero todo esto lo veremos a fondo más tarde. De momento es fundamental que se familiarice con estas 5 ventanas que aparecen al iniciar Visual Basic.

Pulsando la tecla "F4", aparecerá la ventana de propiedades (4). Esta ventana es fundamental, ya que contiene todas las propiedades de cada objeto que insertaremos en nuestro formulario, asi como las propiedades del formulario en sí.

Por último, la ventana caja de herramientas (5), no es menos importante, ya que contiene todos los objetos que podemos incluir en nuestro formulario. Esta ventana se puede abrir en el menú principal (Ver -> Caja de herramientas).

Esta es la visión general del compilador Visual Basic, pero hay como bien se imaginará usted, muchas otras cuestiones que son importantes tener en cuenta.

Quizás usted halla oído hablar de las palabras Objeto, Método, Evento, Formulario, Módulo, Propiedades, etc, pero no sepa bien lo que es o lo que significan estas palabras. Es hora por tanto de ver su significado, pero antes me gustaría hacer alusión a la OOP (Programación orientada a objetos).

Microsoft defiende que Visual Basic 4.0 es un lenguaje OO (orientado a objetos), pero nada más lejos de la realidad. Quizás su nueva versión (Visual Basic 5.0) en versión beta actualmente sí disponga de las cualidades que le hacen ser un lenguaje OO, pero Visual Basic 4.0 NO es un lenguaje OO. Es cierto que se acerca mucho a este concepto, pero aún debe afinar sus conceptos y aceptar la herencia y herencia múltiple adecuadamente para que sea considerado un lenguaje de OOP.

Bueno, no nos despistemos más de la cuenta y vayamos al grano. ;)

Un objeto es una entidad que tiene asociado un conjunto de métodos, eventos y propiedades. Hay muchas clases de objetos, y por tanto, puede llegar a haber tantos métodos, eventos y propiedades distintas como objetos diferentes.

Ejemplo : Una caja de texto (TextBox) en la cual podemos escribir cualquier línea es un objeto.

Los métodos son funciones internas de un determinado objeto que permite realizar funciones sobre él o sobre otro objeto.

Ejemplo : Deseamos poner en la ventana Windows de nuestra aplicación "Hola mundo", por tanto pondremos el método -> Form1.Print "Hola mundo"

Un evento es una atención que realiza un programa, rutina, objeto o llamada para que nuestro programa lo trate.

Un programa Visual Basic es un POE (Programa orientado a eventos).

Todo lo que hacemos en un programa Visual Basic está generado por medio de eventos. Esto puede no quedar muy claro, por eso os voy a contar una historieta para haber si lo entendéis mejor. ;)

Imaginemos que tu vas por la calle paseando y pensando en tus cosas, lo que vas a hacer esta noche, con quien vas a ir, a quien debes llamar … etc. Como vas pensando en tus cosas, al llegar a la calle no te percatas de que el semáforo se ha puesto en verde y que tú sin darte cuenta vas a comenzar a cruzar. Un coche que estaba reanudando la marcha, lo ve y te pita. Tú levantas la cabeza y tratas en tu conciencia lo que está sucediendo :

1-. El semáforo está en verde.

2-. El coche te pita.

3-. Tú acabas de empezar a cruzar la calle.

4-. Solución?

Tratas todas las premisas y obras en consecuencia. Das dos pasos hacia atrás decididamente y te subes a la acera. El coche pasa y a tí no te ha pasado nada.

Uff!, todo este rollo para contar lo que es un evento, … bueno, pues un evento es una "atención" sobre algo que debe llevar a cabo el "protagonista" (en el ejemplo tú).

Ejemplo en Visual Basic: El click con el ratón sobre un botón.

Un formulario es una ventana. La ventana Windows de cualquier aplicación.

Podemos abrir tantas ventanas como queramos en nuestro proyecto, pero el nombre de las ventanas debe ser distinto. Por defecto como ya hemos visto, la ventana que se abre en Visual Basic tiene el nombre de Form1. Ya veremos como cambiar estas "Propiedades" más adelante.

Un proyecto Visual Basic no sólo está compuesto de Formularios, sino también de lo que se denominan módulos.

Un módulo es un fichero Visual Basic donde escribimos parte del código de nuestro programa, y digo parte, porque puede haber código en el formulario también, pero no desesperéis, ya tocaremos esto más adelante. Todo a su tiempo. :))

Son los datos que hacen referencia a un objeto o formulario.

Ejemplo : Color de fondo del formulario, Fuente de texto de un TextBox, ….

Como hemos visto, en la caja de herramientas (5), disponemos de un montón de controles que nos permiten "depositar" sus correspondientes objetos a nuestro formulario, sin embargo, no están todos los que están, ni son todos los que son, es decir, que podemos incluir quitar y añadir tantos controles como queramos o creamos conveniente.

Los controles en Visual Basic 3.0, llevaban la extensión .VBX, y estaban diseñados en programación de 16 bits, sin embargo, la nueva versión de Visual Basic 4.0, con soporte a 32 bits, permite utilizar controles de 32 bits y SOLO de 32 bits. Los nuevos controles que siguen esta filosofía y arquitectura, tienen la extensión .OCX.

Estos controles los podemos hacer nosotros mismos, otra empresa de Software, etc.

Cada control posee uno o más objetos o funciones que nos permiten realizar operaciones en nuestro programas.

Para agregar controles en Visual Basic, deberemos pulsar las teclas Ctrl+T. Se abrirá una ventana donde podremos seleccionar los controles OCX del disco duro.

Todos los controles seleccionados se añadirán a la caja de herramientas (5).

Dos consejos al utilizar esta opción :

a) Procura tener los controles OCX en tu directorio Windows\System. Te ahorrará muchos quebraderos de cabeza.

b) Si al intentar abrir un control OCX no te permite insertarlo a tu caja de herramientas (5) y te sale un error al cargarlo, entonces deberás registrarlo.

Para registrar un control OCX debes tener el programa RegSvr32.Exe en tu directorio Windows\system.

Escribe : "Regsvr32 nombre.ocx". Te deberá salir un mensaje: "Control registrado satisfactoriamente" o algo parecido.

Espero que lo hayáis entendido, pero sino, no os preocupéis, de momento no os va a ser muy útil.

Seleccionar Archivo -> Nuevo proyecto o simplemente abrir el programa Visual Basic. Aparecerá las 5 ventanas que hemos visto al comienzo del curso, sino aparecen, las abrimos como hemos visto.

Abrimos el formulario Form1 haciendo doble click en Form1 de la ventana de proyectos (3) sino está abierto ya.

Hacemos doble click sobre cualquier parte del formulario. Se nos presentará una ventana como esta :

Pinchamos sobre la parte que pone "Procedimiento". Se abrirá una lista desplegable. Seleccionamos "Paint", y escribimos :

Private Sub Form_Paint()

End Sub

Pulsamos la tecla F5 y entonces comenzará la ejecución del programa. Para finalizar la aplicación la cerraremos pulsando Alt+F4 por ejemplo o haciendo un click sobre el aspa de la ventana.

Sin embargo, esta manera de cerrar una ventana es muy anticuada o poco profesional, por lo que ahora veremos la forma correcta de hacerlo.

Antes de eso, analizaremos lo que sucede en este ejemplo :

El programa inicializa la ejecución comenzando por el formulario principal, que en este caso es el único que hay, Form1. Busca todos sus eventos para ejecutarlos uno detrás de otro empezando por Form1_Load() , y encuentra código en Form1_Paint().

Este código es un método. El método print que imprime un texto.

La forma correcta de hacer esto es hacer primero la llamada a la ventana u objeto al que queremos hacer referencia y mandarle el mensaje correspondiente print en este caso, y el contenido del mensaje.

Supongamos que deseamos cerrar la aplicación de forma normal. Es decir, queremos que exista un botón y que el usuario al pulsar sobre el botón, decida el cierre de la aplicación.

Muy bien, pinchamos sobre el 6º control empezando por la izquierda y de izquierda a derecha y de arriba a abajo en la caja de herramientas (5). El control se llama Command Button. Pinchamos una sola vez y pinchamos sobre cualquier parte del formulario y sin soltar el ratón extendemos una franja sobre el formulario que creamos adecuada. Esa franja será la dimensión del botón. Soltamos y ya está.

El nombre del botón por defecto es : Command1.

Hacemos doble click sobre el botón y escribimos :

Private Sub Command1_Click()

End Sub

Pulsamos F5 y pulsamos sobre el botón. El resultado es que el programa descarga el formulario y al ser el formulario padre, acaba su ejecución. Es importante que los formularios hijos hayan sido descargados anteriormente, sino ocuparán memoria.

Hay dos aspectos importantes a resaltar :

Imaginemos que un formulario padre ejecuta una serie de rutinas y que en una determinada abre una segunda ventana de nuestra aplicación, es posible que nos encontremos con dos situaciones bien distintas al pulsar el botón Command1.

a) Que aunque el formulario padre haya acabado su ejecución, no deseemos que el formulario hijo finalice la suya. Por tanto no es necesario añadir nada en el código anterior.

b) Sin embargo, es posible que deseemos que una vez que se acabe la ejecución del formulario padre, la aplicación finalice por completo. Aquí es donde deberíamos añadir código.

En el evento : Form_ Unload del formulario padre, deberíamos poner :

Private Sub Form_Unload(Cancel As Integer)

End Sub

De esta manera al pulsar el botón Command1 acabará la ejecución de la aplicación completamente.

Para ver esto mejor, haremos dos ejemplos.

Al ejemplo que estábamos haciendo, añadimos otro botón como lo hemos hecho antes. Fíjate que el nuevo botón se llama ahora Command2.

Seleccionamos en el menú Insertar -> Formulario, un nuevo formulario se abrirá denominado Form2. Con el ratón acotamos su anchura y altura para hacerlo visible al primer formulario, ya que ejecutaremos ambos al mismo tiempo en un momento dado de la ejecución, y es importante ver que están ahí.

Haciendo doble click sobre el botón Command2 del Form1, escribimos :

Private Sub Command2_Click()

End Sub

Pulsamos F5. Ejecutará el Form1. Pulsamos sobre Command2 y abrirá Form2. Pinchamos sobre el botón Command1 de Form1 y el formulario Form1 se cerrará, pero Form2 seguirá activo. Pulsamos Alt+F4 y cerrará el Form2.

Ahora pongamos en Form1 el código que antes hemos visto : Form_Unload(Cancel As Integer)

Pulsamos F5, abrimos el Form2 y pulsamos Command1. Los formularios se cerrarán completamente y acabará la ejecución de la aplicación.

¿Sencillo verdad?.

Repaso :

De momento hemos visto como cargar y descargar un formulario y como finalizar la ejecución de un programa Visual Basic. En los próximos capítulos veremos como abrir una ventana en la que ella y sólo ella coja el "protagonismo" de la ejecución del programa y como cambiar algunas propiedades de la ventana para hacerla conveniente a nuestros propósitos.

No dejaremos tan pronto las ventanas, ya que considero importante entender bien su funcionamiento. Una vez logrado esto, nos meteremos con los controles Visual Basic, dando un repaso a los más utilizados.

Recordemos que este curso está enfocado al programa Visual Basic 4.0 Profesional.

Cuando hacemos un programa Windows, deseamos a veces hacer visible una parte de la ventana o toda, o simplemente deseamos que la ventana sólo se pueda cerrar o acortar y ensanchar, minimizar, maximizar, … etc.

Dependiendo de nuestras necesidades, estas las lograremos mediante la ventana de propiedades (4).

En esta ventana, podemos asignar cualquier propiedad que nos interese sobre la ventana. Así, supongamos que queremos que nuestra ventana adopte las siguientes características con sus correspondientes soluciones :

Otra de las características de una ventana Windows, es la posibilidad que tiene esta de maximizarse o minimizarse en o durante su ejecución. Esto lo logramos con la propiedad "WindowState" que tiene 3 valores. Estado normal de la ventana o "0", estado minimizado o "1" y estado maximizado o "2".

Podemos hacer que la ventana Windows no aparezca en la barra de tareas de Windows. Esto se consigue poniendo la propiedad "ShowTaskBar" a valor Falso.

Las ventanas pueden ser centradas en cualquier posición del espacio de resolución de Windows.

Como ya hemos visto en el tema anterior, las ventanas podían ser maximizadas y minimizadas, pero también es posible moverlas o situarlas en una determinada posición.

Esto puede producirse durante la ejecución de del programa.

Al igual, que esta cualidad, es posible modificar también el tamaño (ancho y alto) de la ventana.

Para centrar una ventana, podemos utilizar dos métodos. El primero es menos profesional y rápido, el segundo es mucho más rápido.

Si lo que deseamos hacer, es ensanchar o alargar la ventana, debemos cambiar estas propiedades :

Width (ancho).

Height (alto).

Es posible que lo que queramos sea mover la ventana arriba, abajo, a la derecha o a la izquierda de su posición. Para lograr esto, debemos cambiar las propiedades de la ventana siguiente :

Top (situación vertical de la ventana. Más arriba o abajo).

Left (situación horizontal de la ventana. A la derecha o izquierda).

Estas últimas cuatro propiedades son modificadas mediante números. Es decir, que podemos escribir sentencias Visual Basic propias del uso de estas propiedades como :

Otras propiedades de las ventanas son :

El color de fondo de la aventana, que se selecciona con la propiedad Backcolor.

El icono de la ventana (muy importante o aconsejable!!) que se selecciona con la propiedad Icon.

La propiedad name es el nombre por el cual nos referiremos a la ventana. Hasta ahora hemos utilizado el nombre Form1 que es el que utiliza Visual Basic por defecto. Puede ser que queramos hacer alusión a un determinado nombre de la ventana. Por ejemplo, a la ventana la llamamos Aplicacion. Desde ahora cada vez que hagamos referencia a cualquier propiedad o evento de la ventana, lo deberemos hacer con el nombre de Aplicacion antes de la propiedad o evento. Así por ejemplo, en Form1.Top=Form1.Left + 200, deberíamos haber puesto Aplicacion.Top=Aplicacion.Left + 200.

Por último, veremos la propiedad Caption de la ventana. Esta propiedad es la que hace referencia al título de la ventana.

Los controles personalizados o controles ActiveX también denominados Ocx, son unas librerías especiales desarrolladas para facilitarnos "algunas" líneas de código que por su extensión o complejidad, hemos desarrollado con otro lenguaje o con el mismo Visual Basic (Visual Basic 5.0 CCE).

En Visual Basic 3.0 o anteriores, el único control que podía ser utilizado, era el control Vbx. Este tipo de controles son de 16 bits.

Con la llegada de Visual Basic 4.0 y de los 32 bits, los controles a usar en este lenguaje de programación son los controles Ocx de 32 bits.

Estos controles pueden ser desarrollados con otros lenguajes de programación o con el reciente programa de Microsoft Visual Basic 5.0 CCE.

Entre algunos lenguajes capaces de desarrollar controles Ocx, nos encontramos con Visual C++ 4.0 o superior, Borland C++ 5.0, y Delphi. Es muy posible que me deje a algún lenguaje por ahí, pero estos son los más utilizados.

Podemos encontrar controles Ocx en el mundo de muy diversos tipos.

Los controles Freeware o gratuitos, los shareware o de prueba antes de pagar, los cardware … etc.

Estos controles pueden ser encontrados además en BBS o en la distribución de nuestra aplicación.

Si nuestra aplicación utiliza controles personalizados, estos deben distribuirse junto a nuestra aplicación, por tanto, a la hora de instalarla, se encontrarán en nuestro disco duro.

Los controles Ocx son los objetos que en nuestro formulario colocaremos. Por ejemplo, un botón, una caja de texto, una barra de estado, … etc.

Para insertar un nuevo control en la caja de herramientas (que ya vimos en el tema 1), deberemos seleccionar el menú : Herramientas -> Controles personalizados o pulsar la tecla Ctrl+T.

Se nos presentará una ventana donde podremos seleccionar los controles que deseemos añadir o eliminar de nuestra caja de herramientas. Los controles están situados generalmente (y es bueno que así sea) en el directorio System de Windows, por ejemplo en : C:\Windows\System.

Es posible que a la hora de añadir un determinado control Ocx en nuestra caja de herramientas, este no sea aceptado produciéndose un error. Esta es una de las cualidades de los controles Ocx. Deben ser registrados. Algunos se registran directamente sin que nosotros lo percibamos, sin embargo, hay controles que debemos registrarlos nosotros mismos para poder utilizarlos. Este registro se produce ejecutando el programa "Regvsr32.exe". La sentencia correcta es "Regsvr32 nombre.ocx". Si todo ha ido perfectamente, un mensaje aparecerá en una pequeña ventana informándonos de la correcta instalación del control en la página de registros de Windows. Ahora deberemos volver a repetir los pasos a seguir para añadir el control Ocx en nuestra caja de herramientas como hemos visto con anterioridad.

El control quedará añadido ahora en nuestra caja de herramientas.

Ahora veremos los controles más utilizados que vienen con el programa Visual Basic 4.0 Profesional y como usarlos.

Este control es uno de los más utilizados en los proyectos Visual Basic. Apenas hay algún proyecto que no utilice alguna etiqueta o label.

Su uso reside en la aclaración o explicación de algunas partes de la ventana de nuestro proyecto.

Sus propiedades más importantes son :

Alignment es usada para alinear el texto de la etiqueta a la izquierda, derecha o centrado.

Appearance utilizado para dar un efecto 3D o no a la etiqueta. Si elegimos el valor 1, le damos este efecto 3D, si le damos el valor 0, queda sin efecto 3D. Por defecto tiene el valor 1.

Backcolor selecciona el color de fondo de la etiqueta.

BackStyle tiene dos posibles valores. 0 - Transparent y 1 - Opaque. Si elegimos 0, el fondo de color de la etiqueta será ignorado, si elegimos 1, adoptará el color que nosotros habíamos seleccionado.

BorderStyle es utilizado para asignarle un borde de la etiqueta. Si la propiedad Appearance está con valor 1, la etiqueta adopta una forma en relieve muy vistosa.

Caption es el contenido de la etiqueta.

DataField y DataSource son utilizados con Bases de Datos.

Enabled es la propiedad que hace que el control esté habilitado o desabilitado. El valor True de este control, confirma el funcionamiento normal del control, mientras que el valor False deja el control desabilitado. Cuando un control está desabilitado adquiere un tono gris claro.

Font es usado para seleccionar el tamaño, propiedad y fuente del texto.

Forecolor es la propiedad del color de la fuente.

Height, Left, Top, y Width son utilizadas de la misma manera que para el formulario como ya hemos visto anteriormente.

MouseIcon y MousePointer son usadas para cambiar el puntero del ratón en tiempo de ejecución. Si cambiamos la propiedad MousePointer a otro valor, al acercar el ratón sobre la etiqueta el puntero del ratón cambiará.

Name es el nombre de la etiqueta. A veces queremos cambiar algún contenido o propiedad de este control u objeto, con lo que llamarlo de una determinada forma es importante para hacer referencia sobre él sin equivocarnos.

Visible esta propiedad es utilizada para hacer visible o no la etiqueta o label. En tiempo de diseño todas los controles u objetos serán visibles, siendo efectivas estas propiedad en tiempo de ejecución.

La caja de texto o TextBox, es junto al control Label o etiqueta uno de los controles que más podemos ver y utilizar en nuestros proyectos.

Se suele utilizar para que el usuario introduzca algún texto para que el programa lo trate y de una respuesta.

Locked es la posibilidad que tiene un TextBox de ser de sólo lectura o de lectura y escritura. Esto es utilizado para mostrar un texto que no deseamos que sea manipulado por el usuario. Para que sea de sólo lectura, debe tener la propiedad True.

MaxLength es la propiedad que nos permite seleccionar un tope de caracteres insertados en el TextBox, como por ejemplo 20 para el nombre de una persona. Si la dejamos a 0, el texto admitirá tantos caracteres como admita el control hasta que este se llene.

Multiline nos permite escribir en el TextBox una línea de texto una debajo de otra si la propiedad de este control está a True y una línea seguida si está a False.

PasswordChar nos permite escribir el texto encriptado con el carácter que nosotros le pongamos. Por ejemplo, si ponemos * (asterisco), cada letra que escribamos en el TextBox será vista como * (asteriscos). Esto es muy usado en password o palabras clave o secretas.

ScrollBars nos permite tener una barra de scroll para bajar, subir, adelantar o atrasar el texto que escribimos o que está escrito. Este control tiene 4 posibilidades. Sin scroll, con scroll horizontal, con scroll vertical, y con scroll horizontal y vertical.

Default nos permitirá dejar el botón por defecto como accesible, de modo que al abrir una ventana que tiene un botón y al pulsar enter, se accionará el botón que esté por defecto o default.

Align posee la característica y posibilidad de alinear una Picture a la parte superior del formulario, a la inferior o ajustar la picture al formulario.

AutoRedraw permite redibujar o refrescar el Picture. Esto es efectivo si se realizan modificaciones en la Picture y se desean visualizar.

Aún así, todo esto que hemos visto es muy teórico, por lo tanto vamos a ver el resto de controles (que poseen características muy similares o iguales a los ya vistos) practicando y aprendiendo que es la mejor forma de comprender todo. Aunque hemos visto estos 4 controles, el resto de controles no los veremos tan profundamente, con lo que a partir de ahora, prácticamente todo se basará en la práctica.

· Ejemplo 1; iniciación :

Para iniciarnos en el uso de los diferentes controles de Visual Basic 4.0, vamos a desarrollar un ejemplo que nos hará comprender el uso de los controles que hemos visto teóricamente, para más tarde irlo complicando a medida que avanzamos, con otros controles.

Abra un nuevo proyecto e inserte y escriba estas propiedades y controles:

Formulario;

Caption = Ejemplo 1

BorderStyle = 3

Height = 2100

Width = 2400

Dos TextBox con las propiedades;

Text1

Text = "" (nada)

Top = 100

Left = 100

Width = 2100

Height = 300

MaxLength = 20

Text2

Text = "" (nada)

Top = 600

Left = 100

PasswordChar = *

Width = 2100

Height = 300

Locked = True

MaxLength = 20

Un ButtonClick;

Caption = Aceptar

Height = 400

Width = 1200

Top = 1100

Left = 540

Enabled = False

Hacer doble click sobre el Text1 y escribir;

Private Sub Text1_Change()

If Text1.Text = "" Then

Command1.Enabled = False

Else

Command1.Enabled = True

End If

Text2.Text = Text1.Text

End Sub

Hacer doble click sobre el ButtonClick (botón) y escribir;

Private Sub Command1_Click()

MsgBox "Texto 1: " & Text1.Text & " y texto 2 " & Text2.Text

Unload Form1

End Sub

Este es un ejemplo de iniciación al Visual Basic y la utilización del control "Caja de texto" y del "Botón". Conforme vayamos avanzando en el curso, este tratará ejemplos sin tanto texto. Este primer ejemplo ha sido bastante descriptivo debido a que el lector debe ir cogiendo soltura de las propiedades y eventos de los diferentes controles.

Repaso de lo visto hasta ahora : Hemos visto los controles más habituales usados en Visual Basic. Hay muchos más controles que iremos profundizando según avancemos en el curso, pero de momento no quiero liar a nadie, y por tanto, el resto de controles los veremos con ejemplos prácticos.

Así mismo, hemos visto un ejemplo de iniciación del Visual Basic en el que se podía usar dos de los controles que hemos visto, el TextBox y el CommandButton. Hemos tratado de ver todas sus características, aunque no hemos podido ver todas las importantes como la Multiline o la ScrollBar.

A partir de ahora, los ejemplos que hagamos serán menos largos de explicación que el que hemos visto, por tanto, animo a todo aquel que se decida y no tenga miedo a errar, que pruebe a modificar valores o atributos del ejemplo que hemos realizado, a buen seguro que merecerá la pena.

· Ejemplo 2 de Label, TextBox, CommandButton y PictureBox :

Abra un nuevo proyecto y pegue una Picture Box, un TextBox, una Label por encima del TextBox y dos Botones (CommandButton).

En la propiedad Caption del formulario debe escribir Ejemplo 2.

En la propiedad Caption de la etiqueta escriba : "Nombre :"

La propiedad Text de la caja de texto déjela en blanco, y escriba en MaxLenght 10.

La PictureBox sitúela por debajo de la caja de texto y de un tamaño aproximadamente del doble de la caja de texto.

Los dos botones alinéelos uno al lado del otro y por debajo de la Picture.

Para el primer botón, escriba en la Caption "&Aceptar" y "&Salir" para el otro botón.

Ponga la propiedad Default del primer botón a True.

Haga doble click sobre el primer botón y escriba :

Private Sub Command1_Click()

Picture1.Cls

Picture1.Print Text1.Text

End Sub

Haga doble click sobre el segundo botón y escriba :

Private Sub Command2_Click()

Unload Form1

End Sub

Corra la aplicación en modo de diseño pulsando la tecla F5 y pulse el botón Aceptar. El texto de la caja de texto será "imprimido" en la PictureBox.

Haga lo mismo pero añadiendo el carácter ' delante de la línea Picture1.Cls, notará que la línea ha cambiado de color. El carácter ' indica que lo que hay en esa línea es un comentario. Es decir, Picture1.Cls lo hemos dejado como comentario, con lo que Visual Basic no lo ejecutará. No se asuste, esto es para demostrar otra propiedad del PictureBox. Pulse nuevamente F5 y haga lo mismo. Pulse el botón Aceptar tantas veces como quiera.

En el primer ejemplo hemos observado que el texto imprimido en la PictureBox ha sido eliminado o borrado y puesto el nuevo. Esto se consigue con el parámetro Cls.

En el segundo ejemplo, los caracteres no son borrados, sino que se van añadiendo al PictureBox.

Si desea ver otra fuente de letra o color de letra en un PictureBox, deberá modificar las propiedades ForeColor y Font.

· Ejemplo 3 de Multiline con un TextBox :

Abra un nuevo proyecto y pegue un TextBox y un Botón (CommandButton).

En la propiedad Caption del formulario debe escribir Ejemplo 3.

El botón tendrá la misma propiedad que el botón 2 del ejemplo 2 (el de Salir).

El TextBox tiene las siguientes propiedades ;

Multiline = True.

Text = "" (nada).

ScrollBars = Vertical.

Escriba tanto texto como quiera. Observará que al llegar al final de la línea, continúa saltando a la siguiente.

Pulse el botón para finalizar.

Haga lo mismo pero con la propiedad Multiline a False.

Notará que pese a tener la propiedad ScrollBars como Vertical, el control TextBox se comporta como si tuviese la propiedad 0 - None (ninguna).

Ahora bien, supongamos que deseamos que nuestra aplicación muestre un texto escrito por nosotros. A lo mejor nos interesa mostrar varios saltos de línea entre párrafo y párrafo.

En Visual Basic 3.0 y anteriores, se utilizaba una constante global, que en mi caso por ejemplo, la declaraba en un módulo (aunque el tema de las constantes lo veremos más adelante, esto valdrá como anticipo). Inserte un módulo al proyecto y escriba Global NL.

Esto produce un salto de línea. Así por ejemplo, si utilizamos por ejemplo en el evento Load de Form1:

Text1.Text = "Ejemplo con Visual Basic" & NL & "Segunda línea.", obtendremos un resultado como :

Recuerde que la propiedad Multiline del TextBox debe estar a True para que esto tenga efecto.

En Visual Basic 4.0 esto cambia, ya que Microsoft introduce una constante que nos permite no tener que declarar esta variable. La constante se llama vbCrLf. Por tanto, no es necesario hacer ninguna referencia a ninguna constante en el módulo. Tan sólo con utilizar esta constante es suficiente. Así, en el ejemplo último, en el evento Load del Form1 podemos escribir : Text1.Text = "Ejemplo con Visual Basic" & vbCrLf & "Segunda línea."

· Ejemplo 4 Uso de MsgBox  :

Abra un nuevo proyecto y pegue un TextBox y un Botón (CommandButton).

En la propiedad Caption del formulario debe escribir Ejemplo 4.

El botón tendrá la misma propiedad que el botón 2 del ejemplo 2 (el de Salir).

La propiedad Visible del Botón, póngala a False.

Aunque el uso de MsgBox no pertenece al apartado de estos controles propiamente, iremos ampliando conocimientos poco a poco, y por eso, será bueno entender lo que es para completarlo en otro capítulo.

Escriba en el evento Load de Form1: Text1.Text = "Ejemplo con Visual Basic" & vbCrLf & "Segunda línea.".

Haga doble click en el botón y escriba para el evento Click del botón el siguiente código:

MsgBox "Usted ha escrito: " & vbCrLf & Text1.Text

Unload Form1

Pulsamos F5 para ejecutar la aplicación. El TextBox no estará visible.

Pulsamos sobre el botón y veremos que se nos presenta un mensaje en pantalla que nos muestra lo que usted ha escrito en el TextBox.

· Ejemplo 5 usar el PictureBox  :

Abra un nuevo proyecto y pegue un PictureBox y dos Botones (CommandButton).

En la propiedad Caption del formulario debe escribir Ejemplo 5.

Uno de los botones seguirá siendo el mismo que el de los ejemplos anteriores (sin el MsgBox).

El otro botón permite pegar una imagen en la PictureBox. Por ejemplo, la propiedad Caption de este botón póngala como "Pegar". Haga doble click sobre él y escriba en el evento Click:

Picture1.Picture = LoadPicture("C:\WINDOWS\Greca.bmp")

(o cualquier otra imagen siempre y cuando exista).

Esto nos permite visualizar imágenes Bmp, Ico y Wmf en el PictureBox en modo de ejecución.

Ampliaremos ahora un poco nuestros conocimientos con una parte muy importante en Visual Basic como es el tratamiento de errores.

Escriba el siguiente código :

Private Sub Command2_Click()

On Error GoTo fallo:

Picture1.Picture = LoadPicture("C:\Windows\Greca.bmf")

Exit Sub

fallo:

MsgBox "Error, fichero no encontrado."

End Sub

Debe apreciar que el programa intentará ejecutar la primera línea. En caso de error, se irá a la etiqueta llamada fallo y tratará el error. Puede haber muchas causas de errores que veremos en próximos capítulos, pero de momento forzaremos un error y lo trataremos. A veces es importante forzar errores en los programas para controlar una determinada acción.

Por tanto, el programa ejecutará línea a línea. Si no encuentra errores, al llegar a la línea Exit Sub el evento del programa llamado acabará. En caso de encontrar un error de ejecución irá a la etiqueta fallo donde tratará el error hasta encontrarse con End Sub.

Repaso de lo visto hasta ahora : Además de haber visto el uso de los controles Label, TextBox, CommandButton y PictureBox, nos hemos iniciado con el uso de salto de carro vbCrLf, el uso de MsgBox y el tratamiento de errores.

En los temas siguientes profundizaremos en estos apartados antes de continuar con el resto de controles.

En versiones anteriores de Visual Basic, la forma de realizar un salto de página en un TextBox era cambiando la propiedad Multiline a True y escribiendo una constante string cualquiera con valor igual a Chr$(13) & Chr$(10), es decir salto de párrafo.

Con la versión Visual Basic 4.0, se usa una constante VbCrLf que realiza esta función.

Las cajas de mensajes o Message Box, tienen una función clara, que es la de mostrar una determinada información, aviso, o pregunta para que el usuario tenga conocimiento de ella y actúe.

Hay diferentes formas de mostrar información :

1) El aviso es sí, que tiene por objetivo mostrar una información de interés.

2) El aviso con espera de respuesta, que muestra una información esperando que el usuario seleccione una de las respuestas posibles para que el programa la trate.

Una caja de mensaje, puede ser por ejemplo, la instrucción MsgBox "Hola" .

Por defecto, la caja de mensaje será similar a esta :

Debe darse cuenta de algunas cosas :

En primer lugar el mensaje, "Hola" que se escribe a continuación de la palabra MsgBox, también debe darse cuenta del botón Aceptar que tiene el Focus de la ventana activa y que sólo hay ese botón, y por último el título de la ventana.

Podemos modificar estos parámetros para alcanzar nuestros objetivos, por eso, vamos a escribir ahora este código : MsgBox "Hola", ,"Ejemplo" .

El resultado es :

Como podemos apreciar en el código, la caja de mensaje posee un título Ejemplo y el mensaje, pero es posible que deseemos escribir un mensaje en varias líneas con salto de párrafo. Nada tan fácil como este código por ejemplo : MsgBox "Hola" & vbCrLf & "Esto es un ejemplo.", , "Ejemplo".

El resultado es :

Supongo que se habrá percatado de que entre el mensaje y el título de la ventana, hemos escrito dos comas, esto es porque entre las comas, debe ir un número que representará el icono a mostrar. Existen cuatro iconos diferentes además de la posibilidad de no mostrar ninguno. Los iconos son :

Estos iconos corresponden a los siguientes mensajes :

Mensaje crítico.

Mensaje de pregunta.

Mensaje exclamativo.

Mensaje de información.

Para mostrar el icono en cuestión o para que Visual Basic lo entienda, es necesario escribir lo siguiente :

Mensaje crítico. VbCritical ó 16

Mensaje de pregunta. VbQuestion ó 32

Mensaje exclamativo. VbExcalamqtion ó 48

Mensaje de información. VbInformation ó 64

Note que es lo mismo insertar VbCritical o 16.

Vamos a ver un ejemplo añadiendo un icono al último ejemplo :

El resultado es :

Ahora bien, es posible que queramos mostrar algún otro botón que o bien no sea el de Aceptar o que además del botón de Aceptar haya más botones. Para este propósito, tenemos los siguientes parámetros :

Aceptar vbOKOnly ó 0

Aceptar y Cancelar vbOKCancel ó 1

Anular, Reintentar, Ignorar vbAbortRetryIgnore ó 2

Sí, No y Cancelar vbYesNoCancel ó 3

Sí y No vbYesNo ó 4

Reintentar y Cancelar vbRetryCancel ó 5

Aplicación modal vbApplicationModal ó 0 (Es la caja de mensaje sin icono)

La forma de hacer esto es sumar al parámetro del icono que queremos mostrar el valor de los botones que deseamos que aparezcan.

Así por ejemplo :

El resultado es :

Aún así, es posible que deseemos que el Focus lo adquiera otro un botón determinado. Por ejemplo, en este caso el Focus lo tiene el botón Sí, pero es posible que deseemos que lo tenga el botón No por ejemplo. Esto se consigue con los siguientes parámetros :

Primer botón predeterminado vbDefaultButton1 ó 0

Segundo botón predeterminado vbDefaultButton2 ó 256

Tercer botón predeterminado vbDefaultButton3 ó 512

Por ejemplo : MsgBox "Hola" & vbCrLf & "Esto es un ejemplo.", vbQuestion + vbYesNo + vbDefaultButton2, "Ejemplo"

El resultado es :

Si no se señala el botón predeterminado, Visual Basic seleccionará el primer botón.

En caso de seleccionar como predeterminado un botón que no existe, (por ejemplo el tercero), Visual Basic seleccionará el primero.

Ahora bien, si decidimos mostrar un mensaje esperando una respuesta, o queremos saber que botón ha pulsado el usuario, esto lo podemos conseguir mediante el siguiente código de respuestas :

Aceptar vbOK ó 1

Cancelar vbCancel ó 2

Anular vbAbort ó 3

Reintentar vbRetry ó 4

Ignorar vbIgnore ó 5

Sí vbYes ó 6

No vbNo ó 7

Así por ejemplo, el siguiente código :

Dim Resp As Integer

Resp = MsgBox("Hola" & vbCrLf & "Esto es un ejemplo.", vbQuestion + vbYesNo + vbDefaultButton2, "Ejemplo")

If Resp = 6 Then

MsgBox "Ha pulsado SI"

Else

MsgBox "Ha pulsado NO"

End If

Tiene el resultado siguiente :

Si pulsamos el botón Sí obtendremos una acción, y si pulsamos el otro botón otra acción.

Ahora bien, para elegir o seleccionar un evento o acción, el usuario debe saber combinar los códigos, sabiendo que un MsgBox posee la siguiente sintaxis principal:

El InputBox o caja de entrada es otra de las partes más utilizadas para la interacción del usuario con la aplicación. Es importante que el usuario interactúe con la aplicación para ser el protagonista de esta.

El InputBox nos permite sacar una caja donde el usuario pasará un parámetro, valor o dato para que el programa lo trate y lo ejecute.

El mensaje que quiere que aparezca se realiza de forma casi idéntica al MessageBox. Puede escribirse varias líneas de texto seguidas por la constante de Visual Basic VbCrLf o salto de línea o párrafo.

La sentencia es : Val = InputBox (Mensaje, Titulo, ValorPredeterminado)

Val almacenará el texto escrito por el usuario, que puede ser una cantida, cadena string, … etc.

Por ejemplo :

Tiene como resultado :

Ahora bien, podemos determinar un texto predeterminado a la caja de entrada, como por ejemplo :

Obtendremos como resultado :

Es importante determinar que si el usuario elige el botón Cancelar, el programa devolverá una cadena de caracteres igual a 0, es decir, Val="".

La caja de entrada puede ser sin embargo más personalizada mediante dos parámetros como son la posición de la ventana de entrada de datos en la pantalla. Estos parámetros se ponen a continuación del ValorPredeterminado.

Por ejemplo :

Situará la ventana en el eje de las X a 1200 twips (posición horizontal) y la Y a 1400 twips (posición vertical).

Vamos a programar a partir de ahora nuestras propias aplicaciones.

Es mejor practicar que llenar este curso de palabras y teoría. Para aprender a programar es fundamental practicar, practicar y practicar. De momento y en las tres lecciones anteriores, hemos dado buena cuenta de práctica mezclada con teoría, porque es indispensable conocer antes el entorno de trabajo donde nos moveremos, para no perdernos más tarde por él.

Las aplicaciones que tratemos a partir de ahora, constituirán el uso de lo visto ya con nuevos controles, código y técnicas.

La programación en Visual Basic es una programación orientada a eventos, es decir, no posee código estructurado claro, sino dentro de los eventos, siendo uno el comienzo y otro el final, pero puede haber varios (más de uno) finales en nuestros programas (p. ej.: error grave detectado en la ejecución de una sentencia que no nos permita continuar para no degradar el programa o el resultado de este).

Ejemplo 1. (Parte 1)

Para ello, deberemos pensar cuáles son los objetivos del programa para utilizar los controles justos.

Pongámonos manos a la obra.

Haga click en el formulario una vez y pulse las teclas Ctrl+E.

Escriba lo siguiente:

Caption: &Abrir

Name: mnuAbrir

Pulse el botón Siguiente.

Caption: &Guardar

Name: mnuGuardar

Pulse el botón Siguiente.

Caption: &Salir

Name: mnuSalir

Ponga un TextBox en el formulario y escriba las siguientes propiedades:

Text: ""

Multiline: True

ScrollBars: Vertical

Escriba el título de nuestro formulario:

Caption: Editor

En el control CommonDialog escriba:

InitDir: C:\

CancelError: True (checked)

Ahora ajustaremos el tamaño del TextBox al tamaño del formulario, para darle una vista más atractiva.

Para ello escribimos el siguiente texto:

Con este evento logramos que cada vez que cambiemos el tamaño de nuestra ventana (maximizar, minimizar, … etc), el control TextBox se ajuste en tamaño con este a la vez.

Ahora añadimos la propiedad WindowState del formulario a valor 2-Maximized.

Aún, nos queda el código más importante, ya que de momento le hemos dado el aspecto GUI deseado a nuestro programa. Es indispensable que nuestro programa realice bien su trabajo y por tanto nos quedará por escribir todas las instrucciones necesarias para ello.

Añada el siguiente código:

' Menu: Salir

Private Sub mnuSalir_Click()

Dim Respuesta As Integer

Respuesta = MsgBox("¿Desea salir del editor?", 36, "Editor")

If Respuesta = 6 Then

Unload Form1

End If

End Sub

'Menu Abrir

Private Sub mnuAbrir_Click()

Dim nLen, nCanal As Integer

On Error GoTo error

CommonDialog1.DialogTitle = "Abrir archivo"

CommonDialog1.Filter = "Archivos de Texto (*.txt;*.wri;*.me;*.bbs)|*.txt;*.wri;*.me;*.bbs|Todos los ficheros(*.*)|*.*"

CommonDialog1.ShowOpen

nCanal = FreeFile

Open CommonDialog1.filename For Binary As #nCanal

nLen = LOF(nCanal)

Texto$ = Space$(nLen)

Get #nCanal, , Texto$

Text1.Text = RTrim$(Texto$)

Close #nCanal

Exit Sub

error:

'Escribe o gestiona el error aquí si quieres

Exit Sub

End Sub

'Menu Guardar

Private Sub mnuGuardar_Click()

Dim nCanal As Integer

On Error GoTo error

CommonDialog1.DialogTitle = "Guardar archivo"

CommonDialog1.Filter = "Archivos de Texto (*.txt;*.wri;*.me;*.bbs)|*.txt;*.wri;*.me;*.bbs|Todos los ficheros(*.*)|*.*"

CommonDialog1.ShowSave

nCanal = FreeFile

Open CommonDialog1.filename For Output As nCanal

Print #nCanal, Text1.Text

Close #nCanal

Exit Sub

error:

'Escribe o gestiona el error aquí si quieres

Close #nCanal

Exit Sub

End Sub

Con este código, nuestro programa abre y graba un archivo de texto.

Aún, así, nuestra aplicación carece del aspecto profesional que se merece, por lo que es necesario mejorar algunas opciones para realizar un editor de texto más profesional, además de hacer uso de algunos controles y llamadas a las API de Windows.

Manos a la obra.

Para darle un aspecto más propio de un editor profesional, incluiremos en nuestro proyecto un control llamado StatusBar, el cual nos permite mostrar varios aspectos de interés al usuario.

Seleccione el control StatusBar de nuestra caja de herramientas e insértelo en el formulario extendiéndolo.

Pinche con el botón derecho del ratón sobre la barra de estado, y seleccione Propiedades.

Dentro de la ventana de propiedades del control StatusBar, pinche sobre la solapa Paneles, y una vez que esté situado sobre esta, siga estos pasos:

Index: 1

Text: Intersoft - 2000

ToolTip Text: ejemplo de StatusBar

Alignment: 1 - sbrCenter

Style: 0 - sbrText

Bevel: 2 - sbrRaised

AutoSize: 1 - sbrSpring

Pulse sobre el botón Insert Panel y escriba:

Index: 2

Minimun Width: 600

Alignment: 1 - sbrCenter

Style: 2 - sbrNum

Bevel: 1 - sbrInset

AutoSize: 2 - sbrContent

Pulse sobre el botón Insert Panel y escriba:

Index: 3

Minimun Width: 600

Alignment: 1 - sbrCenter

Style: 1 - sbrCaps

Bevel: 1 - sbrInset

AutoSize: 2 - sbrContent

Pulse sobre el botón Insert Panel y escriba:

Index: 3

Minimun Width: 600

Alignment: 1 - sbrCenter

Style: 3 - sbrIns

Bevel: 1 - sbrInset

AutoSize: 2 - sbrContent

Pulse sobre el botón Insert Panel y escriba:

Index: 4

Minimun Width: 600

Alignment: 1 - sbrCenter

Style: 4 - sbrScrl

Bevel: 1 - sbrInset

AutoSize: 2 - sbrContent

Pulse F5 y sitúe el icono del ratón sobre el texto de la barra de estado, podrá ver que el texto " ejemplo de StatusBar" aparece junto a la barra de estado. Aquí puede poner cualquier referencia que desee o dejarlo en blanco. Es útil para mostrar información adicional del programa como "Programa Shareware", una dirección de e-mail, etc.

El resultado parcial es aproximadamente este:

Hasta aquí, todo va resultando sencillo, y con pocas líneas hemos dado una apariencia más profesional a nuestra aplicación. Todo sin hacer un gran esfuerzo.

Ahora bien, es posible que deseemos dar mayor funcionalidad a nuestra aplicación.

Debemos tener en cuenta, que nuestra aplicación posee un error de programación muy importante y habitual a los programadores de Visual Basic. Este error es producido cuando deseamos cerrar nuestra aplicación. Si pulsamos en el menú sobre la palabra Salir, el programa nos pregunta si deseamos o no salir de la aplicación, pero si pulsamos sobre el aspa de la ventana:

el programa no nos preguntará si deseamos acabar, es decir, concluirá directamente nuestra aplicación. Ahora bien, puede ser que deseemos realizar dos cosas cuando se pulse sobre el aspa de la ventana:

Veámoslo son sendos ejemplo, para que usted elija el que crea más oportuno:

Ejemplo 1:

' Menu: Salir

Private Sub mnuSalir_Click()

Unload Form1

End Sub

Private Sub Form_Unload(Cancel As Integer)

Dim Respuesta As Integer

Respuesta = MsgBox("¿Desea salir del editor?", 36, "Editor")

If Respuesta = 6 Then

Unload Form1

Else

Cancel = True

End If

End Sub

Ejemplo 2:

'En General declaraciones, escriba:

Private Pasa

'Inicializamos el valor de la variable Pasa:

Private Sub Form_Load()

Pasa = False

End Sub

' Menu: Salir

Private Sub mnuSalir_Click()

Dim Respuesta As Integer

Respuesta = MsgBox("¿Desea salir del editor?", 36, "Editor")

If Respuesta = 6 Then

Pasa = True

Unload Form1

End If

End Sub

Private Sub Form_Unload(Cancel As Integer)

If Pasa = False Then

Cancel = True

End If

End Sub

Con esta segunda forma, mantenemos un control de ignorar cuando el usuario pulsa sobre el aspa de la ventana, obligando al usuario a pulsar la opción del menú Salir.

Pulsamos Ctrl+E y pinchamos una vez con el ratón sobre &Salir y pulsamos el botón Insertar.

Escribimos las siguientes propiedades:

Caption: &Editor

Name: mnuEditor

Pinche otra vez con el ratón sobre &Salir y pulsamos el botón Insertar.

Pulse ahora sobre el botón con la punta de flecha hacia la derecha: -->

Caption: &Seleccionar Todo

Name: mnuSeltodo

Pinche otra vez con el ratón sobre &Salir y pulsamos el botón Insertar.

Pulse ahora sobre el botón con la punta de flecha hacia la derecha: -->

Caption: &Copiar texto

Name: mnuCopiar

Pinche otra vez con el ratón sobre &Salir y pulsamos el botón Insertar.

Pulse ahora sobre el botón con la punta de flecha hacia la derecha: -->

Caption: &Pegar texto

Name: mnuPegar

Pinche otra vez con el ratón sobre &Salir y pulsamos el botón Insertar.

Pulse ahora sobre el botón con la punta de flecha hacia la derecha: -->

Caption: C&ortar texto

Name: mnuCortar

Añada el siguiente código en General declaraciones:

Private Declare Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Long) As Long

Y las siguientes líneas:

Private Sub mnuSeltodo_Click()

Text1.SetFocus

Text1.SelStart = 0

Text1.SelLength = Len(Text1.Text)

End Sub

Private Sub mnuCopiar_Click()

Clipboard.Clear

Clipboard.SetText Text1.SelText

Text1.SetFocus

End Sub

Private Sub mnuPegar_Click()

Text1.SelText = Clipboard.GetText()

Text1.SetFocus

End Sub

Private Sub mnuCortar_Click()

Clipboard.SetText Text1.SelText

Text1.SelText = ""

Text1.SetFocus

End Sub

Private Sub mnuUndo_Click()

UndoResultado = SendMessage(Text1.hwnd, &HC7, 0&, 0&)

If UndoResultado = -1 Then

Beep

MsgBox "Error al intentar recuperar.", 20, "Undo"

End If

End Sub

Private Sub Form_Resize()

Text1.Left = 0

Text1.Top = 0

Text1.Height = Form1.ScaleHeight - StatusBar1.Height

Text1.Width = Form1.ScaleWidth

End Sub

Pulse F5. Que duda cabe que este no es el mejor aspecto o el aspecto más profesional de este ejemplo, pero eso ya lo dejo a gusto del programador que es el encargado de distribuir los menús como él quiera.

El resultado parcial de la aplicación es:

Antes me gustaría hacer alusión a los menús subdivididos, es decir, aquellos menús que están separados mediante una pequeña barra horizontal que separa por ejemplo dentro de un menú llamado Fichero a unos submenús llamados Abrir, Guardar, y dividido mediante una pequeña barra horizontal el submenú Salir.

El aspecto debería ser algo así:

La barra separadora se obtiene, de la forma:

Dentro del submenú, escribimos:

Caption: -

Name: A1 (por ejemplo)

Es bastante recomendable que los nombres a los separadores sean códigos o palabras poco utilizados para no caer en la repetición de los nombres de las variables.

Por ahora, nuestra aplicación, posee las características más usuales de un editor de texto de carácter lo más parecido a la profesionalidad de una aplicación.

Todo programa puede ser mejorado, ampliado, modificado, ... pero no está mal para empezar.

En Windows 95 y Windows NT, si pulsamos con el botón derecho sobre una caja de texto, aparece un menú de selección como este:

Puede ser que no deseemos que aparezca este menú, y sí que aparezca el menú Editor que nosotros mismos hemos programado. Para que esto suceda, deberemos escribir lo siguiente en el evento correcto:

(En este caso, haremos uso de un truco de programación para que Windows no nos muestre la pantalla antes mencionada. Con este truco engañaremos a Windows para ocultar esta pantalla y mostrar la que nosotros queremos).

Private Sub Text1_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single)

' Button=1 --> botón izquierdo

' Button=4 --> botón central

' Button=2 --> botón derecho

If Button = 2 Then

Text1.Enabled = False

Text1.Enabled = True

PopupMenu mnuEditor

Text1.SetFocus

End If

End Sub

Cabe destacar, que en el truco de programación, antecede la línea:

PopupMenu mnuEditor

a la línea:

Text1.Enabled = True

Con esto conseguimos que el texto aparezca en background (color gris) mientras que aparece el menú de selección nuestro.

Es decir, con un ejemplo:

Este es el resultado final de nuestra aplicación mostrando el menú que nosotros queremos.

Este tema más o menos ha concluido.

En los siguientes mejoraremos nuestro editor realizando un editor de texto mucho más profesional.

Poco a poco veremos los cambios insertando más controles que nos permitan un mejor aspecto a nuestra aplicación.

En resumen podríamos decir que hemos visto como insertar menús, separadores dentro de un submenú, ajuste de un control (TextBox y StatusBar) al formulario cuando redimensionamos la ventana de nuestra aplicación.

Hemos aprendido a mostrar menús PopUps dentro de un control (hemos visto como ejemplo dentro de un TextBox). Veremos más adelante como mostrar menús inexistentes u ocultos.

Hemos visto funciones básicas del control StatusBar, y funciones básicas de un editor de texto simple, así como el uso de una función API de Windows para deshacer los cambios realizados sobre el control TextBox.

Lo que más utilidad o funcionalidad que tiene cualquier programa es la posibilidad de almacenar y recuperar información almacenada en ficheros.

Visual Basic soporta varios tipos de ficheros que veremos a continuación.

En Visual Basic podemos abrir ficheros directamente sin utilizar ningún control ActiveX, ni Dll, pero podemos abrir o guardar un fichero utilizando el control CommonDialog de Visual Basic o el fichero, librería CommDlg.Dll.

Las clases de ficheros en Visual Basic son:

Estos tipos de archivos son los más sencillos de procesar. Ejemplo de este tipo de archivos con los textos normales, en los que se graba y abre la información línea a línea.

Los archivos secuenciales o mejor dicho las líneas de información almacenadas en los ficheros secuenciales están separadas por el campo VbCrLF, o mejor dicho, por Cr y Lf (código Ascii 13 y Ascii 10).

Por ejemplo, el texto:

quedaría almacenado en un fichero de esta forma:

Estos ficheros son fáciles de abrir, cerrar y procesar.

De momento no vamos a hacer caso en la utilización de controles ActiveX o llamadas API a la Dll.

Crearemos el esqueleto para abrir y guardar ficheros secuenciales.

La sentencia para abrir un fichero secuencial es:

La sentencia para escribir un fichero secuencial es:

Donde archivo es el nombre del archivo a abrir o guardar y númeroDeCanal es el canal disponible para operar sobre el canal de I/O (Input/Output [Entrada/Salida]).

El númeroDeCanal es un número entre 1 y 255.

Muchos programadores utilizan un único número de canal, es decir, operan sus operaciones con un canal fijo. Este es un error muy grave de programación, porque podemos estar utilizando un canal que está siendo usado por otro programa. Es necesario pedirle al sistema operativo el canal libre para operar. Esto lo veremos más adelante.

Volviendo al tema de los ficheros secuenciales, es necesario conocer si un fichero sobre el que deseamos realizar una operación de lectura, existe. Si no existe Visual Basic producirá un error.

Pero cuidado con utilizar la instrucción Output, porque el fichero en caso de existir será reemplazado o sobreescrito totalmente perdiendo la anterior información en caso de existir.

Es importante recordar que toda operación de apertura, requiere el proceso inverso, es decir, la operación de cierre. En caso de no hacerlo, el sistema operativo realizará dicha operación al finalizar nuestra aplicación incidiendo negativamente en el rendimiento de nuestra aplicación.

Para cerrar un canal abierto sobre el que estamos operando debemos escribir:

Vamos a ver dos ejemplos significativos:

Apertura de un fichero para leer su información:

Dim Texto as String

numeroDeCanal = FreeFile

Open "C:\autoexec.bat" For Input As #numeroDeCanal

Do While Not EOF(numeroDeCanal)

Line Input #numeroDeCanal, Texto

Text1.Text= Text1.Text & Texto & vbCrLf

Loop

Close #numeroDeCanal

Sin embargo, podemos utilizar la apertura de archivos de otra manera, suponiendo que el tamaño del archivo es tan amplio como el lugar donde vamos a mostrarlo, como puede ser un TextBox o una caja de texto enriquecido.

Apertura de un fichero para leer su información "de un tirón":

numeroDeCanal = FreeFile

Open "C:\autoexec.bat" For Input As #numeroDeCanal

Text1.Text= Input$(LOF(numeroDeCanal), #numeroDeCanal)

Close #numeroDeCanal

Apertura de un fichero para grabar su información:

Dim Texto as String

numeroDeCanal = FreeFile

Open "C:\autoexec.bak" For Output As #numeroDeCanal

Print #numeroDeCanal, Text1.Text

Close #numeroDeCanal

Este tipo de archivos son muy útiles para los ficheros log por citar un ejemplo.

LOF significa longitud del archivo (Long of file).

EOF es otra de las instrucciones con la que nos encontraremos que significa final de fichero (End of file).

La función LOF toma como parámetro el número de canal utilizado y devuelve el número de bytes que contiene.

La sentencia de un fichero de acceso aleatorio es:

Se utiliza según sea para leer o para escribir, la instrucción Get y Put.

Para cerrar un fichero de acceso aleatorio utilizaremos la instrucción Close.

Es necesario utilizar estructura de datos para el uso de este tipo de archivos.

Por ejemplo, para tener un archivo que almacene el nombre, apellido1, apellido2 y edad, podríamos hacer uso de la siguiente estructura:

Type Persona

Nombre As String * 14

Apellido1 As String * 28

Apellido2 As String * 28

Edad As Integer

End Type

Un registro Persona tendrá una longitud de 72 bytes (14 + 28 +28 +2).

Este tipo de ficheros fueron los antecesores de las bases de datos, y pueden ser usados si desea almacenar una cantidad de datos referente a algo en concreto siempre y cuando la información contenida en el archivo no sea muy grande y no sea muy importante, ya que con un simple editor de textos, podemos leer fácilmente su información.

Sigamos adelante.

Para leer y escribir datos en un archivo de acceso aleatorio, haremos uso de las instrucciones Get y Put que ya hemos citado con anterioridad.

Ejemplo de lectura es:

Dim Humano As Persona

Dim Registros As Integer

Dim Lon As Integer

numeroDeCanal = FreeFile

Open "d:\testio.txt" For Random As #numeroDeCanal

Lon = 72

Registros = LOF(numeroDeCanal) / Lon

For i = 1 To Registros

Get #numeroDeCanal, i, Humano

Text1.Text = Humano.Nombre

Text2.Text = Humano.Apellido1

Text3.Text = Humano.Apellido2

Text4.Text = Humano.Edad

Next i

Si analizamos este código fuente, veremos que es muy sencillo.

Registros va a almacenar el número de registros existentes en el fichero.

Es necesario comentar, que si por ejemplo, uno de nuestros registros Nombre posee más de 14 caracteres, estos se truncarán. De la misma manera, si posee menos de 14 caracteres, el contenido que sobra, es rellenado con caracteres en blanco.

Por ese motivo, a la hora de recuperar información de un fichero de acceso aleatorio, debemos (según lo que deseemos claro está), utilizar la instrucción RTrim$(Texto), la cual eliminará todo el texto de caracteres en blanco que haya a la derecha de la cadena Texto.

Por ejemplo:

Dim Texto As String

Texto = "Esto es una prueba "

Text1.Text = Texto

Text2.Text = RTrim$(Texto)

El primer campo insertará "Esto es una prueba ", mientras que en el segundo campo se insertará el texto "Esto es una prueba".

RTrim$ elimina los caracteres en blanco a la izquierda a partir de una cadena de texto cualquiera.

LTrim$ elimina los caracteres en blanco a la derecha a partir de una cadena de texto cualquiera.

Ejemplo de escritura es:

Dim Humano As Persona

Dim Registros As Integer

Dim Lon As Integer

numeroDeCanal = FreeFile

Humano.Nombre = Text1.Text

Humano.Apellido1 = Text2.Text

Humano.Apellido2 = Text3.Text

Humano.Edad = Text4.Text

Lon = 72

Open "d:\testio.txt" For Random As #numeroDeCanal

Registros = LOF(numeroDeCanal) / Lon

Registros = Registros + 1

Put #numeroDeCanal, Registros, Humano

Esto es en consecuencia el uso y manejo de los archivos de acceso aleatorio. Ni que decir tiene que puede complicarse tanto como queramos. Incluso para crear copias de seguridad en caso de fallo a la hora de actualizar o modificar datos, ... etc.

Los archivos binarios, suelen ser archivos que no son de texto, pero que tampoco están estructurados en bloques de longitudes fijas.

Todos estos archivos, no poseen una estructura de registros fija.

Las imágenes son ficheros binarios o los archivos comprimidos más usuales.

La apertura de una archivo binario es como sigue:

Al abrir un archivo binario, no le estamos indicando si deseamos realizar operaciones de entrada o de salida. Es decir, actúa de forma idéntica al archivo de acceso aleatorio.

La diferencia está en que si no existe un fichero, este se creará automáticamente sin generarnos ningún error.

Para leer o escribir, se utiliza la instrucción Get y Put.

Bloque es el número de byte a partir del cual deseamos leer o escribir.

Para realizar la lectura de un archivo, podemos hacer uso de la sentencia InputB que nos permitirá leer desde la posición actual un número de bytes determinado que debemos especificar.

Con los archivos binarios leemos toda la información sin diferenciar espacios, saltos de carro o intros. Esto nos permite actuar sobre toda la información de un fichero.

Un ejemplo de escritura y lectura de un fichero binario es:

Private Type Inf

Text As String

End Type

Dim numeroDeCanal As Integer

Dim Infor As Inf

Infor.Text = Text1.Text

numeroDeCanal = FreeFile

Open "d:\TestIO.txt" For Binary As #numeroDeCanal

Put #numeroDeCanal, , Infor

Close (numeroDeCanal)

Para leer el fichero, deberíamos escribir:

Dim numeroDeCanal As Integer

Dim Cadena As String

Dim Infor As Inf

numeroDeCanal = FreeFile

Open "d:\TestIO.txt" For Binary As #numeroDeCanal

Get #numeroDeCanal, , Infor

Close (numeroDeCanal)

Text1.Text = Infor.Text

La información de un fichero binario puede ser combinada mediante texto (una cabecera informativa como la que aparecen en los distintos formatos gráficos de imágenes por ejemplo), seguido de datos (los pixels de la imagen siguiendo con el mismo ejemplo), seguido de otro texto por ejemplo.

Los ficheros binarios permiten gran versatilidad.

Es posible obtener información adicional de cualquier fichero como sus propiedades, tamaño, fecha y hora de la última modificación, además lógicamente del camino o Path.

Dim Camino As String

Dim Atributo As Integer

Camino = "D:\testio.txt"

Atributo = GetAttr(Camino)

If Atributo & vbReadOnly Then Text1.Text = "Sólo lectura"

If Atributo & vbHidden Then Text1.Text = "Oculto"

If Atributo & vbSystem Then Text1.Text = "De sistema"

If Atributo & vbArchive Then Text1.Text = "Modificado"

Este ejemplo muestra el atributo de un archivo determinado.

Dim Camino As String

Camino = "D:\testio.txt"

Text1.Text = FileDateTime(Camino)

Este ejemplo muestra la fecha y hora del fichero.

Dim Camino As String

Camino = "D:\testio.txt"

Text1.Text = FileLen(Camino) & " bytes"

Ejemplo que muestra el tamaño de un archivo.

¿Cuántas veces hemos visto aplicaciones de funcionalidad mínima pero con un perfecto diseño GUI (Interfaz Gráfica de Usuario)?.

Las nuevas aplicaciones de Microsoft poseen nuevas características GUI que las dan un aspecto visual muy agradable.

Es posible que Microsoft incluya dentro de poco algún control que permita hacer barras de herramientas y menús tan vistosos como los de la saga 97 y 98, pero hasta que Microsoft quiera no nos vamos a quedar con los brazos cruzados, por eso usaremos un control Ocx gratuito que permite justamente esto.

El control que usaremos para desarrollar los ToolBar con aspecto 97 será el llamado FlatBar32.ocx.

Este control lo podeis encontrar en mis páginas web.

Gracias a este control, nos ahorraremos mucho código y crearemos aplicaciones con gran aspecto profesional (desgraciadamente para la programación, prima lo bonito por encima de otros aspectos como la seguridad, rapidez y fiabilidad).

Vamos a explicar algunos datos acerca de este fabuloso control antes de continuar con la programación en sí.

Este control lo añadiremos (después de instalarlo) a nuestra caja de herramientas y lo insertaremos a nuestro formulario.

Una vez insertado tiene este aspecto:

Con el control FlatBar, recibimos una colección de bitmaps de 16x16 pixels muy habituales y usados frecuentemente. Sin embargo, es posible utilizar nuestros propios bitmaps con el fin de personalizar nuestra barra de la mayor forma posible.

Si pulsamos el botón derecho del ratón sobre nuestro control, nos mostrará un menú desplegable del que debemos seleccionar Properties.

En esta nueva ventana encontraremos las diferentes propiedades de los botones y barra que "sostiene" a los botones. Nos permite añadir ToolTips a cada botón, hacerlo Enabled (Activado o Desactivado), ... etc.

El uso de FlatBar32 no tiene más misterios. Es sencillo de usar aunque posee un bug que he comentado con el autor del control, y que pese a que él lo admite, no creo que de momento tenga ganas de modificar el código, y no es para menos, pues el control es Freeware.

Este fallo consiste en que cada vez que modifiquemos una propiedad de un botón a insertar en nuestra ToolBar, debemos pulsar el botón Aplicar para que los cambios tengan validez. Es una tarea un poco aburrida si encima contamos con un número elevado de botones.

Bueno, veamos el aspecto la ventana de propiedades del control FlatBar32.ocx.

Es esta:

Como vemos, Flatbar posee una línea de botones comúnmente usados en programas de tipo comercial.

Podemos incluir nuestros propios bitmaps.

Antes hacía mención a los bitmaps de 16x16 pixels, pero FlatBar32 permite además incorporar botones de 32x32 pixels.

Lo único que debemos hacer es modificar el valor de ToolBarSize a 32 (sólo pueden usarse estos dos valores, 16 ó 32) y seleccionar un picture que tenga 32 pixels de alto x un múltiplo de 32 como ancho.

La propiedad MaskColor nos permite seleccionar un color transparente.

Yo personalmente prefiero hacerme mi barra de pictures con el fondo en color gris y quitarme de problemas. No conozco cual es el objetivo principal de Ramon Guerrero autor de este control, pero si quereis quitaros de problemas si usais los pictures por defecto, podeis dejar el color por defecto como MaskColor.

Como la mejor forma de entender un control, Dll o ejemplo es practicando, vamos a hacer una breve pantalla para ver los resultados.

Insertemos el control en nuestro formulario y pulsemos el botón derecho sobre el control.

Ahora elegimos las propiedades (Properties) del menú desplegable.

El botón Nuevo está por defecto, lo cual nos beneficiará el comienzo.

Botón 0 (Nuevo por defecto):

Pulsar el botón Aplicar, y luego el botón Insert Button.

Botón 1

ToolTips: Abrir

Image Number: 1

Pulsar el botón Aplicar, y luego el botón Insert Button.

Botón 2

ToolTips: Guardar

Image Number: 2

Pulsar el botón Aplicar, y luego el botón Insert Button.

Botón 3

Image Number: 43

Pulsar el botón Aplicar, y luego el botón Insert Button.

Botón 4

ToolTips: Ayuda

Image Number: 7

Pulsar el botón Aplicar.

Pulsar el botón Aceptar.

De la ventana de propiedades de FlatBar, seleccionamos Align y seleccionamos AlignTop - 1.

Si pulsamos F5, no veremos nada. Es decir, la ToolBar no "arranca".

Esto es debido a que debemos inicializar la ToolBar. Para ello es preciso escribir el siguiente código en el evento Form_Load:

FlatBar1.Runtime

End Sub

Debemos tener una pantalla similar a esta:

FlatBar1.Runtime

FlatBar1.AddBandsToRebar FlatBar1.GetToolbarHwnd, "Intersoft", 0, 10

End Sub

Con estas líneas forzamos la creación de las barras alrededor del ToolBar al estilo de las aplicaciones de Office 97 y 98.

El aspecto visual de esto que comentamos es el siguiente:

Podemos evitar el texto donde pone Intersoft para dejarlo en blanco o personalizando el texto.

Ahora bien, es posible que modifiquemos el tamaño de la ventana haciéndola más o menos grande, maximizándola, minimizándola, ... etc.

Para evitarnos problemas, es necesario escribir el siguiente código:

FlatBar1.ResizeRebar Me

End Sub

Lo mismo ocurre al cerrar nuestra aplicación.

Es posible que existan problemas, por eso es bueno destruir la ToolBar creada. Esto lo conseguimos con el siguiente código:

FlatBar1.Destroy

End Sub

Sin embargo, podemos saber cual es el botón seleccionado dentro de la ToolBar.

Para ello, es suficiente escribir este código:

End Select

End Sub

Como podemos observar, el aspecto visual de nuestra aplicación ha cambiado radicalmente y con tan sólo unas poquísimas líneas de código.

Esto es lo que hace realmente atractivo a este control.

Sin embargo, es posible añadir estilos CoolBar. Como los que aparece en el navegador de Internet Explorer.

Esto se consigue introduciendo un bitmap cualquiera a nuestra ventana e insertando en él el bitmap CoolBar correspondiente.

Imaginemos el CoolBar del estilo:

Lo insertaremos en nuestro proyecto en el formulario primero como un Picture, que será el Picture1 por defecto.

Ahora debemos escribir el siguiente código:

FlatBar1.Runtime

FlatBar1.SetRebarPicture Picture1

FlatBar1.AddBandsToRebar FlatBar1.GetToolbarHwnd, "Intersoft", 0, 10

End Sub

La segunda línea de código es la línea que hemos insertado.

Esta línea nos asocia el Picture1 como CoolBar. El Picture1 debe tener la propiedad Visible a False.

El aspecto exterior de nuestra aplicación es este:

Podemos cambiar la propiedad MaskColor a otra que nos satisfaga más.

Como vemos, el aspecto de nuestra aplicación puede tomar el parecido exterior al de las aplicaciones y programas nuevos de Microsoft.

Sin embargo, es posible añadir más utilidades a nuestro mini-proyecto.

Por eso, vamos a crear una segunda FlatBar que posea tres botones, dos de los cuales actúen como los botones de Alineación de texto en Word, es decir, que al pulsar uno se quede seleccionado y los demás pierdan la selección. Para que veamos que se puede combinar botones de selección con otros de no-selección, vamos a hacer los dos primeros botones apropiados a este tipo de selección y el tercer botón como un botón normal.

Añadimos una nueva FlatBar.

Podemos incluso borrar el Picture1 de nuestro proyecto pues no lo vamos a usar (se podría pero vamos a dejar el FlatBar por defecto).

Debemos escribir el siguiente código:

FlatBar1.Runtime

FlatBar1.CreateRebar Me, True

FlatBar1.AddBandsToRebar FlatBar1.GetToolbarHwnd, "Intersoft", 0, 10

FlatBar2.Runtime

FlatBar2.CreateRebar Me, True

FlatBar1.AddBandsToRebar FlatBar2.GetToolbarHwnd, "", 0, 10

FlatBar2.PressButton 1

End Sub

Seleccionamos la propiedad Align de esta segunda FlatBar a Align Top - 1.

Ahora debemos seleccionar los botones apropiados a nuestra segunda FlatBar.

Pulsamos con el botón derecho sobre la FlatBar2 y seleccionamos Properties.

Index: 0

Image Number: 14

Check Group: Checked

Pulsamos el botón Aplicar y luego el botón Insert Button.

Index: 1

Image Number: 15

Check Group: Checked

Pulsamos el botón Aplicar y luego el botón Insert Button.

Index: 2

Image Number: 6

Caption: Imprimir

Pulsa el botón Aplicar y Aceptar.

No debemos olvidar añadir parte del código necesario para que nuestra aplicación funcione correctamente:

FlatBar1.ResizeRebar Me

FlatBar2.ResizeRebar Me

End Sub

FlatBar1.Destroy

FlatBar2.Destroy

End Sub

Si pulsamos la tecla F5, observaremos que inicialmente el botón segundo está chequeado, es decir, presionado. Esto lo hemos logrado en la línea de código de Form_Load:

FlatBar2.PressButton 1

Si omitimos esta línea de código, ninguna opción aparecerá chequeada hasta que pulsemos sobre alguna de ellas.

El aspecto visual de esta parte es como sigue:

De todas formas, FlatBar permite ejecutar nuestro navegador de Internet por defecto para ejecutar un dirección Web.

Para realizar esto, debemos lanzar la petición con la instrucción RunFile.

Un ejemplo:

Haga click con el botón derecho del ratón sobre la FlatBar y seleccione Properties.

Sitúe el Index en el valor 2 y pulse el botón Insert Button.

Index: 3

Image Number: 31

ToolTips: Internet

Pulsa el botón Aplicar y Aceptar.

Inserte el siguiente código:

End Sub

Este código permite ejecutar el navegador, pero lo mismo deseamos enviar un e-mail a alguien, por lo tanto, podemos hacer uso de esta llamada:

Para hacer esto último, vamos a insertar otro botón.

Index: 4

Image Number: 28

ToolTips: e-mail

Pulsamos el botón Aplicar y Aceptar.

Escribimos el código fuente necesario para realizar esta función:

End Sub

Este nuevo código ejecutará el correo electrónico.

Nota: He detectado sin embargo que hay un problema a la hora de ejecutar el navegador de Internet si no estamos conectados a Internet y no lo tenemos abierto, y es que el programa o más concretamente FlatBar produce un error que hace concluir nuestra aplicación. No sé si este error sólo se me produce a mí, asi que dejo aquí el aviso. Revisadlo.

El aspecto de nuestra ventana por ahora es este:

Referente al error con la conexión de Internet y e-mail, es muy muy probable que este error sea únicamente producido en mi Computador, pues he probado con otras técnicas y este error vuelve a producirse.

La otra técnica que aquí comento, es una técnica adicional no necesaria en principio con FlatBar, pero que puede sernos útil para otros programas.

Debemos incorporar una llamada API que puede ser insertada en nuestro código dentro del formulario 1. El código es:

Después, debemos insertar este código:

End Sub

Este código ejecutará el navegador de Internet y programa de correo por defecto.

Hasta aquí hemos visto las partes más importantes de este control llamado FlatBar32.Ocx.

El control posee además un programa que nos facilitará la creación de botones para insertarlos en el control y personalizarlos de acuerdo a nuestras intenciones.

Volveré a recordar, que cuando deseemos modificar alguna propiedad, botón, etc del control, debemos pulsar el botón Aplicar antes de insertar otra propiedad o modificarla siempre y cuando pertenezca a otro botón distinto. Una vez que pulsamos el botón Aplicar, podemos pulsar el botón Aceptar para salir de la ventana de propiedades. De otra manera, los cambios efectuados no tomarán valor.

Este pequeño bug es el único "pero" que posee el control. El propio autor me ha confirmado este bug. Que se le va hacer. Además es gratis.

¿Quieres además "rizar el rizo" y realizar menús como los de las aplicaciones 97 y 98?.

Pues es fácil con otro control del mismo autor.

Este control se llama IconMenu32.Ocx . Este control sólo puede ser utilizado en Visual Basic 5.0 y posteriores.

Puede incluso añadir bitmaps en los menús de las ventanas MDI.

En fín, que poco a poco os iré metiendo en este tema.

De momento disfrutad con esto que no es poco.

Repaso : Hemos visto en este capítulo como mejorar nuestras aplicaciones con el uso del control FlatBar32.Ocx gratuito.

Por norma general, la mayoría de los libros de programación, comienzan hablando después de una breve iniciación o introducción, de las variables en Visual Basic.

Yo prefiero hablar de esto una vez avanzado un poco en el lenguaje como ya hemos hecho hasta aquí. El objetivo es claro. Al principio se dan las diferentes variables que se pueden usar en Visual Basic, y luego se introduce a la programación propiamente dicha, con lo que debemos echar una mirada hacia atrás para recordar las variables.

Si habeis seguido el curso, tendreis unas nociones mínimas pero suficientes de programar algo en Visual Basic, pero os falta conocer el tipo de variables a usar.

Esto es lo que veremos a continuación.

En Visual Basic, podemos declarar las variables a usar, antes de escribir el código de nuestros programas, o justo antes de usarla en una determinada instrucción.

Por ejemplo. Inserte un Label y un CommandButton. Escriba lo siguiente:

Sum = 3 + 4

Num = 32 / Sum

Label1 = Num

End Sub

Podría escribirse también:

Sum = 3 + 4

Num = 32 / Sum

Label1 = Num

End Sub

Sin duda alguna, la primera forma es más ordenada que la segunda y más fácil de mantener, pero cualquiera de las dos es factible.

Si omitimos el tipo de una variable, esta adquiere el valor de Variant.

Variant puede tomar cualquier valor, y por defecto, suele tomar más tamaño en memoria que el valor que quisiéramos usar, y además, puede no darnos el resultado deseado por ser demasiado corta.

Por defecto suele ocupar 4 Bytes.

La forma de llamar a una variable desde Visual Basic y dentro de un evento es de la forma:

siendo Tipo alguno de los tipos de variables permitidos en Visual Basic.

Los distintos tipos de variables utilizados en Visual Basic son:

Integer Valor Entero 2 Bytes

Long Valor Entero Largo 4 Bytes

Single Valor Real 4 Bytes

Double Valor Real Doble 8 Bytes

String Carácter (texto) 1 Byte por carácter

Byte Byte 1 Byte

Boolean Valor Booleano (1/0) 2 Bytes

Currency Monedas y Punto Fijo 8 Bytes

Date Fecha 8 Bytes

Object Referencias a objetos 4 Bytes

Variant Cualquiera 16-22 Bytes

Ahora veremos los valores que comprenden algunos de los tipos que hemos visto:

Byte 0 a 255

Boolean True o False (1 ó 0)

Integer -32768 a 32767

Long -2147483648 a 2147483647

Single -3,402823E38 a -1,401298E-45 (valores negativos)

-1,401298E-45 a 3,402823E38 (valores positivos)

Double -1,79769313486232E308 a -4,94065645841247E-324 (valores negativos)

4,94065645841247E-324 a 1,79769313486232E308 (valores positivos)

Currency -922337203685477,5808 a 922337203685477,5807

Decimal +/- 79228162514264337593543950335 (sin punto decimal)

+/- 7,9228162514264337593543950335 (28 posiciones a la derecha del signo decimal)

+/-0,0000000000000000000000000001 (es el número más pequeño posible)

Date 01/01/100 a 31/12/9999

Object [Objeto]

String Desde 1 a 65000

Variant Números: 16 Bytes hasta el intervalo Double

Caracteres: 22 Bytes + longitud ed la cadena

Estos que hemos visto, son los tipos base de uso en Visual Basic, pero podemos asignar un tipo de variable de dos formas.

Una de ellas ya la hemos visto:

pero hay otra forma que sólo es utilizable para 6 tipos. Esta forma de identificar a una variable nos permite ahorrar tiempo a la hora de escribir código, además de tratar de hacer compatible las primeras formas de asignar variables en Visual Basic (desde Visual Basic 1.0).

Estas formas son extensibles para las variables tipo Integer, Long, Single, Double, String y Currency.

Integer %

Long &

Single !

Double #

String $

Currency @

De esta forma, podemos escribir el siguiente código:

Sum% = 3 + 4

Num# = 32 / Sum%

Label1 = Num#

End Sub

Yo personalmente sugiero utilizar poco este tipo de instrucciones siempre y cuando, el número de variables tipo a utilizar sea grande, pues podemos llegar a hacernos un verdadero lío.

En este ejemplo, puede utilizarse, pero es preciso tener un ligero conocimiento de este tipo de variables para no confundir una variable de tipo Long por otra de tipo Integer por ejemplo.

Otro tipo de variables que se usan con frecuencia, son las constantes, las cuales toman un valor fijo durante la ejecución de un evento, formulario y/o programa. Este tipo de valor se define y no puede ser modificado a lo largo de nuestro programa. Es un valor de lectura, no puede ser sobreescrito.

La forma normal de escribir una constante es:

constante puede ser una cadena carácter, números, ... etc.

Podemos sin embargo, hacer una contante accesible en un formulario.

Esto se hace en el Objeto General del Procedimiento Declaraciones dentro de un formulario de esta manera:

ó

Cada vez que llamemos a la variable Pepe desde cualquier parte del formulario, obtendremos el valor 2.

Si hacemos una variable constante dentro de un evento, esta sólo tendrá lugar en el transcurso del evento.

Es decir, que podemos utilizar una variable con el mismo nombre dentro de otro evento a la cual no afectaría para nada el valor de la constante dado en otro procedimiento.

Un ejemplo para entenderlo mejor:

Label1 = Pepe

End Sub

Pepe = 5

Label1 = Pepe

End Sub

Aquí, el valor Pepe es una constante Integer (la hemos forzado así al darle el valor 3) dentro del evento Command1_Click, pero en el evento Form_Click, Pepe no es una constante, con lo que el valor de Pepe en este caso adquiriría el tipo Variant como ya hemos visto y puede tener cualquier valor, que inicialmente sería un blanco.

Las constantes nos dan la fiabilidad y seguridad de que el valor a utilizar no va a modificarse dentro o fuera de un procedimiento o evento (si nuestra constante es accesible en un formulario o un evento).

Sin duda, que las constantes son muy útiles sobre todo en cálculos numéricos. Por ejemplo el número Pi.

Cabe destacar que el lograr que unas variables sean accesibles dentro o no de un formulario posee un nombre específico en Visual Basic. Las variables que poseen estas cualidades de ser accesibles, adquieren el nombre de ámbito.

Ahora bien, puede ser que queramos realizar una constante accesible durante todo nuestro proyecto, con lo que deberemos insertar un módulo y hacer una variable de uso Público. El ámbito de esta variable sería de ámbito público, es decir, accesible a lo largo de todo el proyecto y desde cualquier parte del mismo.

Con un ejemplo lo entenderemos perfectamente.

Insertaremos un formulario más del que tiene por defecto un proyecto Visual Basic y un módulo. Es decir, nuestro proyecto tendrá dos formularios y un módulo.

En cada formulario insertaremos un Label y un Command Button.

El código a insertar es este:

Módulo:

Formulario 1:

Label1 = Pepe

Form2.Show 1

End Sub

Formulario 2:

Label1 = Pepe

End Sub

La variable Pepe es accesible a lo largo de todo el proyecto (los dos formularios) con el valor constante público, dado en el módulo inicialmente como hemos visto.

Todas las variables que se declaran por primera vez, adquieren el valor 0 para los datos numéricos y de una cadena vacía "" para las variables carácter. Para las variables Variant es un blanco ó "", es decir, lo toma como carácter incialmente.

Otro tipo de variables son las denominadas Static.

Este tipo de variables mantiene su valor mientras el código se está ejecutando.

La forma de referenciarlo es:

Otro tipo de variables son las variables definidas por el usuario.

Son las variables Type ... End Type.

Un ejemplo:

End Type

Este tipo definido por el usuario, puede ser utilizado en ámbitos globales o parciales de un evento, formulario o proyecto.

Esta forma de hacer un tipo definido por el usuario de ámbito público, se hace colocando delante de Type la palabra Public. Para usarlo en el mismo ámbito del formulario o ámbito privado, lo debemos hacer con la palabra Private.

Esto es:

...

End Type

ó

...

End Type

Este tipo de variables tienen la posibilidad de ser personalizadas por el usuario, lo cual nos permite gran versatilidad en nuestros desarrollos.

Este tipo de variables permiten tener un valor accesible a lo largo de todo el proyecto, pudiéndose modificar si no se utiliza como constante.

El tipo de variables Global es el utilizado en versiones 3.0 y anteriores de Visual Basic.

Con la versión de Visual Basic 4.0, se usa el tipo de valores Public aunque por compatibilidades, es posible usar el tipo Global. Aunque se pueda utilizar Global, es aconsejable empezar a acostumbrarse a utilizar Public.

Es un tipo de declaración muy útil.

Para poder asignar una variable de tipo Global o Public a nuestro proyecto, debemos hacerlo en un módulo.

Con un ejemplo lo entenderemos mejor.

Aprovechando el ejemplo anterior de los dos formularios, modificaremos el código de esta manera:

Módulo:

Formulario 1:

Pepe = 7

Label1 = Pepe

Pepe = Pepe * 2

Form2.Show 1

End Sub

Formulario 2:

Label1 = Pepe

End Sub

Este ejemplo muestra como hacer accesible un valor a lo largo de nuestro proyecto desde cualquier procedimiento, llamada o evento.

Para hacer una variable constante global, lo haremos dentro de un módulo de esta forma:

Ó

Las matrices son conocidas también como arrays.

El array más simple es el de 1 dimensión.

Las dimensiones de un array son las filas, pudiendo tener en principio tantas columnas como elementos diferentes tengan el array.

Un array unidimensional (de una única dimensión, una única fila), no tiene sentido si no tiene al menos dos elementos. Un array de un único elemento debemos asignarlo como variable y no complicarnos su programación utilizando para almacenar su valor un array.

Hay dentro de los arrays, dos clases o tipos de arrays. Los arrays estáticos y los arrays dinámicos.

Los arrays estáticos son aquellos arrays cuyo número de elementos es fijo y determinado.

Los arrays dinámicos son aquellos arrays cuyo número de elementos pueden modificarse.

Es necesario tener en cuenta unos aspectos sobre los arrays que nos vendrán muy bien.

Esta declaración no contendrá 4 posibles valores, sino 5.

Los valores en Visual Basic comienzan introduciéndose en el índice 0 seguido del siguiente índice.

Para hacer referencia a un dato o valor dentro de un array, lo hacemos mediante índices.

Ahora bien, quizás tengamos la necesidad de forzar a un array que comience por 1 y acabe en 5 por ejemplo. Entonces, la creación del array anterior sería:

Veamos esto con dos ejemplos, donde utilizaremos un array de 5 elementos. En el segundo ejemplo forzaremos que el array tenga 5 elementos empezando desde el índice 1 hasta el 5 mientras que en el primer ejemplo, empezará por el índice 0 hasta el 4.

En un nuevo proyecto, insertamos un Command Button y un TextBox con las propiedades Text a "", Multiline a True y ScrollBars a Vertical.

Insertaremos este código:

[(General) - (Declaraciones)]

Text1 = Text1 & MiArray(I) & vbCrLf

End Sub

J = 0

MiArray(J) = I

J = J + 1

End Sub

Insertaremos este código:

[(General) - (Declaraciones)]

Text1 = Text1 & MiArray(I) & vbCrLf

End Sub

J = 1

MiArray(J) = I

J = J + 1

End Sub

Estos dos ejemplos muestran como manejar dos arrays unidimensionales forzando que uno de ellos comience por el índice 1.

Si deseamos comenzar por ejemplo por el índice 21, lo podemos hacer también, pero no nos tenemos que olvidar que para hacer referencia a sus valores, debemos comenzar por el índice 21 hasta el último índice del array.

Otros arrays son los arrays con varias dimensiones, los cuales son más complejos cuantas más posiciones de memoria puedan almacenar o mejor dicho, cuantos más elementos puedan contener compuestos por filas y columnas.

Un array de dos dimensiones recibe el nombre de array bidimensional, y podemos hacer cada vez más complejo este tipo de arrays (3 dimensiones, ... etc), pero su gestión requiere una gran atención para no cometer errores.

Como en el caso de los arrays unidimensionales, los arrays de más de una dimensión, los podemos forzar a comenzar por un índice.

Para no liarnos, haremos un ejemplo en el que comenzaremos a introducir los datos por el índice 1 y leerlos de igual forma.

Los datos que introduciremos serán 3 filas x 5 columnas, es decir un array formado por 3x5 = 15 elementos que contendrás esta información:

El código para este ejemplo es el siguiente (de la misma forma que el anterior, con los mismos controles, etc):

Text1 = Text1 & MiArray(I, J) & vbCrLf

End Sub

K = 1

MiArray(I, J) = K

K = K + 1

End Sub

Este ejemplo demuestra como escribir información en un array bidimensional y como leer su información. Hasta aquí hemos visto arrays numéricos, pero se pueden introducir array carácter.

Para hacer un array bidimensional carácter, lo podríamos hacer de esta forma:

Pero quizás no deseemos guardar nada más que cadenas de 5 caracteres de longitud, por lo que su correcta forma de asignarlo es:

Otra cualidad de los arrays es el parámetro ReDim.

El parámetro ReDim posee dos usos.

ó

ReDim sólo puede ser utilizada para arrays donde el índice de la matriz no han sido localizadas. Aquí entramos en el terremo de las matrices o arrays dinámicos.

ReDim Preserve tiene la posibilidad de no borrar los valores de los índices almacenados en nuestra matriz, mientras que la palabra única ReDim, destruye toda la información que contenía la matriz.

El número de índices de los arrays dinámicos son modificables en tiempo de ejecución, lo cual nos dá gran versatilidad y libertad de desarrollo en nuestras aplicaciones. El uso de ReDim y ReDim Preserve es de gran importancia en este tipo de matrices.

Si deseamos conocer el índice mayor y menor de un array, lo podemos hacer mediante las funciones internas de Visual Basic LBound (Low = Bajo, nos devuelve el índice más pequeño del Array) y Ubound que al contrario que Lbound nos devuelve el índice más alto.

Hago hincapié en índice, porque no devuelve ningún valor, sino el índice.

Es decir, si tenemos un array de una dimensión con 3 columnas (1 x 3 = 3 elementos) en el que tenemos los valores 5, 78, 6:

Al llamar a las funciones Lbound y Ubound, recibiremos el valor 1 y 3.

Suponiendo que nuestra matriz o array se llame MiArray(1 To 3), de esta forma:

Dim MiArray(1 To 3) As Integer

Suponiendo que en:

MiArray(1) = 5

MiArray(2) = 78

MiArray(3) = 6

Podemos llamar al array con las funciones que hemos visto de esta manera:

Obtendremos por pantalla el mensaje:

1-3

donde 1 es el primer índice y 3 el último.

Puede ser que tengamos un array de varias dimensiones. Si este es nuestro caso y teniendo como ejemplo un array bidimensional en el que tengamos los valores siguientes:

Esta matriz se define como ya hemos visto en otro ejemplo de la forma:

La forma de conocer el tamaño del índice más pequeño del primer subíndice y del índice más alto del segundo subíndice es:

MsgBox LBound(MiArray) & "-" & UBound(MiArray, 2)

Por tanto esta instrucción nos devolverá en pantalla el mensaje:

1-5

Omitir [LBound(MiArray,1)] el 1 es forzar a la función a buscar en el primer subíndice del array.

Con el número 2 de la función UBound nos hemos posicionado en el segundo subíndice de nuestro array bidimensional.

Al igual que declaramos un array de la forma por ejemplo:

Dim MiArray(1 To 3, 1 To 5) As Integer

Podemos declararlo también de la forma:

Dim MiArray%(1 To 3, 1 To 5)

Como ya hemos visto en anteriores apartados.