UNIVERSIDAD CENTRAL DEL ECUADOR FACULTAD DE INGENIERÍA, CIENCIAS FÍSICAS Y MATEMÁTICA INGENIERÍA CIVIL PROGRAMACION 1 NOMBRE: CURSO: PRIMERO FECHA DE ENTREGA: 09/08/2016 PARALELO: SEGUNDO PERIODO LECTIVO: ABRIL 2016 – SEPTIEMBRE SEPTIEMBRE 2016 NOMBRE DEL DOCUMENTO: MANUAL DE USUARIO (2H)
Índice Primer Hemi Bienvenido a Visual Basic ® 6.0 .......................................... ................................................................ ............................................ ...................... 3 Definición de Visual Basic ......................... ................................................ ............................................. ............................................ ......................... ... 4 Descripción del entorno ....................... ............................................. ............................................ ............................................ ............................. ....... 5 Iniciar el IDE de Visual Basic ........................ .............................................. ............................................ ........................................ .................. 6 Elementos del entorno integrado de desarrollo (IDE) ........................................... .................................................... .......... 7 Barra de menús ........................................... ................................................................. ............................................ ............................................ ...................... 8 Menús contextuales .......................................................... ................................................................................ ............................................ ...................... 8 Barras de herramientas ..................................................... ........................................................................... ............................................ ...................... 9 Cuadro de herramientas .............................. .................................................... ............................................ .......................................... .................... 10 Prefijos............................................. .................................................................... ............................................. ............................................ .................................. ............ 10 Ventana Explorador de proyectos.................................. proyectos........................................................ ............................................. ....................... 11 Ventana Propiedades ............................................................ .................................................................................. ...................................... ................ 11 Examinador de objetos ......................................................... ............................................................................... ...................................... ................ 11 Diseñador de formularios ..................................................... ........................................................................... ...................................... ................ 12 Ventana Editor de código ...................................... ............................................................ ............................................ ............................... ......... 12 Ventana Posición del formulario ...................................... ............................................................ .......................................... .................... 13 Ventanas Inmediatas, Locales e Inspección ............................ ................................................... ................................... ............ 13 Guardar un proyecto. ...................................... ............................................................ ............................................ ...................................... ................ 14 Mi primera Aplicación................................ Aplicación...................................................... ............................................. .............................................. ....................... 15 Hola, Visual Basic .......................................... ................................................................ ............................................ .......................................... .................... 15 Crear la interfaz ..................................................... ........................................................................... ............................................. ............................... ........ 15 Cambiar el tamaño, movimiento y bloqueo de controles ....................................... ....................................... 16 Establecer propiedades ......................................................... ............................................................................... ...................................... ................ 18 Establecer la propiedad Icon...................................... Icon............................................................ ............................................. ....................... 19 Escribir código ............................ ................................................... .............................................. .............................................. .................................. ........... 19 Crear procedimientos de evento ....................................... ............................................................. ...................................... ................ 21 Ejecutar la aplicación.............................. aplicación.................................................... ............................................. .............................................. ....................... 22 Formularios, controles y menús................................. menús....................................................... ............................................ ............................... ......... 22 Descripción de las propiedades, métodos y eventos.............................................. eventos....................................................... ......... 23 Diseñar un formulario............................................ ................................................................... ............................................. .................................. ............ 24 Establecer las propiedades de un formulario .......................................... .............................................................. .................... 25 Eventos y métodos de un formulario ........................................... .................................................................. ............................... ........ 26 Hacer clic en los botones para realizar acciones ................................. ....................................................... ........................... ..... 27 Usar los botones de comando ........................................... ................................................................. .......................................... .................... 27 La aplicación Prueba de botones ............................... ..................................................... ............................................. ........................... .... 28 Controles para mostrar e introducir texto ..................................... ........................................................... .................................. ............ 28 TextBox ........................................... ................................................................. ............................................ ............................................ ............................... ......... 29 Label ............................................ ................................................................... ............................................. ............................................ .................................. ............ 30 Controles que muestran opciones a los usuarios ............................................ ............................................................ ................ 31 CheckBox ............................................ .................................................................. ............................................ ............................................. ........................... .... 31 OptionButton .......................................... ................................................................. ............................................. ............................................. ....................... 32 ListBox ............................................ .................................................................. ............................................ ............................................ ............................... ......... 32 ComboBox........................................... ................................................................. ............................................ ............................................. ........................... .... 33 Fundamentos de los Menús .................................................. ........................................................................ .......................................... .................... 34 Menús incorporados .......................................... ................................................................ ............................................ ............................... ......... 34 Menús contextuales .......................................................... ................................................................................ ...................................... ................ 34 Editor de Menús (Cuadro de Dialogo) ................................................ ....................................................................... ....................... 34
Índice Primer Hemi Bienvenido a Visual Basic ® 6.0 .......................................... ................................................................ ............................................ ...................... 3 Definición de Visual Basic ......................... ................................................ ............................................. ............................................ ......................... ... 4 Descripción del entorno ....................... ............................................. ............................................ ............................................ ............................. ....... 5 Iniciar el IDE de Visual Basic ........................ .............................................. ............................................ ........................................ .................. 6 Elementos del entorno integrado de desarrollo (IDE) ........................................... .................................................... .......... 7 Barra de menús ........................................... ................................................................. ............................................ ............................................ ...................... 8 Menús contextuales .......................................................... ................................................................................ ............................................ ...................... 8 Barras de herramientas ..................................................... ........................................................................... ............................................ ...................... 9 Cuadro de herramientas .............................. .................................................... ............................................ .......................................... .................... 10 Prefijos............................................. .................................................................... ............................................. ............................................ .................................. ............ 10 Ventana Explorador de proyectos.................................. proyectos........................................................ ............................................. ....................... 11 Ventana Propiedades ............................................................ .................................................................................. ...................................... ................ 11 Examinador de objetos ......................................................... ............................................................................... ...................................... ................ 11 Diseñador de formularios ..................................................... ........................................................................... ...................................... ................ 12 Ventana Editor de código ...................................... ............................................................ ............................................ ............................... ......... 12 Ventana Posición del formulario ...................................... ............................................................ .......................................... .................... 13 Ventanas Inmediatas, Locales e Inspección ............................ ................................................... ................................... ............ 13 Guardar un proyecto. ...................................... ............................................................ ............................................ ...................................... ................ 14 Mi primera Aplicación................................ Aplicación...................................................... ............................................. .............................................. ....................... 15 Hola, Visual Basic .......................................... ................................................................ ............................................ .......................................... .................... 15 Crear la interfaz ..................................................... ........................................................................... ............................................. ............................... ........ 15 Cambiar el tamaño, movimiento y bloqueo de controles ....................................... ....................................... 16 Establecer propiedades ......................................................... ............................................................................... ...................................... ................ 18 Establecer la propiedad Icon...................................... Icon............................................................ ............................................. ....................... 19 Escribir código ............................ ................................................... .............................................. .............................................. .................................. ........... 19 Crear procedimientos de evento ....................................... ............................................................. ...................................... ................ 21 Ejecutar la aplicación.............................. aplicación.................................................... ............................................. .............................................. ....................... 22 Formularios, controles y menús................................. menús....................................................... ............................................ ............................... ......... 22 Descripción de las propiedades, métodos y eventos.............................................. eventos....................................................... ......... 23 Diseñar un formulario............................................ ................................................................... ............................................. .................................. ............ 24 Establecer las propiedades de un formulario .......................................... .............................................................. .................... 25 Eventos y métodos de un formulario ........................................... .................................................................. ............................... ........ 26 Hacer clic en los botones para realizar acciones ................................. ....................................................... ........................... ..... 27 Usar los botones de comando ........................................... ................................................................. .......................................... .................... 27 La aplicación Prueba de botones ............................... ..................................................... ............................................. ........................... .... 28 Controles para mostrar e introducir texto ..................................... ........................................................... .................................. ............ 28 TextBox ........................................... ................................................................. ............................................ ............................................ ............................... ......... 29 Label ............................................ ................................................................... ............................................. ............................................ .................................. ............ 30 Controles que muestran opciones a los usuarios ............................................ ............................................................ ................ 31 CheckBox ............................................ .................................................................. ............................................ ............................................. ........................... .... 31 OptionButton .......................................... ................................................................. ............................................. ............................................. ....................... 32 ListBox ............................................ .................................................................. ............................................ ............................................ ............................... ......... 32 ComboBox........................................... ................................................................. ............................................ ............................................. ........................... .... 33 Fundamentos de los Menús .................................................. ........................................................................ .......................................... .................... 34 Menús incorporados .......................................... ................................................................ ............................................ ............................... ......... 34 Menús contextuales .......................................................... ................................................................................ ...................................... ................ 34 Editor de Menús (Cuadro de Dialogo) ................................................ ....................................................................... ....................... 34
Índice segundo Hemi Trabajar con Proyectos ....................................... ............................................................. ............................................ ...................................... ................ 35 Explorador de proyectos ............................................ .................................................................. ............................................ ........................... ..... 35 Archivos de proyecto......................................... ............................................................... ............................................. ................................... ............ 36 Estructura de un proyecto de Visual Basic ........................... ................................................. .......................................... .................... 36 Módulos de formulario ...................................... ............................................................ ............................................. ................................... ............ 36 Módulos de clase ............................................... ...................................................................... ............................................. .................................. ............ 37 Módulos estándar ........................ ............................................... .............................................. ............................................. .................................. ............ 37 Archivos de recursos ............................................................ .................................................................................. ...................................... ................ 37 Documentos ActiveX ............................................ .................................................................. ............................................ ............................... ......... 37 Módulos de controles de usuario y de páginas de propiedades pr opiedades.................................. .................................. 37 Componentes .......................................... ................................................................. ............................................. ............................................. ....................... 38 Controles ActiveX .................................................... ........................................................................... .............................................. ....................... 38 Objetos insertables ........................... ................................................. ............................................ ............................................ ........................... ..... 38 Referencias ............................................. ................................................................... ............................................ .......................................... .................... 38 Diseñadores ActiveX ......................................... ............................................................... ............................................ ............................... ......... 38 Controles estándar ............................................................ .................................................................................. .......................................... .................... 39 Crear, abrir y guardar proyectos ................................ ...................................................... ............................................ ............................... ......... 39 Trabajar con varios proyectos................................ proyectos...................................................... ............................................. ........................... .... 40 Agregar, quitar y guardar archivos ................................... ......................................................... .......................................... .................... 40 Combinar texto ............................................................. .................................................................................... .............................................. ....................... 42 Crear y ejecutar un archivo ejecutable ................................................ ....................................................................... ........................... .... 42 Compilación condicional ................................ ...................................................... ............................................ ...................................... ................ 43 Definir opciones del proyecto ......................................................... ............................................................................... ............................... ......... 43 Estructura de una aplicación en Visual Basic .......................................... ................................................................. ....................... 44 Trabajar con proyectos ..................................................... ............................................................................ .............................................. ....................... 46 Explorador de proyectos ............................................ .................................................................. ............................................ ........................ 46 Archivos de proyecto......................................... ............................................................... ............................................ ............................... ......... 47 Crear y ejecutar un archivo ejecutable ........................................................... ....................................................................... ............ 47 Compilación condicional ................................... ......................................................... ............................................ ............................... ......... 48 Especificaciones, Especificaciones, limitaciones y de archivos de Visual Basic ....................................... ....................................... 48 Requisitos del sistema para aplicaciones de Visual Basic .......................................... .......................................... 49 Limitaciones de los proyectos .......................................... ................................................................ .......................................... .................... 49 Formatos de archivos de un proyecto ............................... ..................................................... .......................................... .................... 50 Extensiones de archivos de proyecto........................................... .................................................................. ........................... .... 50 Archivos varios y de tiempo de diseño............................................ ................................................................... ....................... 50 Archivos de tiempo de ejecución.............................. ejecución..................................................... .............................................. ....................... 51 Agregar controles a un proyecto........................................... ................................................................. .......................................... .................... 52 Agregar controles ActiveX a un proyecto pro yecto ........................................... .................................................................. ....................... 52 Quitar controles de un proyecto .......................................................... ................................................................................. ....................... 53 Usar objetos de otras aplicaciones............................................ ................................................................... .................................. ........... 53 Usar un archivo de recursos ........................................................ .............................................................................. ............................... ......... 54
Bienvenido a Visual Basic ® 6.0 Bienvenido a Microsoft Visual Basic ® 6.0, el lenguaje de programación más rápido y sencillo para crear aplicaciones bajo el entorno de Microsoft Windows®.
¿Qué es Visual Basic? La palabra "Visual " hace referencia al método que se utiliza para crear la interfaz gráfica de usuario (G UI ), que es lo que el usuario ve en pantalla cuando interactúa con una aplicación. En.VB, el diseño de la GUI es muy sencillo, realmente vas viendo lo que creas mientras lo creas. En lugar de escribir un montón de líneas de código, vas colocando los objetos gráficamente, por lo que resulta mucho más fácil e intuitivo. La palabra " Basic" hace referencia al lenguaje BASIC (Beginners AllP ur urp pose Sym ymb bolilicc I nstr nstruct uctii on Co Code), un lenguaje utilizado por más programadores que ningún otro lenguaje en la historia de la informática o computación. Visual Basic ha evolucionado a partir del lenguaje BASIC original y ahora contiene centenares de instrucciones, funciones y palabras clave, muchas de las cuales están directamente relacionadas con la interfaz gráfica de Windows. Este lenguaje de programación no es exclusivo de Visual Basic. Microsoft Excel, Microsoft Access y muchas otras aplicaciones Windows, utilizan el mismo lenguaje. Scripting Edition (VBScript) es un lenguaje de secuencias de comandos ampliamente difundido para para páginas Web y es un subconjunto del lenguaje Visual Basic. El tiempo que emplees en el aprendizaje de Visual Basic te servirá en cualquiera de estas otras aplicaciones.
Cuando terminas, VB genera un archivo del tipo .exe que puedes distribuir con entera libertad.
Definición de Visual Basic En el mundo de la programación informática, uno de los lenguajes más populares y conocidos es el de Visual Basic. Creado en 1991 por Alan Cooper para Microsoft, este paquete permite programar contenidos informáticos gráficos de manera simple y accesible. El Visual Basic ha sido desarrollado con el objetivo de entregar a los usuarios de programación informática un paquete de utilidades simples y accesibles. Es por esto que el Visual Basic puede ser usado y fácilmente comprendido por expertos como también por usuarios principiantes. La creación de interfaces gráficas para diferentes utilidades es una de las principales funciones del Visual Basic y es por esto que es altamente usado en espacios profesionales donde se requieren soportes gráficos para mayor organización de los contenidos y materiales. La programación gráfica se puede llevar a cabo directamente ya que el Visual Basic no requerirá de los usuarios la escritura de los códigos de programación. Ahí, el Visual Basic trabaja a partir de lenguajes RAD, en inglés Rapid Application Development, o desarrollo rápido de aplicaciones específicas para cada necesidad y función. Al mismo tiempo, el Visual Basic, gracias a su simple lenguaje, es perfectamente adaptable a las plataformas de los sistemas Windows Windows y es fácilmente transformable transformable a otros lenguajes más complejos. Visual Basic 6.0, salido a mediados de 1998, muy mejorado, incrementó el número de áreas e incluyó la posibilidad de crear aplicaciones basadas en Web. Microsoft retiró el soporte de VB6 en marzo de 2008, 200 8, pero a pesar de ello las aplicaciones que genera son compatibles con plataformas más modernas, como Windows Vista, Windows Server 2008, Windows 7, 7, Windows 8, Windows 10.
Entorno de desarrollo integrado (IDE)
Descripción del entorno Para desarrollar el curso se utilizara Visual Basic 6.0, y todas las referencias e imágenes serán sobre esa versión. Cuando ejecute VB, después de cargar el entorno, nos aparece el siguiente cuadro:
Nos ofrece tres solapas: Nuevo, con las diferentes opciones que nos permite crear VB, en principio sólo utilizaremos EXE estándar, que nos llevará a un formulario vacío desde el cual comenzaremos a desarrollar nuestra aplicación. Existente, nos permite abrir proyectos que ya existen para continuar implementándolos. Recientes, lo mismo, pero sobre los últimos proyectos que hayamos estado desarrollando. Una vez que hayamos elegido EXE estándar, aceptamos y aparece la siguiente ventana (salvo por las diferencias de tamaño, necesarias para que entre la imagen), en la cual vemos que tenemos un proyecto abierto que en principio cuenta con un formulario vacío. Posteriormente, si los necesitamos podremos insertarle tantos formularios al proyecto como queramos.
I niciar el I DE de Visual Basic Cuando ejecute el programa de instalación de Visual Basic, le permitirá colocar los elementos del programa en un grupo de programas ya existente o crear un nuevo grupo de programas y nuevos elementos de programa para Visual Basic en Windows. Entonces estará preparado para iniciar Visual Basic desde Windows.
Para iniciar Visual Basic desde Windows 1. Haga clic en Inicio en la barra de tareas. 2. Seleccione Programas y luego Microsoft Visual Basic 6.0 . – o bien –
Haga clic en Inicio en la barra de tareas. Seleccione Programas . Utilice el Explorador de Windows para encontrar el archivo ejecutable de Visual Basic. 3. Haga doble clic en el icono de Visual Basic. También puede crear un acceso directo a Visual Basic y hacer doble clic en él. Cuando inicie Visual Basic por primera vez, verá el entorno integrado de desarrollo, como se muestra en la figura 2.1.
Figura 2.1 El entorno integrado de desarrollo (IDE) de Visual Basic
E lementos del entorno integrado de desarrollo (I DE ) El entorno integrado de desarrollo de Visual Basic (IDE) consta de los siguientes elementos.
Barra de título.
Botones de Control (mini mizar, maxi mizar, restaurar, cerrar)
Barra de menús
Presenta los comandos que se usan para trabajar con Visual Basic. Además de los menús estándar Archivo, Edición, Ver, Ventana y Ayuda, se proporcionan otros menús para tener acceso a funciones específicas de programación como Proyecto , Formato o Depuración.
Menús contextuales
Contienen accesos directos a acciones que se realizan con frecuencia. Para abrir un menú contextual, haga clic con el botón secundario del mouse (clic derecho) en el objeto que está usando. La lista específica de opciones disponibles en el menú contextual depende de la parte del entorno en la que se hace clic con el botón secundario del mouse.
Por ejemplo, el menú contextual que aparece cuando hace clic con el botón secundario del mouse en el cuadro de herramientas le permite mostrar el cuadro de diálogo
Componentes, ocultar el cuadro de herramientas, acoplar o desacoplar el cuadro de herramientas, o agregar una ficha personalizada al cuadro de herramientas.
Barras de herramientas
Proporcionan un rápido acceso a los comandos usados normalmente en el entorno de programación. Haga clic en un botón de la barra de herramientas para llevar a cabo la acción que representa ese botón. De forma predeterminada, al iniciar Visual Basic se presenta la barra de herramientas Estándar. Es posible activar o desactivar otras barras de herramientas adicionales para modificar, diseñar formularios desde el comando Barras de herramientas del menú Ver. Las barras de herramientas se pueden acoplar debajo de la barra de menús o pueden "flotar" si selecciona la barra vertical del borde izquierdo y la arrastra fuera de la barra de menús.
Cuadro de herramientas
Prefijos Objeto PictureBox Label TextBox Frame CommandButton CheckBox OptionButton ComboBox ListBox HScrollBar VScrollBar Timer DriveListBox DirListBox FileListBox Shape Line Image Data OLE
Prefijo Pict Lbl Txt Fra - Frm Cmd Chk Opt Cmb Lst Hsb Vsb Tmr Drv Dir File Shp ln Img Dat Ole
Proporciona un conjunto de herramientas que puede usar durante el diseño para colocar controles en un formulario. Además del diseño del cuadro de herramientas predeterminado, puede crear su propio diseño personalizado si selecciona Agregar ficha en el menú contextual y agrega controles a la ficha resultante.
Para obtener más información Para aprender más acerca de los controles específicos, vea "Formularios, controles y menús" y "Usar los controles estándar de Visual Basic". Para obtener información acerca de cómo agregar controles al cuadro de herramientas, vea "Agregar controles a un proyecto" en "Administrar proyectos".
Ventana E xplorador de proyectos
Enumera los formularios y módulos del proyecto actual. Un proyecto es la colección de archivos que usa para generar una aplicación.
Para obtener más información Para obtener información acerca de proyectos, vea "Administrar proyectos".
Ventana Propiedades
Enumera los valores de las propiedades del control o formulario seleccionado. Una propiedad es una característica de un objeto, como su tamaño, título o color.
Para obtener más información Para obtener información acerca de propiedades, vea "Descripción de las propiedades, métodos y eventos" en "Formularios, controles y menús".
E xaminador de objetos Enumera los objetos disponibles que puede usar en su proyecto y le proporciona una manera rápida de desplazarse a través del código. Puede usar el Examinador de objetos para explorar objetos en Visual Basic y otras aplicaciones, ver qué métodos y propiedades están disponibles para esos objetos, y pegar código de procedimientos en su aplicación.
Para obtener más información Para obtener más información acerca del uso del Examinador de objetos para ver procedimientos, vea "Descripción de objetos" en "Programar con objetos". Para obtener más información acerca del uso de complementos para ampliar el entorno de programación de Visual Basic, vea "Usar asistentes y complementos" en "Administrar proyectos".
Diseñador de formularios
Funciona como una ventana en la que se personaliza el diseño de la interfaz de su aplicación. Agregue controles, gráficos e imágenes a un formulario para crear la apariencia que desee. Cada formulario de la aplicación tiene su propia ventana diseñador de formulario.
Para obtener más información Para aprender a agregar controles a una aplicación, vea "Su primera aplicación con Visual Basic", más adelante en este mismo capítulo. Para aprender más acerca del diseño de la interfaz, vea "Crear la interfaz de usuario".
Ventana E ditor de código
Funciona como un editor para escribir el código de la aplicación. Se crea una ventana editor de código diferente para cada formulario o módulo del código de la aplicación.
Para obtener más información Para aprender más acerca de cómo escribir código y el uso del editor de código, vea "Fundamentos de programación".
Ventana Posición del formulari o La ventana Posición del formulario (figura 2.2) le permite colocar los formularios de su aplicación utilizando una pequeña representación gráfica de la pantalla.
Figura 2.2 La ventana Posición del formulario
Ventanas I nmediatas, L ocales e I nspección Estas ventanas adicionales se proporcionan para la depuración de la aplicación. Sólo están disponibles cuando ejecuta la aplicación dentro del IDE.
Para obtener más información Para aprender más acerca de la depuración y el uso de las ventanas de depuración, vea "Depurar el código y tratamiento de errores". Nota También puede agregar características a la interfaz de Visual Basic mediante un programa llamado complemento. Los complementos, disponibles en Microsoft y otros desarrolladores, pueden proporcionar características como el control de código fuente, que permite mantener proyectos de desarrollo en grupo.
Guardar un proyecto. Crearemos una carpeta en nuestro disco duro, por ejemplo: C:\Mis Documentos\Visual Basic\Proyectos, donde almacenaremos tanto los proyectos como los formularios. Podemos guardar los formularios o el proyecto separadamente, pero lo más cómodo es ir al menú Archivo / Guardar proyecto . De esta forma nos sale primero una ventana para que guardemos los formularios que componen nuestro proyecto, en la cual le podemos indicar la carpeta y el nombre que queremos asignar. Cuando tengamos guardados todos los formularios del proyecto, nos sale otra ventana para hacer lo mismo con el proyecto. Guardaremos el ejemplo anterior en la carpeta predeterminada, asignando Form1 al formulario y Proyecto1 al proyecto. Posteriormente para acceder al mismo, bastará con abrir el proyecto Proyecto1 , lo cual nos abrirá todos los formularios que contenga. Cuando se desarrolla un aplicación, se trabaja con un archivo de proyecto para administrar todos los diferentes archivos que se crean. Un proyecto consta de:
Un archivo de proyecto que realiza el seguimiento de todos los componentes (.vbp) Un archivo para cada formulario (.frm). Un archivo de datos binarios para cada formulario que contiene datos sobre propiedades de controles del formulario (.frx). Estos archivos no se pueden modificar y los genera automáticamente cualquier archivo .frm que tenga propiedades en formato binario, como Picture o Icon. Opcionalmente, un archivo para cada módulo de clase (.cls). Opcionalmente, un archivo para cada m ódulo estándar (.bas). Opcionalmente, uno o más archivos con c ontroles ActiveX (.ocx). Opcionalmente, un único archivo de recursos (.res). Opcionalmente, un único archivo de espacio de trabajo de proyecto de Visual Basic (.vbw).
El archivo de proyecto es simplemente una lista de todos los archivos y objetos asociados con el proyecto, así como información acerca de las opciones de entorno establecidas. Esta información se actualiza cada vez que se guarda el proyecto. Todos los archivos y objetos también se pueden compartir con otros proyectos. Cuando ha completado todos los archivos del proyecto podremos convertir el proyecto en un archivo ejecutable (.exe): en el menú Archivo, eligiendo el comando Generar proyecto.exe.
Mi primera Aplicación. Hola, Visual Basic Hay tres pasos principales para crear una aplicación en Visual Basic: 1. Crear la interfaz. 2. Establecer propiedades. 3. Escribir el código. Para ver cómo se realiza esto, siga los pasos del siguiente procedimiento para crear una aplicación sencilla que consiste en un cuadro de texto y un botón de comando. Cuando haga clic en el botón de comando aparecerá el mensaje "!Hola, mundo!" en el cuadro de texto.
Crear la interfaz Los formularios son la base para crear la interfaz de una aplicación. Puede usar formularios para agregar ventanas y cuadros de diálogo a la aplicación. También puede usarlos como contenedores de elementos que no son parte visible de la interfaz de la aplicación. Por ejemplo, puede tener un formulario en su aplicación que sirva como contenedor para gráficos que quiera presentar en otros formularios. El primer paso para generar una aplicación de Visual Basic consiste en crear los formularios que van a ser la base de la interfaz de su aplicación. Después dibuje los objetos que van a componer la interfaz en los formularios que ha creado. Para esta primera aplicación, usaremos dos controles del cuadro de herramientas.
Para dibujar un control mediante el cuadro de herramientas 1. Haga clic en la herramienta del control que ha elegido dibujar; en este caso el cuadro de texto . 2. Mueva el puntero dentro del formulario. El puntero adoptará la forma de cruz, como se muestra en la figura 2.3.
Figura 2.3 Dibujar un cuadro de texto con el cuadro de herramientas
3. Coloque la cruz donde quiera que aparezca la esquina superior izquierda del control. 4. Arrastre la cruz hasta que el control tenga el tamaño deseado. ( Arrastrar significa mantener presionado el botón primario del mouse mientras mueve un objeto con el mouse.) 5. Suelte el botón del mouse. El control aparecerá en el formulario. Otra forma sencilla de agregar un control a un formulario es hacer doble clic en el botón de ese control en el cuadro de herramientas. Esto crea un control con un tamaño predeterminado situado en el centro del formulario; ahora puede mover el control a otra ubicación del formulario.
Cambiar el tamaño, movimiento y bloqueo de controles Observe que en las esquinas del control aparece unos pequeños cuadros rectangulares llamados controladores de tamaño ; en el siguiente paso usará estos controladores para cambiar el tamaño del control. También puede usar el mouse, el teclado y comandos de menú para mover controles, bloquear y desbloquear la posición de los controles, y ajustar sus posiciones.
Para cambiar el tamaño de un control 1. Seleccione el control que quiera cambiar el tamaño; para ello, haga clic en él con el mouse. Aparecerán en el control los controladores de tamaño.
2. Sitúe el puntero del mouse en un controlador de tamaño y arrástrelo hasta que el control tenga el tamaño elegido. Los controladores de las esquinas cambiarán el tamaño de controles horizontal y verticalmente, mientras que los controladores de los lados cambiarán el tamaño sólo en una dirección. 3. Suelte el botón del mouse. – o bien –
Use MAYÚS con las teclas de dirección para cambiar el tamaño del control seleccionado.
Para mover un control
Use el mouse para arrastrar el control a otra ubicación del formulario. – o bien –
Use la ventana Propiedades para cambiar las propiedades Top y Left. Cuando seleccione un control, puede usar CTRL con las teclas de dirección para mover el control una unidad de la cuadrícula cada vez. Si la cuadrícula está desactivada, el control se mueve un píxel cada vez.
Para bloquear la posición de todos los controles
En el menú Formato, elija Bloquear controles . – o bien –
Haga clic en el botón Alternar bloqueo de controles de la barra de herramientas Editor de formularios . Esto bloqueará todos los controles del formulario en sus posiciones actuales, de forma que no los podrá mover accidentalmente una vez que estén en la ubicación deseada. Se bloquearán los controles sólo en el formulario seleccionado; los controles de otros formularios no se ven afectados. Es un comando de alternar, por lo que puede usarlo también para desbloquear las posiciones de los controles.
Para ajustar la posición de controles bloqueados
Puede "arrastrar" el control que tiene el enfoque si presiona la tecla CTRL y la tecla de dirección adecuada. – o bien –
Puede cambiar las propiedades Top y Left del control en la ventana Propiedades.
Ya tiene la interfaz de la aplicación "¡Hola, mundo!", como se muestra en la figura 2.4.
Figura 2.4 La interfaz de la aplicación "¡Hola, mundo!"
E stablecer propiedades El siguiente paso consiste en establecer las propiedades de los objetos que ha creado. La ventana Propiedades (figura 2.5) proporciona una manera fácil de establecer las propiedades de todos los objetos de un formulario. Para abrir la ventana Propiedades, elija el comando Ventana Propiedades del menú Ver, haga clic en el botón Ventana Propiedades de la barra de herramientas o utilice el menú contextual del control.
Figura 2.5 La ventana Propiedades
La ventana Propiedades consta de los siguientes elementos:
Cuadro del objeto: presenta el nombre del objeto para el que puede establecer propiedades. Haga clic en la flecha situada a la derecha del cuadro Objeto para presentar la lista de objetos del formulario actual.
Fichas de orden: elija entre una lista alfabética de propiedades o una vista jerárquica dividida en categorías lógicas, como las que tratan de la apariencia, fuentes o posición. Lista de propiedades: la columna de la izquierda presenta todas las propiedades del objeto seleccionado. Puede modificar y ver los valores en la columna de la derecha.
Para establecer propiedades desde la ventana Propiedades 1. En el menú Ver, elija Propiedades o haga clic en el botón Propiedades de la barra de herramientas. La ventana Propiedades presenta los valores del formulario o control seleccionado. 2. En la lista Propiedades, seleccione el nombre de una propiedad. 3. En la columna de la derecha, escriba o seleccione el nuevo valor de la propiedad. Las propiedades enumeradas tienen una lista predefinida de valores. Puede presentar la lista si hace clic en la flecha hacia abajo que hay a la derecha del cuadro Valores o puede recorrer la lista haciendo doble clic en un elemento de la lista. En el ejemplo "¡Hola, mundo!" necesitará cambiar los valores de tres propiedades. Use el valor predeterminado para las demás propiedades.
Establecer la propiedad Icon Todos los formularios en Visual Basic tienen un icono genérico predeterminado que aparece cuando minimiza ese formulario. Sin embargo, probablemente cambiará este icono por uno que ilustre el uso del formulario en su aplicación. Para asignar un icono a un formulario, establezca la propiedad Icon para ese formulario. Puede usar iconos de 32 x 32 píxeles que eran estándar en las versiones de Microsoft Windows de 16 bits y que se utilizan también en Windows 95 y Windows NT, así como los iconos de 16 x 16 píxeles empleados en Windows 95.
E scribir código La ventana Editor de código es el lugar donde escribe el código de Visual Basic para su aplicación. El código consta de instrucciones del lenguaje, constantes y declaraciones.
Mediante la ventana Editor de código puede ver y modificar rápidamente el código de su aplicación.
Para abrir la ventana Código
Haga doble clic en el formulario o el control para el que desea escribir código. – o bien –
En la ventana Explorador de proyectos, seleccione el nombre de un formulario o un módulo y elija Ver código . La figura 2.6 muestra la ventana Editor de código que aparece cuando hace doble clic en el control botón de comando y los eventos de ese comando.
Figura 2.6 La ventana Editor de código
Puede elegir presentar todos los procedimientos en la misma ventana Código o presentar un único procedimiento cada vez.
Para presentar todos los procedimientos en la misma ventana Código 1. En el menú Herramientas, seleccione Opciones. 2. En la ficha Editor del cuadro de diálogo Opciones, active la casilla de verificación situada a la izquierda de Ver módulo completo de forma predeterminada. La casilla de verificación a la izquierda de Separador de procedimientos agrega o quita una línea separadora entre los procedimientos. – o bien –
Haga clic en el botón Ver módulo completo en la esquina inferior izquierda de la ventana Editor de código.
Para presentar un procedimiento cada vez en la ventana Código 1. En el menú Herramientas, seleccione Opciones. 2. En la ficha Editor del cuadro de diálogo Opciones, desactive la casilla de verificación que hay a la izquierda de Ver módulo completo de forma predeterminada. – o bien –
Haga clic en el botón Ver procedimiento en la esquina inferior izquierda de la ventana Editor de código. La ventana Código incluye los siguientes elementos:
Cuadro de lista Objeto: presenta el nombre del objeto seleccionado. Haga clic en la flecha de la derecha del cuadro de lista para presentar una lista de todos los objetos asociados con el formulario. Cuadro de lista Procedimiento: enumera los procedimientos o eventos de un objeto. El cuadro presenta el nombre del procedimiento seleccionado, en este caso Click. Elija la flecha que hay a la derecha del cuadro para presentar todos los procedimientos del objeto.
Crear procedimientos de evento El código en una aplicación de Visual Basic se divide en bloques menores llamados procedimientos. Un procedimiento de evento, como los que creará aquí, contiene código que se ejecuta cuando se produce un evento (como cuando un usuario hace clic en un botón). Un procedimiento de evento de un control combina el nombre real del control (especificado en la propiedad Name), un carácter de subrayado (_) y el nombre del evento. Por ejemplo, si quiere que un botón de comando llamado Command1 invoque un procedimiento de evento cuando se haga clic en él, utilice el procedimiento Command1_Click.
Para crear un procedimiento de evento 1. En el cuadro de lista Objeto, seleccione el nombre de un objeto del formulario activo. (El formulario activo es el formulario que actualmente tiene el enfoque.) Para este ejemplo, elija el botón de comando, Command1. 2. En el cuadro de lista Procedimiento, seleccione el nombre de un evento del objeto seleccionado.
Aquí, el procedimiento Click ya está seleccionado puesto que es el procedimiento predeterminado para un botón de comando. Observe que ahora se presenta en la ventana Código una plantilla para el procedimiento de evento. 3. Escriba el siguiente código entre las instrucciones Sub y End Sub: 4. Text1.Text = "¡Hola, mundo!"
El procedimiento de evento debería parecerse a éste: Private Sub Command1_Click () Text1.Text = "¡Hola, mundo!" End Sub
Observará que aquí el código simplemente cambia la propiedad Text del control llamado Text1 para que sea "¡Hola, mundo!". La sintaxis de este ejemplo tiene el formato objeto.propiedad , donde Text1 es el objeto y Text la propiedad. Puede usar esta sintaxis para cambiar los valores de las propiedades de cualquier formulario o control como respuesta a los eventos que se producen mientras se ejecuta su aplicación.
Para obtener más información Para obtener información acerca de la creación de otros tipos de procedimientos, vea "Introducción a los procedimientos" en "Fundamentos de programación".
E jecutar la aplicación Para ejecutar la aplicación, elija Iniciar en el menú Ejecutar, haga clic en el botón Iniciar de la barra de herramientas o presione F5. Haga clic en el botón de comando que ha creado en el formulario y verá cómo aparece "¡Hola, mundo!" en el cuadro de texto.
Formularios, controles y menús El primer paso para crear una aplicación con Visual Basic es crear la interfaz, la parte visual de la aplicación con la que va a interactuar el usuario. Los formularios y controles son los elementos de desarrollo básicos que se usan para crear la interfaz; son los objetos con los que se trabaja para desarrollar la aplicación. Los formularios son objetos que exponen las propiedades que definen su apariencia, los métodos que definen su comportamiento y los eventos que definen la forma en que interactúan con el usuario. Mediante el establecimiento de las propiedades del formulario y la escritura de código de Visual Basic para responder a sus eventos se personaliza el objeto para cubrir las necesidades de la aplicación. Los controles son objetos que están contenidos en los objetos de formularios. Cada tipo de control tiene su propio conjunto de propiedades, métodos y eventos, que lo hacen adecuado para una finalidad determinada. Algunos de los controles que puede usar en las aplicaciones son más adecuados para escribir o mostrar texto, mientras que otros
controles permiten tener acceso a otras aplicaciones y procesan los datos como si la aplicación remota formara parte del código. Este capítulo presenta los conceptos básicos del trabajo con formularios y controles, y las propiedades, métodos y eventos que tienen asociados. Se explican muchos de los controles estándar, así como elementos específicos de formularios como menús y cuadros de diálogo.
Descripción de las propiedades, métodos y eventos
Los formularios y controles de Visual Basic son objetos que exponen sus propios métodos, propiedades y eventos. Las propiedades se pueden considerar como atributos de un objeto, los métodos como sus acciones y los eventos como sus respuestas. Un objeto de uso diario como el globo de un niño tiene también propiedades, métodos y eventos. Entre las propiedades de un globo se incluyen atributos visibles como el alto, el diámetro y el color. Otras propiedades describen su estado (inflado o desinflado) o atributos que no son visibles, como su edad. Por definición, todos los globos tienen estas propiedades; lo que varía de un globo a otro son los valores de estas propiedades. Un globo tiene también métodos o acciones inherentes que puede efectuar. Tiene un método inflar (la acción de llenarlo de helio) o un método desinflar (expeler su contenido) y un método elevarse (si se deja escapar). De nuevo, todos los globos pueden efectuar estos métodos. Los globos tienen, además, respuestas predefinidas a ciertos eventos externos. Por ejemplo, un globo respondería al evento de pincharlo desinflándose o al evento de soltarlo elevándose en el aire.
Figura 3.1 Los objetos tienen propiedades, responden a eventos y ejecutan métodos
Si se pudiera programar un globo, el código de Visual Basic podría ser como el siguiente. Para establecer las propiedades del globo: Globo.Color = Rojo Globo.Diámetro = 10 Globo.Inflado = True
Observe la sintaxis del código: el objeto (Globo) seguido de la propiedad (.Color) seguida de la asignación del valor (Rojo). Podría modificar el color del globo desde el código si repitiera esta instrucción y sustituyera el valor por otro diferente. También es posible establecer las propiedades en la ventana Propiedades mientras se está diseñando la aplicación. Los métodos de un globo se invocan de esta forma: Globo.Inflar Globo.Desinflar Globo.Elevar 5
La sintaxis es similar a la sintaxis de las propiedades: el objeto (un nombre) seguido de un método (un verbo). En el tercer ejemplo hay un elemento adicional, llamado argumento, que indica la distancia que se eleva. Algunos métodos tendrán uno o más argumentos para describir más a fondo la acción que se va a ejecutar. El globo puede responder a un evento como se muestra a continuación: Sub Globo_Pinchazo() Globo.Desinflar Globo.HacerRuido "Bang" Globo.Inflado = False Globo.Diámetro = 1 End Sub
En este caso, el código describe el comportamiento del globo cuando se produce un evento Pinchazo: invoca el método Desinflar y luego invoca el método HacerRuido con un argumento "Bang" (el tipo de ruido que se va a hacer). Como el globo ya no está inflado, la propiedad Inflado tiene el valor False y la propiedad Diámetro adopta un nuevo valor. Si bien no puede programar un globo, sí puede programar un formulario o un control de Visual Basic. Como programador, tiene el control: decide qué propiedades se deben modificar, qué métodos se deben invocar o a qué eventos hay que responder para conseguir la apariencia y el comportamiento deseados.
Diseñar un formulario Los objetos de un formulario son los elementos de desarrollo básicos de una aplicación de Visual Basic, las ventanas reales con las que interactúa el usuario cuando ejecuta la aplicación. Los formularios tienen sus propios eventos, propiedades y métodos con los que se puede controlar su apariencia y comportamiento.
Figura 3.2 Los formularios y controles tienen sus propios eventos, propiedades y métodos
El primer paso para diseñar un formulario consiste en establecer sus propiedades. Puede establecer las propiedades de un formulario en tiempo de diseño en la ventana Propiedades o en tiempo de ejecución, escribiendo código.
Nota En tiempo de diseño, que es cualquier momento mientras está desarrollando una aplicación en el entorno de Visual Basic, se trabaja con formularios y controles, se establecen propiedades y se escribe código para los eventos. Tiempo de ejecución es cualquier momento mientras se ejecuta realmente la aplicación y se interactúa con ella como lo haría un usuario.
E stablecer las propiedades de un formulario Muchas propiedades de un formulario afectan a su apariencia física. La propiedad Caption determina el texto que muestra la barra de título del formulario y la propiedad Icon establece el icono que aparece cuando se minimiza un formulario. Las propiedades MaxButton y MinButton determinan si el formulario se puede maximizar o minimizar. Si cambia la propiedad BorderStyle puede controlar el comportamiento de cambio de tamaño del formulario. Las propiedades Height y Width determinan el tamaño inicial de un formulario, mientras que las propiedades Left y Top determinan la ubicación del formulario en relación con la esquina superior izquierda de la pantalla. Con la propiedad WindowState puede establecer si el formulario se inicia en estado maximizado, minimizado o normal. La propiedad Name establece el nombre con el que hará referencia al formulario en el código. De forma predeterminada, cuando se agrega un formulario por primera vez a un proyecto, su nombre es Form1, Form2, etc. Es conveniente asignar a la propiedad Name un valor más significativo, como "frmEntry" para un formulario de entrada de pedidos. La mejor manera de familiarizarse con las numerosas propiedades de los formularios es experimentar. Cambie algunas propiedades de un formulario en la ventana Propiedades
(figura 3.3) y ejecute la aplicación para ver su efecto. Puede aprender más acerca de cada propiedad si la selecciona y presiona F1 para ver Ayuda contextual.
Figura 3.3 La ventana Propiedades
E ventos y métodos de un formulario Como objetos que son, los formularios pueden ejecutar métodos y responder a eventos. El evento Resize de un formulario se desencadena siempre que se cambia el tamaño de un formulario, ya sea por una acción del usuario o a través del código. Esto permite realizar acciones como mover o cambiar el tamaño de los controles de un formulario cuando han cambiado sus dimensiones. El evento Activate se produce siempre que un formulario se convierte en el formulario activo; el evento Deactivate se produce cuando otro formulario u otra aplicación se convierte en activo. Estos eventos son adecuados para iniciar o finalizar acciones del formulario. Por ejemplo, en el evento Activate podría escribir código para resaltar el texto de un determinado cuadro de texto; con el evento Deactivate podría guardar los cambios efectuados en un archivo o en una base de datos. Para hacer visible un formulario se invoca el método Show: Form2.Show
Invocar el método Show tiene el mismo efecto que asignar el valor True a la propiedad Visible del formulario. Muchos métodos de un formulario implican texto o gráficos. Los métodos Print, Line, Circle y Refresh son útiles para imprimir o dibujar directamente en la superficie de un formulario. Estos y otros métodos se explican en "Trabajar con texto y gráficos".
Para obtener más información Para obtener información adicional acerca de los formularios, vea "Más acerca de los formularios" en "Crear la interfaz de usuario".
Hacer clic en los botones para realizar acciones
La forma más sencilla de permitir al usuario interactuar con una aplicación es proporcionarle un botón para que haga clic en él. Puede usar el control de botón de comando que proporciona Visual Basic o crear su propio "botón" mediante un control de imagen que contenga un gráfico, por ejemplo un icono.
Usar los botones de comando La mayoría de las aplicaciones de Visual Basic tienen botones de comando que permiten al usuario hacer clic en ellos para realizar acciones. Cuando el usuario hace clic en el botón, éste no solamente realiza una acción, sino que, además, parece que se está presionando y soltando. Siempre que el usuario hace clic en un botón se invoca el procedimiento de evento Click. Para realizar cualquier acción que desee puede escribir código en el procedimiento de evento Click. Hay muchas formas de elegir un botón de comando en tiempo de ejecución:
Usar un mouse (ratón) para hacer clic en el botón. Mover el enfoque al botón presionando la tecla TAB y elegir luego el botón presionando la BARRA ESPACIADORA o ENTRAR. (Vea "Descripción del enfoque", más adelante en este capítulo.)
Presionar una tecla de acceso a un botón de comando (ALT+ la letra subrayada).
Asignar a la propiedad Value del botón de comando el valor True en el código:
cmdCerrar.Value = True
Invocar el evento Click del botón de comando en el código:
cmdCerrar_Click
Si el botón de comando es el botón de comando predeterminado para el formulario, al presionar ENTRAR se elige el botón, incluso aunque cambie el enfoque a un control diferente de un botón de comando. Para especificar un botón de comando predeterminado en tiempo de diseño, asigne a la propiedad Default del botón el valor True. Si el botón de comando es el botón Cancelar predeterminado para el formulario, al presionar ESC se elige el botón, incluso aunque cambie el enfoque a otro
control. Para especificar un botón Cancelar predeterminado en tiempo de diseño, asigne a la propiedad Cancel del botón el valor True. Todas estas acciones hacen que Visual Basic invoque el procedimiento de evento Click.
La aplicación Prueba de botones Utilice la propiedad Caption para mostrar texto en el botón e indicar al usuario lo que hace el botón. En la figura 3.4, el ejemplo Prueba de botones de la aplicación de ejemplo Controls contiene un botón de comando cuya propiedad Caption es "Cambiar la señal". (Para ver una versión operativa de este ejemplo, vea el archivo Button.frm de la aplicación de ejemplo Controls.vbp.) Observe que la tecla de método abreviado para este botón es ‘S’, representada por el
subrayado. Insertar un símbolo & en el texto de la propiedad Caption hace que el carácter siguiente sea la tecla de método abreviado para el botón (por ejemplo, Cambiar la &señal).
Figura 3.4 Botón de comando con un título
Cuando un usuario hace clic en el botón de comando, se ejecuta el código contenido en el procedimiento de evento Click del botón de comando. En el ejemplo aparece un icono de semáforo diferente cada vez que se hace clic en el botón.
Para obtener más información Para obtener información acerca de las propiedades adicionales del botón de comando, vea "Usar los controles estándar de Visual Basic".
Controles para mostrar e introducir texto
Los controles de etiquetas y cuadros de texto se usan para mostrar o introducir texto. Utilice etiquetas cuando desee que la aplicación muestre texto en un formulario y utilice cuadros de texto cuando desee permitir al usuario escribir texto. Las etiquetas contienen texto que sólo se puede leer, mientras que los cuadros de texto contienen texto que se puede modificar.
TextBox
Un control TextBox, también denominado control de campo de edición o control de edición, muestra información introducida en tiempo de diseño, introducida por el usuario o asignada al control en código en tiempo de ejecución.
Sintaxis TextBox (Para Programar Txt)
Comentarios Para mostrar múltiples líneas de texto en un control TextBox, establezca la propiedad MultiLine a True. Si un TextBox de múltiples líneas no tiene una barra de desplazamiento horizontal, el texto se ajustará automáticamente aunque se ajuste el tamaño de TextBox. Para personalizar la combinación de barra de desplazamiento en un TextBox, establezca la propiedad ScrollBars. Las barras de desplazamiento siempre aparecerán en el TextBox cuando su propiedad MultiLine se haya establecido a True y su propiedad ScrollBars a cualquier cosa excepto None (0). Si establece la propiedad MultiLine a True, podrá emplear la propiedad Alignment para establecer la alineación del texto dentro del TextBox. El texto está justificado a la
izquierda de forma predeterminada. Si la propiedad MultiLine es False, el valor de la propiedad Alignment no tiene ningún efecto. Un control TextBox también puede actuar como vínculo de destino en una conversación DDE.
Label
Un control Label es un control gráfico que puede usar para mostrar texto que el usuario no podrá cambiar directamente.
Sintaxis Label (Para programar Lbl)
Comentarios Puede escribir código que cambie el texto mostrado por un control Label como respuesta a eventos en tiempo de ejecución. Por ejemplo, si la aplicación tarda unos minutos en realizar un cambio, puede mostrar un mensaje de estado del proceso en un control Label. También puede usar Label para identificar un control, como un control TextBox, que no tenga su propia propiedad Caption. Establezca las propiedades AutoSize y WordWrap si desea que Label muestre líneas de longitud variable o números variables de líneas. Un control Label también puede actuar como destino en una conversación DDE. Establezca la propiedad LinkTopic para crear un vínculo, establezca la propiedad LinkItem para especificar un elemento de la conversación y establezca la propiedad LinkMode para activar el vínculo. Una vez establecidas estas propiedades, Visual Basic intentará iniciar la conversación y mostrará un mensaje si no puede hacerlo. Establezca la propiedad UseMnemonic a True si desea definir un carácter en la propiedad Caption de Label como tecla de acceso. Cuando define una tecla de acceso en
un control Label, el usuario puede presionar y mantener presionado Alt+ el carácter que designe para mover el enfoque al control siguiente del orden de tabulación.
Controles que muestran opciones a los usuarios La mayoría de las aplicaciones necesitan presentar opciones a los usuarios, que van desde una simple opción de tipo sí o no hasta seleccionar de una lista que contiene cientos de posibilidades. Visual Basic incluye varios controles estándar que ayudan a presentar opciones. En la tabla siguiente se resumen estos controles y su uso adecuado.
CheckBox
Un control CheckBox muestra una X cuando está activado; la X desaparece cuando el control CheckBox se desactiva. Utilice este control para ofrecer al usuario una opción de tipo Verdadero o Falso o Sí o No. Puede usar controles CheckBox en grupos para mostrar múltiples opciones entre las cuales el usuario puede seleccionar una o más. También puede establecer el valor de CheckBox mediante programación con la propiedad Value.
Sintaxis CheckBox (Para programar Chk)
Comentarios
Los controles CheckBox y OptionButton funcionan de manera similar, pero con una diferencia importante: pueden seleccionarse varios controles CheckBox de un formulario al mismo tiempo. Por el contrario, sólo puede seleccionarse un control OptionButton en un grupo en un momento determinado. Para mostrar el texto que aparece junto al CheckBox, establezca la propiedad Caption. Utilice la propiedad Value para determinar el estado del control: activado, desactivado o no disponible.
OptionButton
Un control OptionButton muestra una opción que se puede activar o desactivar.
Sintaxis OptionButton (Para programar Opt)
Comentarios Generalmente, los controles OptionButton se utilizan en un grupo de opciones para mostrar opciones entre las cuales el usuario sólo puede seleccionar una. Los controles OptionButton se agrupan si los dibuja dentro de un contenedor como un control Frame, un control PictureBox o un formulario. Para agrupar controles OptionButton en un Frame o PictureBox, dibuje en primer lugar el Frame o el PictureBox y, a continuación, dibuje dentro los controles OptionButton. Todos los controles OptionButton que están dentro del mismo contenedor actúan como un único grupo. Aunque puede parecer que los controles OptionButton y CheckBox funcionan de forma similar, hay una diferencia importante: cuando un usuario selecciona un OptionButton, los otros controles OptionButton del mismo grupo dejan de estar disponibles automáticamente. Por el contrario, es posible seleccionar cualquier número de controles CheckBox.
ListBox
Un control ListBox muestra una lista de elementos entre los cuales el usuario puede seleccionar uno o más. Si el número de elementos supera el número que puede mostrarse, se agregará automáticamente una barra de desplazamiento al control ListBox. Si no se selecciona ningún elemento, el valor de la propiedad ListIndex será -1. El primer elemento de la lista es ListIndex 0 y el valor de la propiedad ListCount siempre es uno más que el mayor valor de ListIndex.
Sintaxis ListBox
Comentarios Para agregar o eliminar elementos de un control ListBox, use el método AddItem o RemoveItem. Establezca las propiedades List, ListCount y ListIndex para permitir que un usuario tenga acceso a elementos del ListBox. También puede agregar elementos a la lista mediante la propiedad List en tiempo de diseño.
ComboBox
Un control ComboBox combina las características de un control TextBox y un control ListBox; los usuarios pueden introducir información en la parte del cuadro de texto o seleccionar un elemento en la parte de cuadro de lista del control.
Sintaxis ComboBox
Comentarios Para agregar o eliminar elementos en un control ComboBox, use el método AddItem o RemoveItem. Establezca las propiedades List, ListCount y ListIndex para permitir a un usuario tener acceso a los elementos de un control ComboBox. Como alternativa, puede agregar elementos a la lista mediante la propiedad List en tiempo de diseño.
Nota Un evento Scroll ocurrirá en un control ComboBox sólo cuando se desplace el contenido de la parte desplegable del ComboBox, no cada vez que cambie el contenido del ComboBox. Por ejemplo, si la parte desplegable de un ComboBox contiene cinco elementos y el elemento superior está resaltado, no ocurrirá un evento Scroll hasta que presione seis veces la flecha hacia abajo (o una vez la tecla AV PÁG). Después de eso, ocurrirá un evento Scroll por cada pulsación de la tecla de flecha hacia abajo. Sin embargo, si después presiona la tecla de flecha hacia arriba, no ocurrirá un evento Scroll hasta que presione seis veces la tecla de flecha hacia arriba (o una vez la tecla RE PÁG). Después de eso, cada vez que presione la tecla de flecha hacia arriba se producirá un evento Scroll.
Fundamentos de los Menús Visual Basic dispone de dos tipos de menús: incorporados y contextuales.
Menús incorporados Los menús incorporados aparecen en la barra de menús situada en la parte superior de la ventana de Visual Basic. Cada menú contiene comandos que están relacionados con el nombre del menú. Por ejemplo, el menú Formato contiene comandos utilizados para dar formato al formulario. Algunos de los comandos tienen submenús donde se incluyen comandos más específicos. Por ejemplo, el comando Barras de herramientas del menú Ver tiene un submenú que contiene los nombres de las barras de herramientas y el comando Personalizar . Puede utilizar el comando Personalizar para modificar los menús incorporados o para agregar comandos a la barra de menús.
Menús contextuales Los menús contextuales son aquéllos que contienen los comandos utilizados con más frecuencia y que aparecen al hacer clic con el botón secundario del mouse (ratón) o al presionar Mayús-F10.
Nota Para encontrar información sobre un comando de menú, utilice el comando Índice de referencias de búsqueda perteneciente al menú Ayuda y busque el nombre del comando.
Editor de Menús (Cuadro de Dialogo) Muestra el cuadro de diálogo Editor de menús. Utilice el comando Editor de menús para la creación de menús personalizados en la aplicación y para la definición de algunas de las propiedades. Sólo está disponible entiempo de diseño. Método abreviado de la barra de herramientas:
Tecla de método abreviado: Ctrl-E.
Trabajar con Proyectos Cuando se desarrolla una aplicación, se trabaja con un archivo de proyecto para administrar todos los diferentes archivos que se crean. Un proyecto consta de:
Un archivo de proyecto que realiza el seguimiento de todos los componentes (.vbp) Un archivo para cada formulario (.frm). Un archivo de datos binarios para cada formulario que contiene datos sobre propiedades de controles del formulario (.frx). Estos archivos no se pueden modificar y los genera automáticamente cualquier archivo .frm que tenga propiedades en formato binario, como Picture o Icon.
Opcionalmente, un archivo para cada módulo de clase (.cls).
Opcionalmente, un archivo para cada módulo estándar (.bas).
Opcionalmente, uno o más archivos con controles ActiveX (.ocx).
Opcionalmente, un único archivo de recursos (.res).
El archivo de proyecto es simplemente una lista de todos los archivos y objetos asociados con el proyecto, así como información acerca de las opciones de entorno establecidas. Esta información se actualiza cada vez que se guarda el proyecto. Todos los archivos y objetos también se pueden compartir con otros proyectos. Cuando ha completado todos los archivos del proyecto puede convertir el proyecto en un archivo ejecutable (.exe): en el menú Archivo, elija el comando Generar proyecto.exe.
Nota Con las ediciones Profesional y Empresarial de Visual Basic también puede crear otro tipo de archivos ejecutables, como archivos .ocx y .dll. En las referencias de este capítulo se supone un proyecto .exe estándar; para obtener información adicional acerca de otros tipos de proyectos, vea la Guía de herramientas componentes , disponible en las ediciones Profesional y Estándar. Para obtener más información Para obtener más detalles acerca de la creación de ejecutables, vea "Crear y ejecutar un archivo ejecutable" más adelante en este capítulo. Para obtener información acerca de archivos de datos binarios y archivos de proyecto, vea "Especificaciones, limitaciones y formatos de archivos de Visual Basic".
Explorador de proyectos Cuando se crean, agregan o quitan archivos modificables de un proyecto, Visual Basic refleja los cambios en la ventana Explorador de proyectos, que contiene una lista actualizada de los archivos del proyecto. La ventana Explorador de proyectos de la figura 4.1 muestra algunos tipos de archivos que puede incluir un proyecto de Visual Basic.
Figura 4.1 Ventana del Explorador de proyectos
Archivos de proyecto Cada vez que guarda un proyecto, Visual Basic actualiza el archivo de proyecto (.vbp). Un archivo de proyecto contiene la misma lista de archivos que aparece en la ventana del Explorador de proyectos, así como referencias a los controles ActiveX y objetos insertables que se usan en el proyecto. Para abrir un archivo de proyecto existente, haga doble clic en el icono, elija el comando Abrir proyecto en el menú Archivo o arrastre el archivo y colóquelo en la ventana del Explorador de proyectos.
Para obtener más información El formato específico de la información almacenada en el archivo .vbp se describe en "Especificaciones, limitaciones y formatos de archivo de Visual Basic".
Estructura de un proyecto de Visual Basic Las siguientes secciones describen los diferentes tipos de archivos y objetos que se pueden incluir en un proyecto.
Módulos de formulario Los módulos de formulario (extensión de nombre de archivo .frm) pueden contener texto descriptivo del formulario y sus controles, incluyendo los valores de sus propiedades. También pueden contener declaraciones de formulario de constantes, variables y procedimientos externos, así como procedimientos de evento y procedimientos generales.
Para obtener más información Para obtener información acerca de la creación de formularios, vea "Desarrollar una aplicación con Visual Basic" y "Crear la interfaz de
usuario". Para obtener información acerca del formato y el contenido de archivos de formulario, vea "Especificaciones, limitaciones y formatos de archivos de Visual Basic".
Módulos de clase Los módulos de clase (extensión de nombre de archivo .cls) son similares a los módulos de formulario, excepto en que no tienen interfaz de usuario visible. Puede usar módulos de clase para crear sus propios objetos, incluyendo código para métodos y propiedades.
Para obtener más información Para obtener información acerca de la escritura de código en módulos de clase, vea "Crear clases propias" en "Programar con objetos".
Módulos estándar Los módulos estándar (extensión de nombre de archivo .bas) pueden contener declaraciones públicas o a nivel de módulo de tipos, constantes, variables, procedimientos externos y procedimientos públicos.
Para obtener más información Para obtener información acerca del uso de módulos, vea "Fundamentos de programación" y "Programar con objetos".
Archivos de recursos Los archivos de recursos (extensión de nombre de archivo .res) contienen mapas de bits, cadenas de texto y otros datos que se pueden modificar sin volver a modificar el código. Por ejemplo, si piensa localizar su aplicación a un idioma extranjero, puede guardar todas las cadenas de texto de la interfaz de usuario y los mapas de bits en un archivo de recursos, y simplemente traducir el archivo de recursos en vez de la aplicación completa. Un proyecto sólo puede contener un archivo de recursos.
Para obtener más información Para obtener más información acerca del uso de archivos de recursos, vea "Usar un archivo de recursos" y "Aspectos internacionales" más adelante en este capítulo.
Documentos ActiveX Los documentos ActiveX (.dob) son similares a los formularios, pero se muestran en un explorador de Internet como Internet Explorer. Las ediciones Profesional y Empresarial de Visual Basic son capaces de crear documentos ActiveX.
Para obtener más información Para obtener más información acerca de los documentos ActiveX, vea "Crear componentes ActiveX" en la Guía de herramientas componentes, disponible en las ediciones Profesional y Empresarial.
Módulos de controles de usuario y de páginas de propiedades Los módulos de controles de usuario (.ctl) y de páginas de propiedades (.pag) son similares a los formularios, pero se usan para crear controles ActiveX y las páginas de
propiedades asociadas para mostrar propiedades en tiempo de diseño. Las versiones Profesional y Empresarial de Visual Basic pueden crear controles ActiveX.
Para obtener más información Para obtener más información acerca de la creación de controles ActiveX, vea "Crear un control ActiveX" en "Crear componentes ActiveX", dentro de la Guía de herramientas componentes , disponible en las ediciones Profesional y Estándar.
Componentes Además de archivos y módulos, también es posible agregar otro tipo de componentes a un proyecto.
Controles ActiveX Los controles ActiveX (extensión de nombre de archivo .ocx) son controles opcionales que se pueden agregar al cuadro de herramientas y se pueden usar en formularios. Cuando instala Visual Basic, los archivos que contienen los controles incluidos en Visual Basic se copian a un directorio común (el subdirectorio \Windows\System en Windows 95). Existen controles ActiveX adicionales disponibles en diversas fuentes. También puede crear sus propios controles mediante las ediciones Profesional y Empresarial de Visual Basic.
Para obtener más información Para obtener más información acerca del uso de los controles ActiveX incluidos, vea "Usar controles ActiveX" en la Guía de herramientas componentes, disponible en las ediciones profesional y empresarial.
Objetos insertables Los objetos insertables, como un objeto Hoja de cálculo de Microsoft Excel, son componentes que se pueden usar como bloques para generar soluciones integradas. Una solución integrada puede contener datos en diferentes formatos, como hojas de cálculo, mapas de bits y texto, creados por diferentes aplicaciones.
Para obtener más información Para obtener más información acerca del uso de objetos de otras aplicaciones, vea "Programar con componentes".
Referencias También puede agregar referencias a componentes ActiveX externos que se pueden usar en la aplicación. Para asignar referencias se usa el cuadro de diálogo Referencias, al que se tiene acceso mediante el comando Referencias del menú Proyecto .
Para obtener más información Para obtener más información acerca de referencias, vea "Usar objetos de otras aplicaciones" más adelante en este capítulo.
Diseñadores ActiveX Los diseñadores ActiveX son herramientas para diseñar clases a partir de las cuales es posible crear objetos. La interfaz de diseño para formularios es el diseñador
predeterminado. Puede haber disponibles otros diseñadores adicionales desde otros orígenes.
Para obtener más información Para obtener más información acerca de los diseñadores ActiveX, vea "Diseñadores ActiveX" en el capítulo 9,"Programar con objetos".
Controles estándar Los controles estándar los proporciona Visual Basic. Los controles estándar, como CommandButton (botón de comando) o Frame (marco), siempre están incluidos en el cuadro de herramientas, al contrario de lo que ocurre con los controles ActiveX y los objetos insertables, que se pueden agregar y quitar del cuadro de herramientas.
Para obtener más información Para obtener más información acerca de los controles estándar, vea "Formularios, controles y menús" y "Usar controles estándar de Visual Basic".
Crear, abrir y guardar proyectos Hay cuatro comandos del menú Archivo que permiten crear, abrir y guardar proyectos.
Comando de menú
Descripción
Nuevo proyecto
Cierra el proyecto actual y le pregunta si desea guardar los archivos modificados. Puede elegir un tipo de proyecto desde el cuadro de diálogo Nuevo proyecto . A continuación, Visual Basic crea un proyecto nuevo con un único archivo nuevo.
Abrir proyecto
Cierra el proyecto actual y le pregunta si desea guardar los cambios. A continuación, Visual Basic abre un proyecto existente, incluyendo los formularios, módulos y controles ActiveX enumerados en el archivo de proyecto (.vbp).
Guardar proyecto
Actualiza el archivo del proyecto actual y todos sus módulos de formulario, estándar y de clase.
Guardar como
proyecto Actualiza el archivo del proyecto actual, guardando el archivo de proyecto con un nombre que especifica el propio usuario. Visual Basic también le pide que guarde cualquier formulario o módulo que haya cambiado.
También es posible compartir archivos entre proyectos. Un archivo concreto, como un formulario, puede formar parte de varios proyectos. Los cambios que realice a un formulario o un módulo en un proyecto afectarán a todos los proyectos que compartan ese módulo.
Para obtener más información Para obtener más información acerca del uso compartido de archivos, vea "Agregar, quitar y guardar archivos" más adelante en este capítulo.
Trabajar con varios proyectos En las versiones Profesional y Empresarial de Visual Basic es posible tener más de un proyecto abierto a la vez. Esto es útil para generar y probar soluciones que contengan controles creados por el usuario u otros componentes. Cuando esté cargado más de un proyecto, el título de la ventana del Explorador de proyectos cambiará a Grupo de proyectos y se mostrarán los componentes de todos los proyectos abiertos.
Para agregar un proyecto adicional al grupo de proyectos actual 1. En el menú Archivo, elija Agregar proyecto . Aparecerá el cuadro de diálogo Agregar proyecto . 2. Seleccione un proyecto existente o un nuevo proyecto y elija Abrir.
Para quitar un proyecto del grupo de proyectos actual 1. Seleccione un proyecto o un componente de un proyecto en el Explorador de proyectos . 2. En el menú Archivo, elija Quitar proyecto .
Para obtener más información Para saber más detalles acerca del trabajo con múltiples proyectos, vea "Crear componentes ActiveX" en la Guía de herramientas componentes, disponible en las ediciones profesional y empresarial.
Agregar, quitar y guardar archivos Trabajar con archivos de un proyecto es similar a trabajar con los proyectos propiamente dichos.
Para agregar un archivo a un proyecto 1. Seleccione Proyecto , Agregar tipo_de_archivo (donde tipo_de_archivo es el tipo de archivo). Aparecerá el cuadro de diálogo Agregar tipo_de_archivo (figura 4.2). 2. Seleccione un tipo de archivo existente o uno nuevo y elija Abrir.
Figura 4.2 Cuadro de diálogo Agregar formulario
Cuando se agrega un archivo a un proyecto, simplemente se está incluyendo en el proyecto una referencia al archivo existente, no agregando una copia de un archivo. Por tanto, si efectúa cambios en un archivo y lo guarda, los cambios afectarán a cualquier proyecto que contenga dicho archivo. Para cambiar un archivo sin afectar a otros proyectos, seleccione el archivo en el Explorador de proyectos, elija Guardar archivo como en el menú Archivo y guarde el archivo con un nombre nuevo.
Nota Puede arrastrar y colocar archivos desde el Explorador de Windows, el Administrador de archivos o el Entorno de red a la ventana Proyecto para agregarlos al proyecto. También puede arrastrar y colocar archivos .ocx en el cuadro de herramientas para agregar controles nuevos. Para quitar un archivo de un proyecto 1. Seleccione el archivo en el Explorador de proyectos . 2. En el menú Proyecto , elija Quitar archivo. 3. El archivo se quitará del proyecto pero no del disco. Si quita un archivo de un proyecto, Visual Basic actualiza la información del archivo de proyecto al guardarlo. Sin embargo, si elimina un archivo desde fuera de Visual Basic, Visual Basic no podrá actualizar el archivo de proyecto; por tanto, cuando abra el proyecto, Visual Basic mostrará un mensaje de error indicando que falta un archivo.
Para guardar un único archivo sin guardar el proyecto 1. Seleccione el archivo en el Explorador de proyectos .
2. En el menú Archivo, elija Guardar archivo.
Combinar texto También puede insertar texto existente de otros archivos dentro de uno de sus módulos de código. Esto es útil para agregar una lista de constantes o para agregar fragmentos de código que haya guardado en archivos de texto.
Para insertar un archivo de texto en el código 1. En la ventana Proyecto, seleccione el formulario o el módulo en el que desea insertar código. 2. Elija el botón Ver código y mueva el cursor al lugar del editor de código donde desee insertar código. 3. En el menú Edición, elija Insertar archivo . 4. Seleccione el nombre del archivo de texto que desea insertar y elija Abrir.
Nota Si modifica archivos de código fuente de Visual Basic con un editor de código o de texto distinto de Visual Basic, tenga cuidado de no cambiar los valores del atributo VB_PredeclaredId. Si cambia este atributo es posible que genere graves problemas en las clases GlobalMultiUse y GlobalSingleUse. En general, no debe modificar atributos manualmente, si lo hace puede situar el módulo en un estado interno de inconsistencia.
Crear y ejecutar un archivo ejecutable En Visual Basic puede crear un archivo ejecutable (.exe) mediante el procedimiento siguiente.
Para crear un archivo ejecutable en Visual Basic 1. En el menú Archivo, elija Generar archivo .exe donde archivo es el nombre de aplicación para el proyecto. 2. Escriba un nombre de archivo o examine los directorios y seleccione un nombre de archivo ejecutable existente para reemplazarlo por una nueva versión. 3. Si hace clic en el botón Opciones también puede especificar una serie de detalles específicos de la versión del archivo ejecutable mediante el cuadro de diálogo Propiedades del proyecto . 4. Si desea modificar el número de versión del proyecto, establezca los números apropiados en Principal, Secundario y Revisión. Si selecciona Incremento automático, el número de Revisión se incrementará automáticamente cada vez que ejecute el comando Generar archivo .exe para este proyecto.
5. Para especificar un nombre nuevo para la aplicación, escriba un nombre nuevo bajo Aplicación, en el cuadro Título. Si desea especificar un icono nuevo, elija uno en la lista. 6. También puede especificar comentarios específicos de la versión sobre diversos aspectos en el cuadro Información de versión (comentarios, nombre de la organización, marcas comerciales legales, derechos de autor, etc.) si selecciona un tema del cuadro de lista y escribe la información en el cuadro de texto. 7. Elija Aceptar para cerrar el cuadro de diálogo Propiedades del proyecto y después elija Aceptar en el cuadro de diálogo Generar proyecto para compilar y vincular el archivo ejecutable. Puede iniciar el archivo ejecutable de la misma manera que cualquier aplicación Windows: haga doble clic en el icono del archivo ejecutable.
Nota La generación de un archivo ejecutable desde la línea de comandos en una sesión DOS puede ser útil cuando desee compilar un proyecto desde un programa. En un archivo por lotes, escriba: Vb6 /make nombre_proyecto[.vbp] [nombre_ejecutable] En nombre_proyecto, escriba el nombre del archivo de proyecto. Use la variable nombre_ejecutable para cambiar el nombre del archivo ejecutable resultante.
Compilación condicional La compilación condicional le permite compilar de forma selectiva ciertas partes del programa. Puede incluir características específicas del programa en diferentes versiones, como cambiar los filtros para mostrar fechas y datos monetarios de una aplicación distribuida en diferentes idiomas.
Para obtener más información Para aprender más acerca de la compilación condicional, vea "Usar la compilación condicional" en "Detalles de programación".
Definir opciones del proyecto Visual Basic permite personalizar cada proyecto estableciendo una serie de propiedades. Use el cuadro de diálogo Propiedades del proyecto , al que se tiene acceso mediante el comando Propiedades de proyecto del menú Proyecto . Los valores de las propiedades se guardan en el archivo de proyecto (.vbp). En la tabla siguiente se describen algunas opciones que puede establecer.
Opción
Descripción
Objeto inicial
Primer formulario que Visual Basic presenta en tiempo de ejecución o Sub Main ( ).
Nombre de proyecto
Identifica el proyecto en el código. No puede contener puntos (.) ni espacios en blanco, y no debe comenzar por caracteres no alfabéticos. Si es el nombre de una clase pública, el nombre de proyecto y el nombre de clase no pueden exceder de 37 caracteres.
Archivo de Ayuda
Nombre del archivo de Ayuda asociado con el proyecto.
Id. de contexto de la Ayuda Identificador de contexto del tema de Ayuda específico del proyecto al que se llama cuando el usuario hace clic en el botón "?" mientras la biblioteca de objetos de la aplicación está seleccionada en el Examinador de objetos. Descripción del proyecto
Nombre descriptivo del proyecto. Se presenta en los cuadros de diálogo Referencias y Examinador de objetos.
Hay disponibles otras muchas opciones, incluyendo las de compilar, componentes y múltiples procesos. Cuando esté preparado para tener acceso a algunas de las opciones más avanzadas, puede obtener más información en la Ayuda.
Para obtener más información Para aprender acerca de cómo establecer las opciones de entorno que afectan a todos los proyectos, vea "Desarrollar una aplicación con Visual Basic".
Estructura de una aplicación en Visual Basic Una aplicación no es más que un conjunto de instrucciones para que el equipo realice una o varias tareas. La estructura de una aplicación es la forma en que se organizan las instrucciones; es decir, dónde se almacenan las instrucciones y el orden en que se ejecutan. Las aplicaciones sencillas, como el ejemplo clásico "Hola mundo", tienen una estructura sencilla; la organización no es muy importante cuando sólo se tiene una línea de código. A medida que las aplicaciones se van haciendo más complejas, resulta obvia la necesidad de organizar o estructurar. Imagine el caos resultante si su aplicación se ejecutara en un orden aleatorio. Además de controlar la ejecución de una aplicación, la estructura es importante para el programador: ¿le resulta sencillo encontrar una instrucción determinada en la aplicación? Puesto que una aplicación de Visual Basic se basa en objetos, la estructura de su código se aproxima mucho a su representación física en pantalla. Por definición, los objetos contienen datos y código. El formulario que ve en la pantalla es una representación de las propiedades que definen su apariencia y su comportamiento intrínseco. Por cada formulario de una aplicación hay un módulo de formulario relacionado (con la extensión de nombre de archivo .frm) que contiene su código.
Figura 5.1 Un formulario y su módulo de formulario relacionado
Cada módulo de formulario contiene procedimientos de evento (secciones de código donde se colocan las instrucciones que se ejecutarán como respuesta a eventos específicos). Los formularios pueden contener controles. Por cada control de un formulario, existe el correspondiente conjunto de procedimientos de evento en el módulo de formulario. Además de procedimientos de evento, los módulos de formulario pueden contener procedimientos generales que se ejecutan como respuesta a una llamada desde cualquier procedimiento de evento. El código que no esté relacionado con un control o un formulario específico se puede colocar en un tipo diferente de módulo, un módulo estándar (.bas). Se deben colocar en un módulo estándar los procedimientos que se puedan usar como respuesta a eventos de diversos objetos, en lugar de duplicar el código en los procedimientos de evento de cada objeto. Se utiliza un módulo de clase (.cls) para crear objetos a los que se puede llamar desde procedimientos de la aplicación. Mientras que un módulo estándar sólo contiene código, un módulo de clase contiene código y datos (puede considerarse como un control sin representación física). Mientras que en "Administrar proyectos" se describen los componentes que puede agregar a una aplicación, este capítulo explica cómo escribir código en los distintos componentes que conforman una aplicación. De forma predeterminada, el proyecto contiene un único módulo de formulario. Puede agregar módulos adicionales de
formulario, clase y estándar, si es necesario. Los módulos de clase se describen en "Programar con objetos".
Trabajar con proyectos Cuando se desarrolla un aplicación, se trabaja con un archivo de proyecto para administrar todos los diferentes archivos que se crean. Un proyecto consta de:
Un archivo de proyecto que realiza el seguimiento de todos los componentes (.vbp) Un archivo para cada formulario (.frm). Un archivo de datos binarios para cada formulario que contiene datos sobre propiedades de controles del formulario (.frx). Estos archivos no se pueden modificar y los genera automáticamente cualquier archivo .frm que tenga propiedades en formato binario, como Picture o Icon.
Opcionalmente, un archivo para cada módulo de clase (.cls).
Opcionalmente, un archivo para cada módulo estándar (.bas).
Opcionalmente, uno o más archivos con controles ActiveX (.ocx).
Opcionalmente, un único archivo de recursos (.res).
El archivo de proyecto es simplemente una lista de todos los archivos y objetos asociados con el proyecto, así como información acerca de las opciones de entorno establecidas. Esta información se actualiza cada vez que se guarda el proyecto. Todos los archivos y objetos también se pueden compartir con otros proyectos. Cuando ha completado todos los archivos del proyecto puede convertir el proyecto en un archivo ejecutable (.exe): en el menú Archivo, elija el comando Generar proyecto.exe.
Nota Con las ediciones Profesional y Empresarial de Visual Basic también puede crear otro tipo de archivos ejecutables, como archivos .ocx y .dll. En las referencias de este capítulo se supone un proyecto .exe estándar; para obtener información adicional acerca de otros tipos de proyectos, vea la Guía de herramientas componentes , disponible en las ediciones Profesional y Estándar. Para obtener más información Para obtener más detalles acerca de la creación de ejecutables, vea "Crear y ejecutar un archivo ejecutable" más adelante en este capítulo. Para obtener información acerca de archivos de datos binarios y archivos de proyecto, vea "Especificaciones, limitaciones y formatos de archivos de Visual Basic".
Explorador de proyectos Cuando se crean, agregan o quitan archivos modificables de un proyecto, Visual Basic refleja los cambios en la ventana Explorador de proyectos, que contiene una lista
actualizada de los archivos del proyecto. La ventana Explorador de proyectos de la figura 4.1 muestra algunos tipos de archivos que puede incluir un proyecto de Visual Basic.
Figura 4.1 Ventana del Explorador de proyectos
Archivos de proyecto Cada vez que guarda un proyecto, Visual Basic actualiza el archivo de proyecto (.vbp). Un archivo de proyecto contiene la misma lista de archivos que aparece en la ventana del Explorador de proyectos, así como referencias a los controles ActiveX y objetos insertables que se usan en el proyecto. Para abrir un archivo de proyecto existente, haga doble clic en el icono, elija el comando Abrir proyecto en el menú Archivo o arrastre el archivo y colóquelo en la ventana del Explorador de proyectos.
Para obtener más información El formato específico de la información almacenada en el archivo .vbp se describe en "Especificaciones, limitaciones y formatos de archivo de Visual Basic".
Crear y ejecutar un archivo ejecutable En Visual Basic puede crear un archivo ejecutable (.exe) mediante el procedimiento siguiente.
Para crear un archivo ejecutable en Visual Basic 1. En el menú Archivo, elija Generar archivo .exe donde archivo es el nombre de aplicación para el proyecto. 2. Escriba un nombre de archivo o examine los directorios y seleccione un nombre de archivo ejecutable existente para reemplazarlo por una nueva versión.
3. Si hace clic en el botón Opciones también puede especificar una serie de detalles específicos de la versión del archivo ejecutable mediante el cuadro de diálogo Propiedades del proyecto . 4. Si desea modificar el número de versión del proyecto, establezca los números apropiados en Principal, Secundario y Revisión. Si selecciona Incremento automático, el número de Revisión se incrementará automáticamente cada vez que ejecute el comando Generar archivo .exe para este proyecto. 5. Para especificar un nombre nuevo para la aplicación, escriba un nombre nuevo bajo Aplicación, en el cuadro Título. Si desea especificar un icono nuevo, elija uno en la lista. 6. También puede especificar comentarios específicos de la versión sobre diversos aspectos en el cuadro Información de versión (comentarios, nombre de la organización, marcas comerciales legales, derechos de autor, etc.) si selecciona un tema del cuadro de lista y escribe la información en el cuadro de texto. 7. Elija Aceptar para cerrar el cuadro de diálogo Propiedades del proyecto y después elija Aceptar en el cuadro de diálogo Generar proyecto para compilar y vincular el archivo ejecutable. Puede iniciar el archivo ejecutable de la misma manera que cualquier aplicación Windows: haga doble clic en el icono del archivo ejecutable.
Nota La generación de un archivo ejecutable desde la línea de comandos en una sesión DOS puede ser útil cuando desee compilar un proyecto desde un programa. En un archivo por lotes, escriba: Vb6 /make nombre_proyecto[.vbp] [nombre_ejecutable] En nombre_proyecto, escriba el nombre del archivo de proyecto. Use la variable nombre_ejecutable para cambiar el nombre del archivo ejecutable resultante.
Compilación condicional La compilación condicional le permite compilar de forma selectiva ciertas partes del programa. Puede incluir características específicas del programa en diferentes versiones, como cambiar los filtros para mostrar fechas y datos monetarios de una aplicación distribuida en diferentes idiomas.
Para obtener más información Para aprender más acerca de la compilación condicional, vea "Usar la compilación condicional" en "Detalles de programación".
Especificaciones, limitaciones y de archivos de Visual Basic
En este apéndice se describen los requisitos de sistema, las limitaciones de un proyecto de Visual Basic, los tipos de archivos que se pueden incluir en el proyecto de Visual Basic y las descripciones de los archivos de formulario (.frm) y de proyecto (.vbp).
Nota A pesar de que muchas de estas limitaciones se describen en términos de un número específico, tenga en cuenta que otras condiciones (como la memoria disponible y los recursos del sistema) pueden imponer una restricción antes de que se llegue a ese límite.
Requisitos del sistema para aplicaciones de Visual Basic Para las aplicaciones de Visual Basic se requiere el siguiente hardware y software:
Microprocesador Pentium® 90MHz o superior. Pantalla VGA de 640x480 o de resolución superior compatible con Microsoft Windows.
24 MB de RAM para Windows 95, 32 MB para Windows NT.
Microsoft Windows NT 3.51 o posterior, o Microsoft Windows 95 o posterior.
Microsoft Internet Explorer versión 4.01 o posterior (versión 4.01 Service Pack 1 o posterior para programadores de aplicaciones DHTML y 4. x para los usuarios finales de dichas aplicaciones). Requisitos de espacio en disco duro: Edición Estándar: instalación típica 48MB, instalación completa 80MB.
Edición Profesional: instalación típica 48MB, instalación completa 80MB. Edición Empresarial: instalación típica 128MB, instalación completa 147MB.
Componentes adicionales (si son necesarios): MSDN (para documentación): 67MB, Internet Explorer 4.x: aproximadamente 66MB. CD-ROM (no se supone soporte para MS-DOS).
Limitaciones de los proyectos Un único proyecto puede contener hasta 32.000 "identificadores" (cualquier palabra clave no reservada), que incluyen entre otros formularios, controles, módulos, variables, constantes, procedimientos, funciones y objetos. Observe que el número real de identificadores se limita a la memoria disponible. Los nombres de variables en Visual Basic no pueden tener más de 255 caracteres y los nombres de formularios, controles, módulos y clases pueden tener un máximo de 40 caracteres. Visual Basic no impone ningún límite en cuanto al número de objetos distintos de un proyecto.
Formatos de archivos de un proyecto Microsoft Visual Basic utiliza y crea una serie de archivos tanto en tiempo de diseño como en tiempo de ejecución. Los archivos que el proyecto o la aplicación requerirán dependen de su alcance y funcionalidad.
Extensiones de archivos de proyecto Visual Basic crea varios archivos cuando se crea y compila un proyecto. Estos se pueden dividir como sigue: tiempo de diseño, otros desarrollos y tiempo de ejecución. Los archivos de tiempo de diseño son los ladrillos de su proyecto: por ejemplo, módulos de Basic (.bas) y módulos de formulario (.frm). Otros procesos y funciones del entorno de desarrollo de Visual Basic crean diversos archivos: por ejemplo, archivos de dependencias del Asistente de empaquetado y distribución (.dep).
Archivos varios y de tiempo de diseño La siguiente tabla muestra todos los archivos de tiempo de diseño y otros archivos que se pueden crear al desarrollar una aplicación:
Extensión
Descripción
.bas
Módulo de Basic
.cls
Módulo de clase
.ctl
Archivo de control de usuario
.ctx
Archivo binario de control de usuario
.dca
Caché de diseñador activo
.ddf
Archivo de información CAB del Asistente de empaquetado y distribución
.dep
Archivo de dependencias del Asistente de empaquetado y distribución
.dob
Archivo de formulario de documento ActiveX
.dox
Archivo binario de formulario de documento ActiveX
.dsr
Archivo de diseñador activo
.dsx
Archivo binario de diseñador activo
.dws
Archivo de secuencia de guiones del Asistente para despliegue
.frm
Archivo de formulario
.frx
Archivo binario de formulario
.log
Archivo de registro de errores de carga
.oca
Archivo de caché de biblioteca de tipos de controles
.pag
Archivo de página de propiedades
.pgx
Archivo binario de página de propiedades
.res
Archivo de recursos
.tlb
Archivo TypeLib de Automatización remota
.vbg
Archivo de proyecto de grupo de Visual Basic
.vbl
Archivo de control de licencia
.vbp
Archivo de proyecto de Visual Basic
.vbr
Archivo de registro de Automatización remota
.vbw
Archivo de espacio de trabajo de proyecto de Visual Basic
.vbz
Archivo de inicio del Asistente
.wct
Plantilla HTML de clase de Web.
Archivos de tiempo de ejecución Al compilar la aplicación, todos los archivos necesarios de tiempo de ejecución se incluyen en los archivos ejecutables de tiempo de ejecución. La siguiente tabla muestra los archivos de tiempo de ejecución:
Extensión Descripción .dll
Componente ActiveX en proceso
.exe
Archivo ejecutable o componente ActiveX
.ocx
Control ActiveX
.vbd
Archivo de estado de documento ActiveX
.wct
Plantilla HTML de clase de Web
Agregar controles a un proyecto Es posible personalizar, para cada proyecto, el conjunto de controles disponibles en el cuadro de herramientas. Cualquier control proporcionado debe estar en el cuadro de herramientas para que se pueda agregar a un formulario del proyecto. El conjunto básico de controles estándar que siempre aparece en el cuadro de herramientas se describe en "Formularios, controles y menús".
Agregar controles ActiveX a un proyecto Puede agregar controles ActiveX y objetos insertables a un proyecto si los agrega desde el cuadro de herramientas.
Para agregar un control al cuadro de herramientas de un proyecto 1. En el menú Proyecto , elija Componentes. Aparecerá el cuadro de diálogo Componentes, tal como se muestra en la figura 4.3. Los elementos mostrados en este cuadro de diálogo incluyen todos los controles ActiveX registrados, objetos insertables y diseñadores ActiveX. 2. Para agregar un control (extensión de nombre de archivo .ocx) o un objeto insertable al cuadro de herramientas, active la casilla de verificación que hay a la izquierda del nombre del control deseado. Para ver los controles con extensiones de archivo .ocx, seleccione la ficha Controles. Para ver objetos insertables, como un gráfico de Microsoft Excel, seleccione la ficha Objetos insertables . 3. Elija Aceptar para cerrar el cuadro de diálogo Componentes. Todos los controles ActiveX que haya seleccionado aparecerán ahora en el cuadro de herramientas.
Figura 4.3 Cuadro de diálogo Componentes
Para agregar controles ActiveX al cuadro de diálogo Componentes, elija el botón Examinar y busque en otros directorios archivos con la extensión .ocx. Cuando agregue un control ActiveX a la lista de controles disponibles, Visual Basic activará automáticamente su casilla de verificación.
Nota Cada control ActiveX viene acompañado de un archivo con extensión .oca. Este archivo almacena información de biblioteca de tipos y otros datos específicos del control. Los archivos .oca se almacenan habitualmente en el mismo directorio que los controles ActiveX y se vuelven a crear cuando sea necesario (los tamaños y las fechas de los archivos pueden cambiar).
Quitar controles de un proyecto Para quitar un control de un proyecto 1. En el menú Proyecto , elija Componentes. Aparecerá el cuadro de diálogo Componentes. 2. Desactive la casilla de verificación que hay junto al control que desea quitar. El icono del control desaparecerá del cuadro de herramientas.
Nota No puede quitar ningún control del cuadro de herramientas si una instancia de ese control se está usando en cualquier formulario del proyecto.
Usar objetos de otras aplicaciones También puede usar objetos de otras aplicaciones, como los incluidos en la biblioteca de objetos de Microsoft Excel, ya sea como controles del cuadro de herramientas o como objetos programables en el código. Para agregar objetos al cuadro de herramientas, vea "Agregar controles a un proyecto". Para que los objetos de otra aplicación estén disponibles en el código, pero no como controles, defina una referencia a la biblioteca de objetos de esa aplicación.
Para agregar una referencia a la biblioteca de objetos de otra aplicación 1. En el menú Proyecto , elija Referencias. Aparecerá el cuadro de diálogo Referencias, como se muestra en la figura 4.4. 2. Active la casilla de verificación correspondiente a la referencia que desea agregar al proyecto. Para agregar referencias a aplicaciones no enumeradas en el cuadro de diálogo Referencias, elija el botón Examinar y seleccione la aplicación. 3. Elija Aceptar para agregar al proyecto las referencias seleccionadas.
Figura 4.4 Cuadro de diálogo Referencias
Si no va a usar ningún objeto de una biblioteca a la que se hace referencia, es conveniente desactivar la casilla de verificación de dicha referencia para reducir al mínimo el número de referencias a objetos que Visual Basic debe resolver reduciendo así el tiempo de compilación del proyecto. Una vez que ha definido las referencias a las bibliotecas de objetos que desea, puede buscar un objeto específico, junto con sus métodos y propiedades, en el Examinador de objetos; para ello, elija Examinador de objetos en el menú Ver. Puede usar en el código cualquier objeto enumerado en el Examinador de objetos.
Para obtener más información Para obtener información acerca del Examinador de objetos, vea "Buscar y examinar objetos" en "Programar con objetos".
Usar un archivo de recursos Un archivo de recursos le permite reunir en un único lugar todo el texto y todos los mapas de bits específicos de una versión para una aplicación. Esto puede incluir declaraciones de constantes, iconos, texto de pantalla y otro material que pueda cambiar entre versiones traducidas o entre revisiones o configuraciones específicas.
Para agregar un archivo a un proyecto 1. En el menú Proyecto , elija Agregar archivo . Aparecerá el cuadro de diálogo Agregar archivo . 2. Seleccione un archivo de recurso existente (.res) y elija Abrir.