You are on page 1of 627

APRENDA VISUAL BASIC

PRACTICANDO

























APRENDA VISUAL BASIC
PRACTICANDO
José Felipe Ramírez Ramírez
Master en Informática Administrativa,
Catedrático de la Facultad de Contaduría Pública y Administración,
Universidad Autónoma de Nuevo León, México
Revisión técnica:
Lic. José Luis Ramos
Coordinador de la Carrera de Informática Administrativa, Facultad de Contaduría
Pública y Administración, Universidad Autónoma de Nuevo León, México

Pearson
Educación
MÉXICO • ARGENTINA • BRASIL • COLOMBIA • COSTA RICA • CHILE
ESPAÑA • GUATEMALA • PERÚ • PUERTO RICO • VENEZUELA



















/ Datos de catalogación bibliográfica
RAMÍREZ RAMÍREZ, JOSÉ
FELIPE Aprenda Visual Basic
practicando
PEARSON EDUCACIÓN. México, 2001
ISBN: 970-26-0285-8
Área: Universitarios
Formato: 18.5x23.5cm Páginas: 848
Editor: José Luis Vázquez Chavarría
e-mail: luis.vazquez@pearsoned.com
Editor de desarrollo: Amonio Nuñez Ramos
Supervisor de producción: José D. Hernández
Garduño
Diseño de portada: Iliana H. González Villafán
PRIMERA EDICIÓN. 2001
D-R, © 2001 por Pearson Educación de
México, S.A. de C.V. Calle 4 No, 25-
2do. Piso
Fracc. Industrial Alce Blanco 53370 Naucalpan de
Juárez, Edo. de México E-mail:
editorial.universidades@pearsoned.com
Cámara Nacional de la Industria Editorial Mexicana. Registro No. 1031

Reservados todos los derechos. Ni la totalidad ni parte de esta publicación pueden
reproducirse, registrarse o transmitirse, por un sistema de recuperación de
información, en ninguna forma ni por ningún medio, sea electrónico, mecánico.
fotoquímico, magnético o electro óptico, por fotocopia, grabación o cualquier otro.
sin permiso previo por escrito del editor.
El préstamo, alquiler o cualquier otra forma de cesión de uso de este ejemplar
requerirá también la autorización del editor o de sus representantes.
ISBN: 970-26-0285-8
Impreso en México- Primea in México
1234567890-03 02 01
Pearson
Educación














A Adriana, mi esposa,
porque ama mis propiedades,
hace mejores todos mis eventos
y motiva todos mis métodos.



















CONTENIDO
____________________________________________________________________

Contenido ..........................................................................................................................................vi
índice de prácticas .............................................................................................................................xv
Lo inesperado ....................................................................................................................................xx
Prólogo ..............................................................................................................................................xxii
Forma y contenido del libro .............................................................................................................xxiii
Agradecimientos...............................................................................................................................xxvii

Parte 1: Entorno Integrado de Desarrollo
Capítulo 1: Visual Basic como plataforma de desarrollo ................................................. 3
Objeto de la programación ...................................................................................................................... 4
Visual Basic: más que un lenguaje de programación ............................................................................. 5
Entorno Integrado de Desarrollo ............................................................................................................ 6
Ediciones de Visual Basic ........................................................................................................................ 8
Elementos del IDE .................................................................................................................................. 9
La barra de menús ................................................................................................................................... 12
La barra de herramientas ......................................................................................................................... 12
Formulario (Form) .................................................................................................................................. 13
Modos de trabajo con formularios: SD1 y MDI ..................................................................................... 13
Tecnología orientada a objetos y Visual Basic ....................................................................................... 16
Controles ................................................................................................................................................. 18
Clase ........................................................................................................................................................ 18
Objetos .................................................................................................................................................... 18
Cuadro de herramientas .......................................................................................................................... 19
Propiedades ............................................................................................................................................. 23
Métodos .................................................................................................................................................. 24
Ejemplificación de objeto - propiedad - método .................................................................................... 24
Explorador de proyectos ......................................................................................................................... 25
Tiempos de desarrollo de Visual Basic ................................................................................................... 27
Ventana Propiedades ............................................................................................................................... 28
Ventana Posición del formulario ............................................................................................................. 31
Pasos para crear una aplicación en Visual Basic ..................................................................................... 32
Resumen................................................................................................................................................... 33
Algunas respuestas a los ejercicios ........................................................................................................ 34

Capitulo 2: Creación de la interfaz de usuario ............................................................... 35
El punto de partida: ¿Qué desea hacer? .................................................................................................. 36
Paso 1: Crear la interfaz de usuario .................................................................................................... 37
























Contenido vii

Inserción de objetos............................................................................................................................... 37
Propiedades de posición y dimensión .................................................................................................. 41
Organización de los objetos en el formulario ...................................................................................... 48
Cómo establecer las aplicaciones para diferentes resoluciones de monitores ..................................... 52
Resumen ....................................................................................................................................................... 55
Algunas respuestas a los ejercicios ..................................................................................................... 56

Capítulo 3: Cómo establecer las propiedades de los objetos .............................................. 57
Consideraciones de diseño en Visual Basic .......................................................................................... 58
Paso 2: Establecer las propiedades de los objetos ....................................................................................... 59
Validar que ya se tienen lodos los objetos que se requieren en el formulario..................................... 59
Cómo asignar el nombre adecuado a cada uno de los objetos .......................................................... 62
Cómo establecer las propiedades de apariencia y comportamiento .................................................. 67
Tablas de objetos y propiedades ........................................................................................................ 73
Resumen ..................................................................................................................................................... 74
Capítulo 4: Escritura del código de los eventos ................................................................... 75
Paso 3: Escribir el código de los eventos .................................................................................................... 76
El editor de código de Visual Basic ............................................................................................................ 76
Elementos de la ventana Código .......................................................................................................... 79
Caracteres especiales ............................................................................................................................ 81
Asistencia en la edición de código ....................................................................................................... 84
El evento predeterminado de los objetos............................................................................................... .84
Convenciones para la codificación ....................................................................................................... .94
Especificaciones de codificación ........................................................................................................... 96
¿Qué hacer con los procedimientos de evento sin código? .................................................................... .97
Resumen ...................................................................................................................................................... 98
Algunas respuestas a los ejercicios ..................................................................................................... 98
Capítulo 5: Cómo guardar y ejecutar aplicaciones ............................................................. 101
¿Cómo se almacena su trabajo en Visual Basic? ......................................................................................... 102
Cómo guardar aplicaciones .......................................................................................................................... 103
Recomendaciones para nombrar archivos en Visual Basic .................................................................... 107
Cómo ejecutar su aplicación ......................................................................................................................... 108
Depuración y control del programa............................................................................................................... 114
Indicadores de margen ............................................................................................................................. 115
La ventana Código al depurar una aplicación ..........................................................................................117
Ejecución paso a paso .............................................................................................................................. 118
Puntos de interrupción ............................................................................................................................. 119
Cómo generar un archivo ejecutable (EXE) ................................................................................................. 120
Forma esquemática de presentación de aplicaciones ................................................................................... 123
Resumen ...................................................................................................................................................... 127
Algunas respuestas a los ejercicios .......................................................................................................... 128


Parte 2: Elementos de programación
Capítulo 6: Variables y tipos de datos ...................................................................................................... 131
MsgBox .................................................................................................................................................. 132
Constantes de Visual Basic .................................................................................................................... 135


























viii Contenido
InputBox .................................................................................................................................................... 139
Declaración de variables ................................................................................................................................ 142
Tipos de datos ................................................................................................................................................ 143
DIM: declaración de variables de memoria ................................................................................................... 145
Alcance .......................................................................................................................................................... 147
Nombre .......................................................................................................................................................... 148
Constantes ...................................................................................................................................................... 150
Matrices .......................................................................................................................................................... 150
Funciones de límite de posiciones .................................................................................................................. 153
Option Explicit ......................................................................................................................................... 155
Conversión de datos ........................................................................................................................................ 158
La función Format ........................................................................................................................................ 161
Resumen ......................................................................................................................................................... 166
Algunas respuestas a los ejercicios ....................................................................................................... 166

Capítulo 7: Operadores y estructuras de control ...................................................................... 169
Operadores aritméticos .................................................................................................................................... 170
Operadores comparativos ................................................................................................................................ 172
Código ASCII ......................................................................................................................................... 173
Operadores lógicos .......................................................................................................................................... 174
Prioridad entre operadores ............................................................................................................................... 177
Instrucción If (condicional) ........................................................................................................................... 178
Select Case ................................................................................................................................................ 184
For Next ....................................................................................................................................................... 186
Do Loop .......................................................................................................................................................... 189
Resumen .......................................................................................................................................................... 191
Algunas respuestas a los ejercicios ...................................................................................................... 191

Capítulo 8: Funciones de manipulación de datos ......................................................................193
Qué son las funciones .......................................................................................................................................194
Funciones de fecha y hora ................................................................................................................................ 195
Funciones de manipulación de cadenas (string) ......................................................................................... 202
Funciones numéricas ........................................................................................................................................ 210
Funciones de decisión ...................................................................................................................................... 213
Funciones de uso específico ............................................................................................................................. 216
Funciones financieras ................................................................................................................................ 216
Funciones trigonométricas ........................................................................................................................ 217
Resumen ........................................................................................................................................................... 218

Capítulo 9: Procedimientos y funciones definidas por el usuario .......................................... 219
Procedimientos ................................................................................................................................................. 220
Ejecución de procedimientos ............................................................................................................... 221
Cómo agregar procedimientos en Visual Basic ................................................................................... 222
Procedimientos que no utilizan argumentos y no devuelven valores ................................................. 224
Procedimientos que no utilizan argumentos y sí devuelven valores .................................................. 225
Procedimientos que utilizan argumentos ........................................................................................... 227
Especificación de argumentos opcionales ......................................................................................... 229
Valores predeterminados para argumentos opcionales ...................................................................... 232
Funciones con número incierto de argumentos ................................................................................ 233
Resumen ......................................................................................................................................................... 237
























Contenido jx
Parte 3: Controles gráficos y programación orientada a eventos
Capítulo 10: Controles básicos para la introducción de datos ................................................................ 241
Controles básicos para el acceso de datos ..................................................................................................... 242
Label....................................................................................................................................................... 242
TextBox.................................................................................................................................................. 243
CommandButton...................................................................................................................... 244
Enfoque ......................................................................................................................................................... 249
La tecla presionada: evento KeyPress .................................................................................................. 259
Resumen ........................................................................................................................................................ 262
Capítulo 11: Programación orientada a eventos ........................................................................................ 263
Eventos y su clasificación ............................................................................................................................... 264
Argumentos implícitos ............................................................................................................................. 266
Resumen de las categorías de eventos, consideradas de uso general .............................................................. 266
TipoClic .................................................................................................................................................. 267
Tipo Cambios ......................................................................................................................................... 268
Tipo Enfoque .......................................................................................................................................... 270
Tipo Ratón .............................................................................................................................................. 284
Prioridad de los eventos .................................................................................................................................. 294
Resumen .......................................................................................................................................................... 303
Capítulo 12: Controles contenedores y controles de selección .................................................................. 305
Objetos contenedores ...................................................................................................................................... 306
Frame ............................................................................................................................................................. 306
CheckBox ...................................................................................................................................................... 312
Matriz de controles .......................................................................................................................................... 316
Colores en Visual Basic utilizando RGB y QBColor .................................................................................... 323
RGB ........................................................................................................................................................... 323
QBColor ............................................................................................................................................... 324
OptionButton ............................................................................................................................................ 325
HscrollBary y ScrollBar ..................................................................................................................... 330
Resumen ........................................................................................................................................................... 337
Capítulo 13: Controles de listas desplegables .............................................................................................. 339
Concepto de colección ..................................................................................................................................... 340
Listas desplegables: ListBox y ComboBox ................................................................................................ 342
Cómo agregar y eliminar opciones de las listas desplegables ......................................................................... 343
Método Additem ..................................................................................................................................... 343
Propiedad ListCount ............................................................................................................................ 344
Propiedad List ........................................................................................................................................ 345
Propiedades Selected y Listindex ................................................................................................. 346
Método Removeltem .............................................................................................................................. 347
Método Clear .......................................................................................................................................... 348
Resumen ........................................................................................................................................................... 368
Capítulo 14: Editor de menús y manejo del Portapapeles ......................................................................... 371
El Editor de menús .......................................................................................................................................... 372
Cómo invocar el Editor de menús .......................................................................................................... 373
























x Contenido
Manejo del Portapapeles ............................................................................................................................... 385
Len: longitud del texto .......................................................................................................................... 386
Propiedades del objeto fuente: SelStart, SelLength y SelText .............................................. 386
Métodos del objeto Clipboard: Clear, SetText y GetText .......................................................... 387
Resumen ........................................................................................................................................................ 393
Capítulo 15: Manejo de imágenes .............................................................................................................. 395
Controles básicos para mostrar imágenes ....................................................................................................... 396
Image .............................................................................................................................................................. 396
LoadPicture ......................................................................................................................................... 396
PictureBox ................................................................................................................................................. 400
Adición de componentes al proyecto .............................................................................................................. 405
Almacenamiento de imágenes ......................................................................................................................... 409
ImageList ( Microsoft Windows Common Controls 6.0) ...................................................................... 410
Resumen .......................................................................................................................................................... 419
Algunas respuestas a los ejercicios ............................................................................................................. 419
Capítulo 16; Arrastrar y colocar ................................................................................................................. 421
Arrastrar y colocar .......................................................................................................................................... 422
Estados de transición y punteros predefinidos ................................................................................................ 432
Punteros predefinidos del entorno de Windows ..................................................................................... 433
Manejo en modo manual de arrastrar y colocar .............................................................................................. 435
Resumen .......................................................................................................................................................... 441
Capítulo 17: Control del tiempo .................................................................................................................. 443
Control básico para controlar el tiempo .......................................................................................................... 444
Timer ...................................................................................................................................................... 444
Resumen .......................................................................................................................................................... 449
Capítulo 18: Manejo del sistema de archivos ............................................................................................. 451
El sistema de archivos ..................................................................................................................................... 452
Controles básicos para el manejo del sistema de archivos .............................................................................. 452
DriveListBox ............................................................................................................................................ 452
DirListBox ................................................................................................................................................. 453
FileListBox .............................................................................................................................................. 453
Manejo del objeto FileSystem ................................................................................................................... 461
Manipulación de subdirectorios ................................................................................................................... 461
Manipulación de archivos ............................................................................................................................ 468
Resumen ........................................................................................................................................................... 474
Capítulo 19: Cuadros de diálogo comunes ...................................................................................................477
Cuadros de diálogo comunes ............................................................................................................................478
CommonDialog ( Microsoft Common Dialog Control 6.0) ..................................................................... 478
Indicadores ................................................................................................................................................... 480
Manejo de errores ......................................................................................................................................... 481
Cuadro de diálogo Color ............................................................................................................................. 482
Cuadro de diálogo Fuente ............................................................................................................................ 485
Cuadro de diálogo Imprimir ........................................................................................................................ 491
Cuadro de diálogo Abrir/Guardar como ...................................................................................................... 497
Resumen .......................................................................................................................................................... 504


























Contenido xi
Capítulo 20: Cómo trabajar en una interfaz de múltiples documentos ............................................... 505
Fundamentos del entorno MDI .................................................................................................................. 506
Limitaciones que implica el uso de un formulario MDI ....................................................................... 508
Cómo preparar su aplicación para compilación y distribución ................................................................... 511
Resumen ...................................................................................................................................................... 512
Capítulo 21: Controles ActiveX para mejorar la interfaz ..................................................................... 513
Controles comunes de Windows ................................................................................................................. 514
ProgressBar ( Microsoft Windows Common Controls 6.0) ....................................................... 514
TreeView ( Microsoft Windows Common Controls 6.0) ............................................................. 518
Cómo agregar opciones a un sistema TreeView ............................................................................... 519
StatusBar ( Microsoft Windows Common Controls 6.0) ............................................................ 526
Cómo agregar opciones a un objeto basado en StatusBar .............................................................. 526
ToolBar ( Microsoft Windows Common Controls 6.0) ................................................................. 529
Cómo agregar opciones a un objeto basado en StatusBar .............................................................. 530
Resumen ...................................................................................................................................................... 537


Parte 4: Archivos y bases de datos
Capítulo 22: Bases de datos y DAO ......................................................................................................... 541
Conceptos de bases de datos ....................................................................................................................... 542
Base de datos, tabla, registro y campo ................................................................................................... 542
Clave primaria ........................................................................................................................................ 543
Clave externa y relaciones ...................................................................................................................... 544
Integridad referencial .............................................................................................................................. 545
Índices ..................................................................................................................................................... 545
El motor de base de datos Microsoft Jet ...................................................................................................... 550
La interfaz de usuario y el código de aplicaciones ................................................................................ 550
El motor de base de datos ....................................................................................................................... 551
El almacén de datos ................................................................................................................................ 551
DAO ............................................................................................................................................................. 551
Clases, objetos y colecciones ................................................................................................................. 554
Divisiones de la programación de bases de datos .................................................................................. 555
Lenguaje de Definición de Datos ........................................................................................................... 555
Lenguaje de Manipulación de Datos ...................................................................................................... 556
Resumen ...................................................................................................................................................... 556
Algunas respuestas a los ejercicios ........................................................................................................ 556
Capítulo 23: Lenguaje de Definición de Datos y DAO ........................................................................... 559
Lenguaje de Definición de Datos ................................................................................................................. 560
Tipos de objetos en DAO ........................................................................................................................ 561
Sintaxis para el uso de colecciones ........................................................................................................ 562
Variables objeto ...................................................................................................................................... 563
Espacio de trabajo e integración de la base de datos .............................................................................. 570
Métodos Create ................................................................................................................................... 570
Bloque With... End With ................................................................................................................ 573
Elementos requeridos para agregar objetos ............................................................................................ 576


























xii Contenido
Cómo trabajar con las colecciones de DAO ................................................................................................... 587
Resumen .......................................................................................................................................................... 594
Algunas respuestas a los ejercicios ........................................................................................................ 595
Capítulo 24: Lenguaje de Manipulación de Datos y DAO ........................................................................ 597
Lenguaje de Manipulación de Datos .............................................................................................................. 598
Validaciones a nivel tabla ....................................................................................................................... 599
Validaciones a nivel base de datos .......................................................................................................... 599
Operaciones básicas de manipulación de bases de datos ............................................................................... 600
Tareas de apertura de base de datos ................................................................................................................ 601
OpenDatabase ....................................................................................................................... 601
OpenRecordset ..................................................................................................................... 602
Tipos de Recordset ............................................................................................................... 603
Close ...................................................................................................................................... 605
Tareas de escritura de datos (partel) ................................................................................................................ 605
AddNew y actualización al almacén de datos .......................................................................................... 606
Tareas de búsqueda de datos (parte 1) ............................................................................................................. 609
Seek ........................................................................................................................................................ 609
Propiedad Index ..................................................................................................................................... 609
Propiedad NoMatch ................................................................................................................................ 610
Tareas de escritura de datos (parte 2) .............................................................................................................. 610
Edit ........................................................................................................................................................ 611
Update .................................................................................................................................................... 611
Delete .................................................................................................................................................... 612
Técnica RAR ................................................................................................................................................... 613
Tareas de movimiento entre datos ................................................................................................................... 622
Tareas de búsqueda de datos (parte 2) ............................................................................................................. 627
Condición ................................................................................................................................................... 628
Métodos Find ........................................................................................................................................... 629
Resumen ........................................................................................................................................................... 636
Capítulo 25: Controles Data y FlexGrid ................................................................................................ 639
Control Data .................................................................................................................................................... 640
Objetos vinculados a campos de base de datos ........................................................................................ 641
FlexGrid ...................................................................................................................................................... 646
Consideraciones de incompatibilidad entre Access 97 y Access 2000 ........................................................... 649
Resumen .......................................................................................................................................................... 655
Capítulo 26: Bases de datos multiusuario usando DAO ........................................................................... 657
La necesidad de capacidades multiusuario ..................................................................................................... 658
Cómo abrir la base de datos en modo compartido ................................................................................... 658
Cómo abrir los Recordsets en modo compartido .............................................................................. 659
Problemas al escribir y concepto de bloqueo ........................................................................................... 660
Bloqueo pesimista y optimista ....................................................................................................................... 662
Bloqueo pesimista .................................................................................................................................... 662
Bloqueo optimista .................................................................................................................................... 663
Aclaración del "bloqueo de registros" ..................................................................................................... 664
Manejo de errores para el modo multiusuario ................................................................................................ 665
On Error ............................................................................................................................... 665
Etiquetas ................................................................................................................................. 665
GoTo ........................................................................................................................................ 665

























Contenido xiii
Resume ............................................................................................................................................... 666
Err y Error ....................................................................................................................................... 666
Exit Sub ............................................................................................................................................. 666
Resumen ....................................................................................................................................... 672

Capítulo 27: Archivos planos para transferencia de datos ...................................................... 675
Los archivos planos siguen vigentes ............................................................................................................... 676
Creación y lectura de archivos planos ............................................................................................................. 677
Open ........................................................................................................................................................ 678
FreeFile ............................................................................................................................................... 678
Tipos de datos definidos por el usuario .................................................................................................... 679
Cómo escribir en un archivo ..................................................................................................................... 679
Input ...................................................................................................................................................... 684
Resumen .......................................................................................................................................................... 688

Capítulo 28: Manejo de bases de datos corporativas usando ADO ........................................ 689
Bases de datos más allá de la computadora personal ...................................................................................... 690
Objeto de Datos ActiveX .......................................................................................................................... 690
Pubs: La base de datos de ejemplo ............................................................................................................ 692
Ejecución front - end a través de ADO ..................................................................................................... 693
Conexión a una base de datos corporativa mediante ADO ...................................................................... 694
Peticiones al servidor de bases de datos utilizando ADO ........................................................................ 701
DataGr-id ( Microsoft DataGrid Control OLEDB) ................................................................................... 704
SQL............................................................................................................................................................... 709
DML usando ADO ........................................................................................................................................ 720
ADO a través de ODBC ................................................................................................................................ 732
Conexión a través de DSN almacenado en el Registro ........................................................................... 733
Conexión a través de DSN almacenado en archivo DSN ....................................................................... 733
MDAC y problemas comunes en el enlace ................................................................................................... 735
Resumen ........................................................................................................................................................ 736

Capítulo 29: Data Environment ................................................................................................. 737
Organización de enlaces a datos utilizando el Data Environment ................................................................ 738
Estructura jerárquica del Data Environment .......................................................................................... 739
Resumen ....................................................................................................................................................... 749
Capítulo 30: Data Report ........................................................................................................... 751
Informes a través del Data Report ................................................................................................................ 752
Cómo agregar un Data Report a un proyecto .......................................................................................... 752
Objetos del Data Report .......................................................................................................................... 753
Secciones del Data Report ....................................................................................................................... 753
Controles del Data Report ...................................................................................................................... 754
Desarrollo de un informe .............................................................................................................................. 755
¿Qué queremos? La imagen visual del informe ...................................................................................... 755
Cómo agregar campos del Data Environment al Data Report ................................................................ 760
Cómo agregar objetos al Data Report ..................................................................................................... 762
Informes con grupos de datos ........................................................................................................................ 769
Data Environment para informes con grupos .......................................................................................... 771
Cómo se organizan las secciones ............................................................................................................. 776
Campos calculados y objetos rptFunction ........................................................................................ 783
Resumen ......................................................................................................................................................... 787
























xiv Contenido

Parte 5: Apéndices
Apéndice I: Convenciones ......................................................................................................................... 791
Prefijos para los controles ............................................................................................................................ 791
Prefijos sugeridos para DAO .................................................................................................................. 794
Prefijos sugeridos para menús ................................................................................................................ 795
Selección de prefijos para otros controles .............................................................................................. 795
Convenciones de nombres de constantes y variables ................................................................................... 795
Prefijos de alcance de variables .............................................................................................................. 796
Constantes ............................................................................................................................................... 797
Variables .................................................................................................................................................. 797
Tipos de datos de variables ..................................................................................................................... 798
Nombres descriptivos de variables y procedimientos ............................................................................ 798
Tipos definidos por el usuario ................................................................................................................ 799
Convenciones de codificación estructurada ................................................................................................. 799
Convenciones de comentarios al código ................................................................................................ 799
Cómo formatear el código ...................................................................................................................... 801
Agrupación de constantes ....................................................................................................................... 801
Operadores & y + .................................................................................................................................... 802
Creación de cadenas para MsgBox, InputBox y consultas SQL ........................................................ 802
Apéndice II: Service Pack 5.0 de Visual Studio 6.0 ................................................................................... 803
Necesidad del Service Pack ............................................................................................................................ 803
Consideraciones de instalación ................................................................................................................. 805
Actualizaciones de productos relativos a Visual Basic ................................................................................... 807
Microsoft® Agent 2.0 ............................................................................................................................... 807
Visual Studio Installer ............................................................................................................................... 807
Problemas con los controles, resueltos con SP5 .............................................................................................. 807
Artículos de Microsoft Knowledge Base sobre los errores solucionados ........................................................ 812

Índice ................................................................................................................................................................813








































ÍNDICE DE PRÁCTICAS
_________________________________________________________________________


Parte 1: Entorno Integrado de Desarrollo
Capitulo 1: Visual Basic como plataforma de desarrollo
01.01 Cómo iniciar sesión en Visual Basic...................................................................................... 6
01.02 Cómo cerrar una sesión en Visual Basic................................................................................ 8
01.03 Cómo activar los elementos del IDE ................................................................................... 11
01.04 Cómo establecer el entorno de desarrollo a SDI ................................................................. 14
01.05 Ubicación de los controles ................................................................................................... 22
01.06 Cómo ocultar y mostrar formularios..................................................................................... 26
01.07 Uso de la ventana Propiedades ............................................................................................. 30
Capitulo 2: Creación de la interfaz de usuario
02.01 Cómo insertar un objeto en la interfaz.................................................................................. 38
02.02 Cómo cambiar la posición o las dimensiones de un objeto................................................... 43
02.03 Cómo seleccionar un formulario... ....................................................................................... 45
02.04 Corno cambiar el tamaño de un formulario. ......................................................................... 45
02.05 Cómo guardar su trabajo....................................................................................................... 46
02.06 Cómo agregar objetos en modo de trazo .............................................................................. 47
02.07 Selección de objeto activo. en forma individual o en modo de grupo ................................. 49
02.08 Cómo determinar la posición de un formulario en la pantalla ............................................. 51
02.09 Cómo establecer las Guías de resolución ............................................................................. 53
02.10 Cómo utilizar las herramientas del menú Formato para organizar objetos...................................... 54
Capítulo 3: Cómo establecer las propiedades de los objetos
03.01 Cómo validar la cantidad y el tipo de objetos requeridos en una aplicación......................... 60
03.02 Cómo modificar la propiedad Ñame de los objetos............................................................... 66
03.03 Cómo modificar las propiedades de apariencia y comportamiento....................................... 68
Capítulo 4: Escritura del código de los eventos
04.01 Cómo abrir la ventana Código............................................................................................... 81
04.02 Cómo manejar los componentes de la ventana Código ........................................................ 82
04.03 Manejo de colores y autoformato al editar código................................................................. 85
04.04 Compilación y detección de errores en modo de edición...................................................... 86
04.05 Sugerencia de propiedades y métodos en modo de edición................................................... 87
04.06 Uso de los cuadros Objeto y Evento para la selección y codificación de un procedimiento
de evento determinado .......................................................................................................... 90
04.07 Uso del carácter de .subrayado y la ayuda contextual en modo de edición........................... 92
Capítulo 5: Cómo guardar y ejecutar aplicaciones
05.01 Archivos de trabajo en Visual Basic ................................................................................. 104
05.02 Cómo abrir un proyecto previamente guardado................................................................. 107
05.03 Cómo ejecutar e interrumpir su programa.......................................................................... 110
05.04 Cómo seleccionar el proyecto inicial.............. ................................................................... 111





xv


















xvi índice de prácticas
05.05 Cómo seleccionar el objeto de inicio en un proyecto..........................................................................113
05.06 Despliegue de errores en tiempo de ejecución ................................................................................... 116
05.07 Cómo corregir código en modo de interrupción................................................................................. 118
05.08 Cómo ejecutar un programa línea por línea................................................. ...................................... 119
05.09 Cómo agregar y eliminar un punto de interrupción............................................................................ 120
05.10 Cómo compilar un proyecto para generar un ejecutable en Visual Basic.......................................... 121

Parte 2: Elementos de programación
Capítulo 6: Variables y tipos de datos
06.01 MsgBox: creación de cuadros de información y confirmación de manera rápida..............................133
06.02 Uso de constantes de Visual Basic...................................................................................................... 138
06.03 InputBox: acceso rápido de datos ...................................................................................................140
06.04 Determinación del nombre. tipo de datos y alcance indicado para las variables de memoria.............148
06.05 Uso de matrices y determinación de límites mínimos y máximos del intervalo de subíndices...........154
06.06 Declaración automática de variables en Visual Basic..........................................................................155
06.07 Uso de Option Explicit (requerir la declaración de variables de manera explícita)...................156
06.08 Cómo establecer Option Explicit de manera automática para todos los formularios nuevos....157
06.09 Uso de funciones de conversión........................................................................ ................................. 160
06.10 Uso de la función Format ................................................................................................................ 163
06.11 Uso de la función Format. en formatos definidos por el usuario..................................................... 165
Capítulo 7: Operadores y estructuras de control
07.01 Uso de los operadores aritméticos .......................................................................................................171
07.02 Cómo se resuelven las condiciones que incluyen operadores de comparación....................................174
07.03 Cómo especificar la preferencia al resolver condiciones. mediante el uso de paréntesis ....................177
07.04 Uso de For Next ................................................................................................................ ...............187
07.05 Uso de Exit For ................................................................................................................................188
07.06 Uso de Do Loop .................................................................... .............................................................190
Capítulo 8: Funciones de manipulación de datos
08.01 Uso de funciones de fecha y hora...................................................... .................................................201
08.02 Uso de funciones de manipulación de cadenas................................................................................... 209
08.03 Uso de funciones numéricas y de decisión.......................................................................................... 214
Capítulo 9: Procedimientos y funciones definidas por el usuario
09.01 Creación de un procedimiento ............................................................................................................ 224
09.02 Creación de un procedimiento que no utilice argumentos y devuelva valores................................... 226
09.03 Creación de un procedimiento que utilice argumentos y devuelva valores........................................ 228
09.04 Creación de un procedimiento que utilice argumentos opcionales y devuelva valores ..................... 231
09.05 Creación de un procedimiento que utilice argumentos opcionales con valor predeterminado
y devuelva valores................................................................................................................ 233
09.06 Creación de un procedimiento que utilice un número de argumentos incierto.................................. 236


Parte 3: Controles gráficos y programación orientada a eventos
Capítulo 10: Controles básicos para la introducción de datos
10.01 Uso de objetos basados en los controles Label. TextBox y CommandButton......................... 245












Índice de prácticas xvii
10.02 Uso de botones predefinidos de aceptación y cancelación y cuadros de texto multilíneas,
de capacidad limitada.......................................................................................................................................... 251
10.03 Uso de caracteres para escritura oculta y validación inmediata de caracteres, asegurando
la captura de caracteres en mayúscula. Habilitar e inhabilitar botones............................................................... 256
Capítulo 11: Programación orientada a eventos
11.01 Demostración de algunos de los eventos de tipo Clic, Cambios y Enfoque.............................................. 271
11.02 Demostración de algunos de los eventos de tipo Teclado ......................................................................... 279
11.03 Demostración de algunos de los eventos de tipo Ratón ............................................................................ 285
11.04 Cómo darle riqueza visual a un programa, mediante el evento MouseMove........................................... 287
11.05 Elaboración de un programa que le permita visualizar la prioridad en la ejecución
de los eventos................................................................................................................................................. 295
11.06 Demostración de la precedencia del evento MouseMove sobre el evento Click.................................. 301
Capítulo 12: Controles contenedores y controles de selección
12.01 Cómo utilizar un objeto contenedor para darle funcionalidad a una aplicación ................................... 307
12.02 Uso de un control CheckBox para seleccionar varias características de manera simultánea ............. 312
12.03 Uso de una matriz de controles y su uso a través de For Next y For Each .................................... 319
12.04 Uso de funciones RGB y QBGolor para la manipulación de colores................................................... 325
12.05 Uso de objetos tipo OptionButton y Shape, y de una matriz de controles ................................... 326
12.06 Uso de barras de desplazamiento y números aleatorios ........................................................................ 332
Capítulo 13: Controles de listas desplegables
13.01 Utilización de un objeto ListBox, agregándole y eliminándole elementos
de forma dinámica............................................................................................................................................. 349
13.02 Uso de objetos ListBox de selección múltiple, que pasan elementos de una lista a otra.................... 354
13.03 Uso de un objeto ListBox con estilo CheckBox................................................................................ 358
13.04 Uso de los objetos ComboBox y ListBox para crear un explorador de fuentes.................................. 361
13.05 Uso de un objeto ComboBox sensible a la escritura............................................................................... 365
Capítulo 14: Editor de menús y manejo del Portapapeles
14.01 Cómo se agrega un objeto de tipo menú.................................................................................................. 375
14.02 Cómo introducir código a una opción de menú y utilizar un menú......................................................... 380
14.03 Activación dinámica de opciones............................................................................................................. 381
14.04 Modificación del tipo de letra utilizando el menú.................................................................................... 383
14.05 Opciones de menú mutuamente excluyentes............................................................................................ 384
14.06 Cómo se maneja el Portapapeles en Visual Basic..................................................................................... 387
Capítulo 15: Manejo de imágenes
15.01 Uso de objetos basados en el control Image y carga de imágenes con LoadPicture....................... 398
15.02 Uso de objetos basados en el control PictureBox y modificación dinámica de imágenes ................ 401
15.03 Cómo agregar componentes a un proyecto de Visual Basic .................................................................... 406
15.04 Almacenamiento de imágenes en un objeto ImageList ...................................................................... 410
15.05 Uso de una colección de imágenes ImageList .................................................................................... 416
Capítulo 16: Arrastrar y colocar
16.01 Programa que comprueba las operaciones de arrastrar y colocar.............................................................. 423
16.02 Programa que comprueba las operaciones de arrastrar y colocar cuando el objeto de destino
no es de tipo Form......................................................................................................................................... 426












xviii índice de prácticas
16.03 Programa que comprueba las operaciones de arrastrar y colocar, y que utiliza un objeto
de destino que no es de tipo Form ......................................................................................................... 428
16.04 Programa que comprueba los estados de las operaciones de arrastrar y colocar, así como
los punteros predefinidos del entorno de Windows ............................................................................... 434
16.05 Programa que comprueba las operaciones de arrastrar y colocar utilizando el modo manual ........... 436
Capítulo 17: Control del tiempo
17.01 Uso del control Timer como valor absoluto. Un reloj.......................................................................444
17.02 Uso del control Timer como valor relativo. Cuenta regresiva en captura.........................................446
Capítulo 18: Manejo del sistema de archivos
18.01 Uso de los controles básicos para el manejo del sistema de archivos................................................. 454
18.02 Uso del objeto FileSystem para manipulación de directorios....................................................... 463
18.03 Uso del objeto FileSystem para manipulación de archivos........................................................... 469
Capítulo 19: Cuadros de diálogo comunes
19.01 Cómo agregar el control CommonDialog al Cuadro de herramientas............................................. 479
19.02 Uso del control CommonDialog para manipular el color en el formato estándar
de Windows................................................................................................................................................... 482
19.03 Uso del control CommonDialog para manipular las fuentes (tipos de letra) en el formato
estándar de Windows.................................................................................................................................... 488
19.04 Uso del control CommonDialog para manipular las especificaciones de impresora
en el formato estándar de Windows.............................................................................................................. 493
19.05 Uso del control CommonDialog para manejar el cuadro de diálogo Abrir/ Guardar como,
en el formato estándar de Windows ............................................................................................................. 501
Capítulo 20: Cómo trabajar en una interfaz de múltiples documentos
20.01 Cómo agregar un formulario maestro para trabajo en MDI y los formularios hijos.......................... 506
20.02 Cómo trabajar con varios formularios ............................................................................................... 509
Capítulo 21: Controles ActiveX para mejorar la interfaz
21.01 Uso de objetos basados en el control ProgressBar ..................................................................... 515
21.02 Uso de TreeView ............................................................................................................................ 521
21.03 Uso de StatusBar y ToolBar ..................................................................................................... 532

Parte 4: Archivos y bases de datos
Capítulo 22: Bases de datos y DAO
22.01 Análisis de un modelo relacional de bases de datos.
22.02 Identificación de elementos del modelo de datos ......
Capítulo 23: Lenguaje de Definición de Datos y DAO
23.01 Habilitación de DAO.......................................................................................................................... 564
23.02 DDL utilizando DAO: declaración de variables objeto...................................................................... 565
23.03 DDL utilizando DAO: creación del almacén de base de datos........................................................... 574
23.04 DDL utilizando DAO: creación de estructura de tablas y sus campos................................................ 579
23.05 DDL utilizando DAO: creación de índices .........................................................................................582












Índice de prácticas xix
23.06 DDL utilizando DAO: creación de relaciones.................................................................................. 584
23.07 Ingeniería inversa utilizando DAO: determinación del modelo de datos a partir
de un almacén de datos .......................................................................................................................... 589
Capítulo 24: Lenguaje de Manipulación de Datos y DAO
24.01 DML utilizando DAO: actualización de una tabla mediante la técnica RAR..................................... 614
24.02 DML utilizando DAO: métodos de movimiento entre registros......................................................... 623
24.03 DML utilizando DAO: búsqueda basada en criterios ......................................................................... 630
Capítulo 25: Controles Data y FlexGrid
25.01 Uso del control Data para agregar, eliminar, modificar y consultar registros................................... 642
25.02 Uso del control Data para alimentar un FlexGrid ........................................................................647
25.03 SQLViewer: intérprete de SQL para DAO, usando los controles Data y FlexGrid..................... 650
Capítulo 26: Bases de datos multiusuario usando DAO
26.01 Rutina de manejo de errores ............................................................................................................... 666
26.02 Uso del DAO para aplicaciones multiusuario..................................................................................... 669
Capítulo 27: Archivos planos para transferencia de datos
27.01 Creación y escritura en archivos planos.............................................................................................. 680
27.02 Proceso para bajar datos de una base de datos a archivos planos ...................................................... 682
27.03 Cómo cargar datos a una base de datos desde un archivo.................................................................. 685
Capítulo 28: Manejo de bases de datos corporativas usando ADO
28.01 Conexión a bases de datos corporativas usando ADO........................................................................ 697
28.02 Visualización de bases de datos corporativas utilizando el control DataGrid y ADO....................705
28.03 Consultas SQL a bases de datos corporativas usando ADO............................................................... 713
28.04 DML utilizando ADO: actualización de una tabla mediante la técnica RAR..................................... 722
Capítulo 29: Data Environment
29.01 Uso del Data Environment para manejar bases de datos corporativas ............................................... 742
Capítulo 30: Data Report
30.01 Cómo definir un Data Environment para utilizarlo con el Data Report.............................................. 757
30.02 Cómo complementar con objetos rptTextBox la sección Detalle de un Data Report................... 761
30.03 Cómo complementar el Data Report con objetos rptLabel y rptLine. Asignación
de valores a objetos rptLabel ............................................................................................ 763
30.04 Cómo complementar el Data Report con objetos rptShape y rptimage................................... 767
30.05 Cómo definir un Data Environment para utilizarlo con el Data Report basado
en grupos de información........................................................................................................................ 772
30.06 Cómo definir un Data Report basado en grupos de información........................................................ 778
30.07 Cómo integrar a un informe datos consolidados, de la base de datos y de campos calculados...........785















LO INESPERADO
_________________________________________________________________________
Errores en tiempo de diseño
Apertura no solicitada de la ventana Código.................................................................................................... 43
Changed database context to "Database" ...................................................................................................... 735
¿Desea crear una matriz de controles?............................................................................................................... 65
Especificación de alcance de procedimiento no requerida................................................................................ 93
Formato regional de Windows afecta el valor devuelto de la función Format............................................... 165
Las secciones del informe no coinciden con el origen de datos ..................................................................... 786
No aparece la ventana Nuevo proyecto............................................................................................................... 7
No hay ninguna fuente .................................................................................................................................... 488
No se encontró campo <campo>.................................................................................................................... 786
No se encuentra Data Environment en el menú Proyecto ............................................................................... 743
No se puede colocar el control <control> en esta sección.............................................................................. 786
No se recuperan datos,..................................................................................................................................... 748

Errores de compilación (orden alfabético)
Bloque if sin end if .......................................................................................................................................... 180
Do sin Loop ..................................................................................................................................................... 190
El Character de declaración de tipo no coincide con el tipo de datos declarado.......................................... 147
El Character no es válido ............................................................................................................................... 147
El número de dimensiones es incorrecto ......................................................................................................... 153
End if sin bloque if .......................................................................................................................................... 180
End Select sin Select Case .............................................................................................................................. 185
For sin Next ..................................................................................................................................................... 188
Loop sin Do ..................................................................................................................................................... 191
Next sin For ..................................................................................................................................................... 189
No coinciden los tipos ..................................................................................................................................... 397
No se encontró el método o el dato miembro .................................................................................................. 248
No se encontró método o elemento de datos ................................................................................................... 114
No se ha definido el tipo definido por el usuario ........................................................................................... 570
No se ha encontrado el archivo ....................................................................................................................... 397
No se puede asignar a una matriz .................................................................................................................. 153
Origen de datos no válido............................................................................................................................... 786
Procedimiento Sub o Function no definido ..................................................................................................... 115
Referencia de variable de control Next no válida ........................................................................................... 189
Se esperaba ")", "(" ......................................................................................................................................... 228
Se esperaba el fin de la instrucción.................................................................................................................. 146
Se esperaba fin de la función ........................................................................................................................... 228
Select Case sin End Select .............................................................................................................................. 185
Uso no válido de una propiedad ..................................................................................................................... .248
XX










Lo inesperado xxi
Errores en tiempo de ejecución (orden consecutivo)
Algunos campos no regresan valores al ejecutar el informe........................................................................... 766
El tamaño del informe excede el tamaño de la página.................................................................................... 766
Error desconocido ADO................................................................................................................................. 734
No se encuentra el nombre del origen de datos (Administrador ODBC)....................................................... 734
Error 5: Llamada a procedimientos o argumentos no válidos ........................................................................ 368
Error 6: Desbordamiento................................................................................................................................. 146
Error 9: El subíndice está fuera del intervalo....................,............................................................................ 153
Error 13: No coinciden los tipos ...................................................................................................................... 228
Error 48: Error al cargar la biblioteca "archivo.ocx".................................................................................... 735
Error 53: No se ha encontrado el archivo....................................................................................................... 397
Error 68: El dispositivo no está disponible ..................................................................................................... 463
Error 75: Error de acceso a ruta o archivo ..................................................................................................... 463
Error 76: No se ha encontrado la ruta de archivo........................................................................................... 462
Error 91: Variable de tipo objeto o la variable de bloque With no está definida............................................ 730
Error 380: El valor de la propiedad no es válido ........................................................................................... 515
Error 424: Se requiere un objeto ............................................................................................................. 115, 247
Error 481: La imagen no es válida.................................................................................................................. 397
Error 3020: Update o CancelUpdate sinAddNew o Edit ................................................................................ 612
Error 3044: {Rutaj No es una ruta válida ...................................................................................................... 575
Error 3078: El motor de base de datos Jet no encuentra la tabla o query ..................................................... 603
Error 3204: Base de datos ya existe................................................................................................................. 575
Error 3264: No hay campos definidos - No se puede agregar el objeto TableDefo índex ............................. 576
Error 3265: Elemento no encontrado en esta colección ................................................................................ 608
Error 3368: Relaciones deben ser por el mismo número de campos del mismo tipo de datos ....................... 587
Error 3420: Objeto inválido o no permanece definido ................................................................................... 578
Error 3421: Error de conversión de tipo de datos .......................................................................................... 620
Error 35600 El índice está fuera de los límites .............................................................................................. 415
Error 35601 No se encontró el elemento ........................................................................................................ 415
Error-2147217843: Conexión inválida............................................................................................................ 707
Error -2147217843: Login failed.................................................................................................................... 707
Error -2147217843: Attempt to locate entry in sysdatabase.......................................,................................... 708



















PRÓLOGO
_________________________________________________________________________
Aprenda Visual Basic practicando es un libro de propuesta.
Nace de una realidad evidente: la gente compra los libros de programación para aprender. En muchos casos
adquiere el conocimiento como resultado de la lectura y, sin embargo, está inconforme con el resultado y con sus
propias potencialidades. La consecuencia obligada, si su afán de aprender persiste o si las necesidades de trabajo
así lo demandan, es que termina tomando un curso.
Tal pareciera entonces que los cursos son más completos, más efectivos, lo que nos lleva a planteamos la pregunta
cuya respuesta mueve este libro: ¿qué tienen los cursos que no tengan los libros? La respuesta es simple: los
cursos tienen más acción, como dirían algunos; hay interacción, aciertos y errores, el hacer del participante es
diferente al hacer que corresponde al lector de un libro.
Conocer la teoría es importante, pero no suficiente; todo lo plasmado en un libro funciona bien, pero en la realidad
las cosas no siempre suceden de manera tan favorable en el trabajo diario. En la realidad aparecen situaciones
inexploradas por los libros, en donde más que conocer la teoría, se requiere haberla comprendido mediante la
vivencia práctica, para poder así ejercer el pensamiento lateral que nos lleve a resolver problemas ante los cuales
nunca nos habíamos enfrentado.
Éste es un libro práctico y creemos firmemente que la práctica hace al maestro. Cada capítulo tiene su objetivo
particular, no sólo explica algo, sino sirve para algo. Es un libro en el que se vale escribir, de hecho se
recomienda; está lleno de conceptos, cuestionarios, ejemplos, ejemplos y ejemplos. Es como leer un libro que
además le brinda los elementos para que trabaje como lo haría en un curso. Reúne lo mejor de los dos mundos.
Es excelente para el lector autodidacta, ya que le permite asimilar la información y practicar lo aprendido, así
como dar seguimiento a sus propios avances en el aprendizaje. Para los maestros e instructores de Visual Basic, es
un apoyo valioso como material de texto. Para el programador que ya ha tenido contacto con Visual Basic, es una
caja de trucos que le puede facilitar la tarea de desarrollar aplicaciones avanzadas o pulir las que haya
desarrollado. En términos generales, es útil para aquellos que no se dejan llevar por la engañosa creencia de que
programar se aprende leyendo; programar se aprende programando y punto.
Sólo esperamos una cosa: que practique, comprenda y aprenda Visual Basic.
José Felipe Ramírez Ramírez
Catedrático de la Universidad
Autónoma de Nuevo León
xxii










FORMA Y CONTENIDO DEl LIBRO
_________________________________________________________________________


La organización de este libro
Este libro está dividido en cinco partes:
• Entorno Integrado de Desarrollo. Trata de manera detallada los elementos y herramientas que
Visual Basic proporciona para soportar el desarrollo de aplicaciones para Windows 95, 98, 2000 y
NT. En esta parte se revisa el ciclo de desarrollo de aplicaciones de Visual Basic, desde el inicio
de un proyecto hasta su compilación a ejecutable (EXE) para su distribución. Es fundamental que
asimile y domine todo lo expuesto en esta parte, incluso si ya maneja Visual Basic, a efecto de
unificar los conceptos que maneja el libro.
• Elementos de programación. Trata de manera detallada los elementos de programación en Visual
Basic, como el manejo de variables, procedimientos, funciones implícitas del lenguaje, tipos de
datos, estructuras de control, etcétera. Si verdaderamente quiere ser un experto en Visual Basic, es
necesario que deje lo sencillo, el lado "Visual", para profundizar en primera instancia en su lado
"Basic".
• Controles gráficos y programación orientada a eventos. Trata de manera detallada los controles
básicos de Visual Basic. Al terminar esta parte, estará listo para diseñar cualquier interfaz de
usuario que se proponga desarrollar. También se revisa el manejo de algunos controles ActiveX
que proporcionarán un aspecto profesional a sus aplicaciones.
• Archivos y bases de datos. Trata de manera específica la forma de utilizar bases de datos con
Visual Basic, introduciéndolo a técnicas avanzadas para el registro, recuperación y eliminación de
información, representación de modelos de datos en Visual Basic y el manejo de instrucciones
SQL, utilizando para ello las versiones más recientes de las colecciones de objetos para manejo de
datos:
Objetos de Acceso a Datos de Microsoft, Objetos de Datos ActiveX de Microsoft y enlaces mediante
ODBC. Esta parte también trata la manipulación de archivos de texto utilizando Visual Basic, así
como el manejo del diseñador Data Report, que le permitirá crear informes para su salida en
pantalla o papel.
• Apéndices. Aquí se detallará información del producto y las costumbres asociadas a su uso. Los
apéndices constituyen una referencia que no debe dejar de consultar para obtener buenos productos
de su trabajo. Se tratarán en este caso las
xxiii













xxiv Forma y contenido del libro
convenciones de la programación en Visual Basic, así como las mejoras relacionadas con el Service
Pack 5.0 de Visual Studio.
Cada parte se divide a su vez en capítulos; cada uno de los cuales tiene una organización consistente
que facilita la presentación del material.
• Cada capítulo tiene el tamaño adecuado para manejar un tema de manera completa, sin ser muy
extenso; la idea es que no interrumpa un tema sin agotarlo.
• Cada capítulo inicia con una sección de Objetivos, la cual describe de manera rápida lo que se
pretende aprender en dicho capítulo.
• Al final de cada capítulo se encontrará una sección de Resumen, en la cual se enumerarán los
puntos más importantes, principalmente los que serán indispensables para capítulos posteriores. En
el resumen también podrá encontrar respuestas relativas a algunas prácticas del capítulo.

Notas
Las notas que aparecen en el contenido de este libro pueden ser de los siguientes tipos:
• Las referencias marcadas como Nota contienen información suplementaria, que no repercute en la
realización de una tarea, pero que sin duda enriquecerá su acervo de conocimientos relativos a
Visual Basic.
• Las notas marcadas como Lo inesperado contienen explicaciones de aquello que le puede suceder
y que no esperaba que ocurriera; comportamientos extraños, errores, situaciones imprevistas de
toda índole. Por lo general, seguirán de prácticas que con toda intención generan el error, a efecto
de que usted lo pueda analizar y prevenir. Este tipo de notas será vital para usted, ya que los
errores más comunes y la forma de solucionarlos se detallarán en el momento oportuno.

Prácticas
• Las prácticas que se encuentren en este libro (que son muchas) estarán presentadas como listas
numeradas (1, 2, 3, y así sucesivamente). Una viñeta triangular (>>) indica el inicio de una
práctica. Las prácticas estarán numeradas por Capítulo.Práctica; las prácticas serán su guía para
saber cómo hacer algo.
• En el desarrollo de las prácticas será muy frecuente el uso de los menús de Visual Basic; algunos
de ellos tienen diferentes niveles de profundidad, es decir, de un












Forma y contenido del libro xxv
menú surge otro menú, y así sucesivamente. Para manejar esa situación, será lo mismo decir
"Seleccione en la barra de menús la opción Herramientas, después seleccione Opciones y después, en
el cuadro de diálogo que aparece, seleccione la ficha Avanzadas", que "Seleccione el menú
Herramientas — Opciones — Avanzadas".

Lo simplificamos porque en la práctica es así de fácil: mediante tres clics usted ya habrá hecho todo el
proceso de selección de una opción, en menos de tres segundos. La idea es que el libro no haga que lo
sencillo parezca complejo.

Notaciones y uso de tipos de letra
• Se utilizarán itálicas cuando surjan conceptos y términos nuevos, incluyendo elementos propios del
lenguaje que sean referidos por primera vez. También aplicará para las variables y argumentos,
cuando aparezcan como parte de una sintaxis. Aplicarán cuando se haga referencia a otros textos,
cuando se haga referencia a bibliotecas del lenguaje y cuando se describan mensajes de error en las
secciones de Lo inesperado.
•Se utilizará MCPdigital (u OCR A Extended) para las propiedades de los objetos (estén o no
asociadas a los objetos), las referencias a funciones, palabras reservadas y el código de Visual Basic.
•En la sintaxis, los corchetes "[ ]" encierran aquellos elementos opcionales. Las llaves "( }", por su
parte, contendrán opciones mutuamente excluyentes.
•Se utilizarán negritas en los nombres de directorios o archivos. Se utilizarán de igual manera para
referir nombres de procedimientos creados por el usuario, así como para los datos de entrada que el
usuario tiene que escribir, incluyendo pulsaciones de teclas. Se utilizarán para identificar las
herramientas y componentes del Entorno Integrado de Desarrollo, en sus partes no utilizables
como opción.
•Se utilizarán negritas itálicas para los elementos de la interfaz que pueden ser utilizados como
opción, las opciones de menú y otras opciones de interfaz, como botones de comando u otros que
desencadenen alguna acción determinada, formen parte del Entorno Integrado de Desarrollo, o de
la interfaz creada por los usuarios.
















xxvi Forma y contenido del libro

Convenciones del teclado
• El signo de suma (+) entre dos teclas indica que éstas deberán ser presionadas de manera
simultánea; por ejemplo, "Alt+A".
Archivos de apoyo
En el sitio Web http://www.enlace.net/ramirez2 se ha colocado un archivo llamado
AVBP.ZIP, que contiene los archivos comprimidos que son necesarios para la realización de las
prácticas del libro. Al ejecutar el programa, se generará un directorio llamado \avbp, que a su
vez tendrá varios directorios, como sigue:

\avbp
\cap01
\cap02
\cap03
..
• En \avbp\capn se colocarán los archivos necesarios para que pueda realizar de manera completa
y correcta las prácticas. La ncorresponde al número de capítulo en donde son requeridos los
archivos.
• En \avbp\capn se deberán guardar las aplicaciones que vaya generando, a efecto de que tenga
debidamente organizado su avance. La n corresponde al número de capítulo en el que son
generadas las aplicaciones.
Aunque no todos los capítulos requieren archivos o generan aplicaciones, se incluirán de tal forma
que se tenga un estándar de uso. No se incluyen los ejercicios ya resueltos; la idea es que usted
programe, ¿o no?














AGRADECIMIENTOS
Aprenda Visual Basic practicando no es el esfuerzo de una sola persona, y mucho menos la visión unipersonal de
un profesional en informática con ánimo de sentarse a escribir; más bien es una especie de consolidación
colectiva, la contribución de muchas cabezas y muchas manos, con el objeto de producir un libro idóneo para
capacitar a estudiantes de informática en la programación, utilizando para ello Visual Basic.
Quiero agradecer a todos los que de una forma u otra contribuyeron con el desarrollo de este libro. Los miembros
de la generación LI@ 1996-2000, de la Facultad de Contaduría y Administración, habitan de manera cómoda y
curiosa en cada uno de los ejercicios contenidos en el texto: para ustedes mi amistad, mi respeto y mi apoyo
constante.
Especialmente agradezco a dos personas: a Dalila Garza Villarreal, quien de manera exhaustiva y dedicada corrió
a cargo de los trabajos de edición del texto, le agradezco su paciencia y precisión en la revisión de los
documentos; sin su atinado apoyo, este libro sería una retórica técnica y extraña. A Juan Francisco Guevara
Álvarez, por otro lado, le agradezco haber probado y criticado todos y cada uno de los ejercicios y su explicación,
haber aportado ideas ("por qué no le agrega esto Lic...") y por transmitirme la sensación de que la docencia sólo
tiene esperanza si el alumno llega a superar al maestro. En palabras de Don Alfonso Reyes, son unos héroes en
mangas de camisa. No temen al trabajo arduo y llegarán lejos.
Agradezco a todos mis compañeros, que como yo, tienen muy presente que los egresados de la UANL deben ir
abriendo surco, y que de hecho lo hacen con gusto: José Luis Ramos, Juvencio Jaramillo, Magdiel Martínez, José
Méndez, Ismael Rodríguez Elizalde, Enrique Hernández Hernández, y a todos los compañeros de la División de
Postgrado de la FACPyA; agradezco también a mis amigos de la Universidad del Norte, Instituto Tecnológico de
Monterrey, ITESM, y demás; son tantos que no puedo precisarlos.
Agradezco a mis amigos Javier Chalup Ayala, José Rogelio Martínez Delgadillo, Abraham Alvarez Escobedo, y
tantos otros que comprendieron que mi preferente atención hacia el monitor de la computadora era un trance
pasajero: si me dieran a escoger entre el libro y ustedes, ¡adiós libro!
Agradezco a los alumnos y ex alumnos que con su retroalimentación ayudaron a obtener un mejor texto:
Guadalupe Rangel Vázquez, Elsa Marcela Lugo, Anna Elizabeth Franco, Mónica Castañeda Guerra y,
especialmente, a Mario Alberto Tamez García, quien probó todo el código del libro.
Como siempre, dejo al último lo más importante: agradezco a mi esposa, a quien dedico este libro, por su
paciencia y apoyo; a mi padre y a mi madre, porque les debo ser el profesional que soy: sólo cuando uno crece
comienza a entender y a agradecer. A mis hermanos, todo mi amor y todo lo bueno.
xxvii


















Parte 1
Entorno integrado de
Desarrollo

En esta primera parte conocerá a Visual Basic como herramienta de
desarrollo de aplicaciones para el entorno de Windows. Así como el
artesano que termina primero su trabajo es aquel que sabe con
exactitud de qué herramientas dispone y dónde se encuentran éstas, de
la misma forma el desarrollador de aplicaciones conoce la enorme
variedad de utilerías y características que Visual Basic pone a su
disposición.

Esta primera parte tiene como objetivo que usted sepa qué partes
componen Visual Basic, cómo se utilizan esas partes, dónde las
encuentra y cómo puede administrarlas.

También se revisa el ciclo de desarrollo de aplicaciones en Visual
Basic, que es el típico para la programación orientada a eventos. Se
propondrá una forma de trabajo sistemática y metódica, que pueda
repetir una y otra vez; recuerde: lo importante no es lo que hace, sino
el método que utiliza. Si bajo un método obtiene e| éxito, repitiendo el
método repetirá el éxito.

Capítulos:
1,2,3,4,5
Número de prácticas: 37
1






















2



Capítulo
1

Visual Basic
como plataforma
de desarrollo

Objetivos
Aprender el objeto principal de la programación. Conocer la parte
gráfica de Visual Basic, a través de su Entorno Integrado de Desarrollo
(IDE), y la parte procedural, a través del manejo del lenguaje orientado
a eventos,
Al finalizar este capítulo deberá:
• Saber cuál es el objeto de la programación
• Entender la tecnología orientada a eventos
• Conocer el Entorno Integrado de Desarrollo
• Saber cómo está compuesto el IDE y para qué sirven cada una de sus
partes
• Dominar los conceptos básicos del desarrollo de aplicaciones en
Visual Basic
• Conocer los siete pasos para crear una aplicación en Visual Basic



3


4 Parte 1; Entorno Integrado de Desarrollo

Objeto de la programación
Usted quiere aprender a programar en Visual Basic. Si no lo ha hecho antes en ningún
lenguaje y quiere empegar de lleno con la programación, déjeme decirle que estará
empezando a la mitad en el proceso de desarrollo de aplicaciones: una medianía que si
no percibe, puede costarle mucho trabajo entender,
No siempre aprender a programar lo conducirá a solucionar sus problemas de infor-
mación. Simplemente automatizará tareas, y éstas pueden constituir en sí mismas una
solución o un problema.
En conclusión, queremos decirle que la programación no es una actividad aislada que
produzca resultados por sí misma: la programación es una de las muchas tareas que se
tienen que hacer al desarrollar una aplicación.
El modelo clásico del Ciclo de Desarrollo de Aplicaciones tiene las siguientes fases:

• Análisis. Se observa detenidamente un problema o situación con el fin de deter-
minar qué aplicación se requiere desarrollar. Se delimitan los problemas o se
identifican áreas de oportunidad sobre las que hay que trabajar.
• Diseño, Se define de manera sistemática y estructurada la forma en que se va a
llevar a cabo el desarrollo. En el diseño se definen las vistas de la aplicación, así
como su comportamiento y sus restricciones.
• Programación. Se diseña y codifica la aplicación de tal forma que haga, sin
errores, lo que está definido en la fase de diseño.
• Pruebas. Se ejecuta la aplicación en todas sus variantes, a efecto de determinar si
cumple con lo estipulado en el diseño, y se comprueba que la misma satisfaga los
requerimientos determinados en la fase de análisis. En caso de que se detecten
errores o funcionamientos equivocados, es necesario volver sobre las fases
anteriores, a fin de aislar el problema y corregirlo.

Como puede darse cuenta, la programación es una fase muy avanzada en e] proceso
de desarrollo; si no sabe qué necesita hacer, mucho menos sabrá cómo hacerlo. Por
otro lado. si ya sabe qué es lo que necesita hacer, debe asegurarse de que la transición
del "qué" al "cómo" se haga sin errores. La mayoría de los errores de sistemas son
debido a que lo especificado en e] análisis y el producto final no representan lo
mismo. El argumento de los usuarios: "eso no es lo que yo quería", es generalmente
válido.
Concluimos que el objeto de la programación es generar código sin errores que
cumpla con lo definido en el diseño y que satisfaga los requerimientos del análisis.
En este libro seremos bastante claros con respecto a lo que queremos que el programa
haga, a cómo lo haga, y además nos aseguraremos de que no tenga errores. Aún más
importante, queremos que usted aprenda a resolver situaciones que generan error,




Capitulo 1: Visual Basic como plataforma de desarrollo 5
ya que una vez que concluya el ejercicio de este libro nadie le dirá cómo resolver los
errores que le aparezcan; serán suyos, como suya será la solución a ellos.
Nuestros grandes consejos:
• No comience a programar sino hasta saber qué desea que su programa realice.
Olvide la creencia de que en un momento de inexplicable lucidez programadora, las
ideas con respecto a la solución de un problema aparecerán en el proceso de
codificación.
• Aprenda a desarrollar siempre de manera organizada y sistemática. Adquirirá
destreza, experiencia y una facilidad casi automática para resolver errores.
• Hágalo bien desde el principio. Cree programas bien desarrollados, aunque se tarde
más; dice un dicho de mi tierra que "el flojo y el atenido trabajan dos veces".
Piense en el tiempo de desarrollo como la suma del tiempo de desarrollo más el
tiempo de mantenimiento; en ocasiones los trabajos de mantenimiento son
demasiado onerosos, y en otros casos, hasta imposibles.
• Consistencia cognoscitiva en comparación con ignorancia veloz. Con respecto al
aprendizaje del contenido de este libro, no olvide la parábola de la tortuga y la
liebre: no siempre el que corre más rápido llega primero a la meta. Comprenda los
temas hasta que sea capaz de explicarlos sin ayuda del libro, y tema por tema,
conviértase en un experto. Antes de mover los dedos, hay que mover las neuronas.

Visual Basic más que un lenguaje de programación
Algunos ubican a Visual Basic como un lenguaje de programación de propósito ge-
neral, otros le atribuyen el carácter de Desarrollo Rápido de Aplicaciones (RAD), e
incluso hay quienes dicen que es un 4GL. Lo más cercano a la verdad, dentro de las
definiciones que citamos, es que Visual Basic es un lenguaje de programación de
propósito general, pero esa apreciación es muy limitada para describir lo que en
realidad es Visual Basic- El lenguaje es sólo una parte de lo que el producto ofrece; en
términos generales, Visual Basic es una plataforma de desarrollo de aplicaciones.
Visual Basic proporciona elementos gráficos de diseño de aplicaciones, compilador,
editor de programas con capacidad de depuración al instante y asistencia basada en
colores, ayuda contextual, poderosos asistentes (wizards) que automatizan tareas de
uso común, tan disímbolas en su objeto como en su complejidad, por citar sólo algu-
nas características. No por nada Visual Basic es la plataforma de desarrollo de apli-
caciones para Windows 95, Windows 98, Windows 2000 y Windows NT, líder en el
mercado.









6 Parte 1; Entorno Integrado de Desarrollo
Visual Basic lleva en su nombre los dos elementos generales que lo conforman.

• Su parte "Visual" indica que es una interfaz gráfica de usuario (GUI), que en lugar de
requerir el uso de comandos escritos para realizar tareas, sólo requiere el uso de
herramientas gráficas, de tal forma que desarrollar se asemeja mucho a estar "dibujando"
el trabajo. Esta parte está compuesta por el IDE, que ocupa casi todo este capítulo.
• Su parte "Basic" indica que aquellas tareas que no se pueden realizar a través de las
herramientas gráficas (que no pueden ser dibujadas), son posibles a través de un
lenguaje de programación basado en el legendario lenguaje de propósito general
llamado Código de Instrucciones Simbólicas Multipropósito para Principiantes
(BASIC) con el que prácticamente se puede desarrollar cualquier cosa.
Visual Basic no es sólo producto, también es tecnología aplicada: su parte "Visual" está
basada en tecnología orientada a objetos (00), su parte "Basic" es de tipo procedural, y la
mezcla de estas dos tecnologías dan lugar a productos híbridos, orientados a eventos (EO).

Entorno Integrado de Desarrollo
Al iniciar una sesión en Visual Basic, entra en contacto con lo que se llama IDE. Este
entorno es un conjunto de herramientas y elementos que le permiten diseñar y
programar aplicaciones interactuando con Visual Basic.

Nota: Es el momento adecuado de que instale los archivos que complementan este
libro, mismos que se encuentran en el sitio Web
http://www.enlace.net/ramirez2; descargue el archivo AVBP.ZIP en el
directorio raíz de su disco duro, y ejecútelo para su instalación.

>> Cómo iniciar sesión en Visual Basic. [01.01]
A continuación aprenderá la forma de iniciar una sesión de trabajo en Visual Basic.
1. En el escritorio de Windows haga clic en el botón Inicio, seleccione Programas,
Microsoft Visual Basic 6.0 y la opción Microsoft Visual Basic 6.0.








Capítulo 1; Visual Basic como plataforma de desarrollo 7

Nota: Visual Basic inicia una sesión mediante la ejecución del programa VB6.EXE;
si tiene definidos los accesos directos a Microsoft Visual Basic 6.0 y su computadora no lo
encuentra, puede buscar el programa ejecutable para iniciar la sesión. También puede estar
como miembro de un grupo de programas Microsoft Visual Studio 6.0; depende de su
instalación.


Al iniciar Visual Basic, aparecerá la ventana Nuevo proyecto que se muestra en la
figura 1.1.




Figura 1.1
Ventana Nuevo
proyecto

2. En la ficha Nuevo, haga clic en el icono EXE estándar, que de manera predeterminada está
seleccionado.
3. Haga clic en el botón de comando Abrir.



Lo inesperado: Si se fija, en la parte inferior de la ventana Nuevo proyecto aparece la
casilla de verificación "No mostrar este cuadro de diálogo en el futuro", si alguien antes que
usted le dijo a Visual Basic que no apareciera la ventana Nuevo proyecto al iniciar, la ventana
de la figura 1.1 no aparecerá. Si ese es su caso, para seguir con la práctica vaya al menú
Archivo - Nuevo proyecto, que mostrará una ventana similar. Este cambio no es para siempre,
ya que puede modificarlo a través del



8 Parte 1: Entorno Integrado de Desarrollo
menú Herramientas - Opciones... - Entorno, seleccionando la opción Preguntar por un proyecto del
área Cuando se inicie Visual Basic.

>> Cómo cerrar una sesión en Visual Basic. [01.02]
Enseguida conocerá la forma de cerrar una sesión de trabajo en Visual Basic.
1. Seleccione el menú Archivo - Salir. También es válida la combinación de teclas
Alt+Q, o el estándar para todas las aplicaciones de Windows: A1t+F4.

Ediciones de Visual Basic
En la ventana Nuevo proyecto aparece un conjunto de iconos, mismos que deberá
seleccionar de acuerdo a lo que desee realizar en Visual Basic. Si tiene la oportunidad
de trabajar en varios lugares con Visual Basic, tal vez se percate de que no siempre
aparecen los mismos iconos en la ventana Nuevo proyecto; el número de iconos dis-
ponibles depende de la edición de Visual Basic que tenga instalada; en la versión 6.0
del producto, se tienen las siguientes ediciones:
• Edición de aprendizaje. Esta edición de Visual Basic permite a los programa-
dores crear aplicaciones robustas para Windows 95, Windows 98, Windows 2000 y
Windows NT. Incluye todos los controles intrínsecos, además de los de cuadrícula,
de fichas y los enlazados a datos. La documentación proporcionada con esta
edición incluye el CD "Aprenda Visual Basic ya", junto con el de la biblioteca de
Microsoft Developer Network (MSDN) que contiene documentación completa en
pantalla. Una desventaja de esta versión con respecto a la versión 5.0 es que
anteriormente se acompañaba el Crystal Reports, módulo para elaborar informes en
papel, mismo que ahora tiene que comprarse por separado. Visual Basic suple esta
herramienta con un diseñador llamado Data Report, que es un producto más
modesto. Para el que desea iniciarse en Visual Basic, comprar la edición de
aprendizaje pueden ser los cien dólares mejor gastados; claro, ¡no olvidando
comprar este libro que tiene en sus manos!
• Edición profesional. Proporciona a los profesionales un conjunto completo de
herramientas para desarrollar soluciones para terceros. Incluye todas las caracterís-
ticas de la edición de aprendizaje, así como controles ActiveX adicionales, el di-
señador de aplicaciones para Internet Information Server y Visual Database Tools
and Data. La documentación que se proporciona con la edición profesional incluye
el libro Características empresariales de Visual Studio más los CDs de Microsoft
Developer Network, la cual contiene documentación completa en pantalla.
• Edición empresarial. Permite a los profesionales crear sólidas aplicaciones dis-
tribuidas en un entorno de trabajo en equipo. Si decide utilizar a Visual Basic







Capítulo 1: Visual Basic como plataforma de desarrollo 9
para proyectos grandes, complejos y que involucren un número considerable de
programadores trabajando en un mismo proyecto simultáneamente, o bien si piensa
que Visual Basic será el componente front end de un esquema cliente/servidor, la
compra de esta edición es casi obligatoria. Incluye todas las características de la
edición profesional, así como herramientas de enlace con productos Back Office
como SQL Server, Microsoft Transaction Server, Internet Information Server, Visual
SourceSafe, SNA Server, etcétera. La documentación impresa que se proporciona
con la edición empresarial incluye el libro Características empresariales de Visual
Studio más los CDs de Microsoft Developer Network, la cual contiene
documentación completa en pantalla.
Entre más completa sea la edición, más capacidades tendrá; el número de iconos es un
indicador de ese hecho. Entre más iconos haya en la ventana Nuevo proyecto, obviamente,
mayor será el costo.

Nota: Aunque la documentación de Visual Basic hace referencia a los Libros en pantalla,
éstos no son parte del producto. En la versión 5.0, al momento de la instalación se generaba
dentro del menú de Microsoft Visual Basic 5.0 una opción que decía Libros en línea, que a
través de hipertexto dinámico proporcionaba la documentación del producto. En la versión 6.0,
tiene que instalar la MSDN Library Visual Studio 6.0 (otro producto) para disponer de ayuda.
MSDN Library es una referencia técnica muy completa, de más de 1 GB de información de los
productos que integran Visual Studio 6.0; si usted está dispuesto a consumir más de 1 GB en
información de Visual C++, Visual Basic 6.0, Visual InterDev, Visual FoxPro, Visual J++ y
Visual SourceSafe, adelante. Por otro lado, puede decidir que no desea información de
productos que no le interesan, e instalar sólo la ayuda de Visual Basic con la finalidad de no
consumir mucho espacio en disco. Esto es posible, pero se puede llevar la sorpresa de que
algunos componentes compartidos por varios productos no se integren si usted solicita instalar
únicamente información de Visual Basic. O instala toda la información de MSDN Library que
comparten todos los productos de Visual Studio 6.0, o corre el riesgo que algo que necesite
consultar no se encuentre instalado.

Elementos del IDE
Una vez que haya abierto un proyecto como EXE estándar, aparecerá el IDE (vea la figura
1.2).

Nota: La distribución del IDE es bastante parecida en todos los productos de Visual Studio 6.0
(Visual C++, Visual InterDev, etcétera), así como en los módulos basados






10 Parte 1: Entorno Integrado de Desarrollo
en Visual Basic para Aplicaciones (nuevo manejo de macros de la Suite Microsoft
Office), por lo que identificarse con la distribución de los elementos para aprender
Visual Basic proporciona el beneficio adicional de reducir la curva de aprendizaje que
usted tendrá si desea aprender otras herramientas.


Figura 1.2
Entorno
Integrado de
Desarrollo












El IDE contiene todos los elementos y herramientas gráficas que Visual Basic pro-
porciona para desarrollar una aplicación.
No todos los elementos se requieren todo el tiempo, por lo que a través del menú Ver
puede decidir qué elementos desea utilizar, y por tanto, tener presentes en la pantalla.
Esto es importante porque en ocasiones el espacio en la pantalla es muy preciado.


Nota: Al estar desarrollando en Visual Basic, es importante disponer del mayor
número de elementos del IDE para realizar las tareas. Esto se dificulta en virtud de
que el espacio en la pantalla es reducido y los elementos aparecen demasiado amon-
tonados. Si desarrollará profesionalmente un monitor de 17" o más, sería una verda-
dera bendición; si su presupuesto no se lo permite, aumente la resolución máxima
soportada por su monitor, aunque su vista pedirá un poco de piedad ante lo diminuto
de ciertas figuras.









Capítulo 1: Visual Basic como plataforma de desarrollo 11
Visual Basic respeta las preferencias del desarrollador, de tal forma que si distribuye en
la pantalla los elementos del IDE a su gusto, la próxima vez que inicie sesión en Visual
Basic, los elementos del IDE se encontrarán donde los dejó la última vez.
>> Cómo activar los elementos del IDE. [01.03]
A continuación aprenderá a activar los elementos del IDE.
Para activar los elementos del IDE que no se encuentren actualmente en la pantalla,
haga lo siguiente:
1. Abra un nuevo proyecto EXE estándar de Visual Basic.
2. Seleccione el menú Ver — Explorador de proyectos (Ctrl+R).
3. Seleccione el menú Ver — Ventana Propiedades (F4).
4. Seleccione el menú Ver — Ventana Posición del formulario.
5. Seleccione el menú Ver — Cuadro de herramientas.




Nota: Observe detenidamente las figuras que aparecen a la izquierda de las op-
ciones que se encuentran en el menú Ver. Esto es importante porque dichas figuras
también se encuentran en la barra de herramientas, por lo que puede hacer clic en
ellas para activarlas en lugar de utilizar la barra de menús.

El IDE se compone de los siguientes elementos:
• La barra de menús
• La barra de herramientas Estándar
• El Diseñador de formularios
• La ventana Propiedades
• La ventana Posición del formulario
• La ventana Explorador de proyectos
• El Cuadro de herramientas





12 Parte 1: Entorno Integrado de Desarrollo

A continuación se definirán cada uno de los elementos del IDE, así como los con-
ceptos que están asociados con él y que son indispensables para comprender su uti-
lidad.
La barra de menús
La barra de menús (vea la figura 1.3) proporciona los menús que contienen
comandos que Visual Basic tiene disponibles para su uso en aplicaciones
desarrolladas, o para la administración de su propio entorno.
Figura 1.3
La barra
de menús



La barra de herramientas
La barra de herramientas (vea la figura 1.4) es un conjunto de botones que pro-
porcionan un acceso rápido a comandos más comunes que Visual Basic tiene dispo-
nibles para su uso en aplicaciones desarrolladas o para la administración de su
propio entorno.
Figura 1.4
La barra de herramientas


Nota: La existencia de la barra de herramientas sigue con la tradición de los pro-
gramas basados en Windows. Seguramente usted reconocerá algunos botones que
son estándar para todas las aplicaciones, como Abrir, Guardar, Cortar, Copiar,
Pegar y Deshacer.












Capítulo 1: Visual Basic como plataforma de desarrollo 13

Figura 1.5
Formulario
Todo proyecto en Visual Basic inicia y se desarrolla en un formulario; un formulario
es una ventana, tal y como las hemos utilizado toda la vida; en ella pueden encon-
trarse objetos que responden a nuestras acciones, pueden minimizarse, maximizarse,
cerrarse, etcétera (vea la figura 1.5).

Un formulario es un objeto contenedor, es decir puede contener a otros objetos, en
este caso, botones de comando, cuadros de texto, imágenes, botones de opción,
etcétera.
Modos de trabajo con formularios: SDI y MDI
En Visual Basic existen dos modos de trabajo con formularios:
• Interfaz de Documentos Simples (SDI). Una aplicación SDI se compone de un
solo formulario; al cerrar el formulario se cierra la aplicación. Un ejemplo puede ser
la aplicación Notepad.exe de Windows. Sólo permite editar un documento a la vez
y si cierra el documento se cierra la aplicación.
• Interfaz de Documentos Múltiples (MDI). Una aplicación MDI se compone de
un formulario maestro y éste puede contener uno o más formularios. Un ejemplo








14 Parte 1: Entorno Integrado de Desarrollo
de este upo de aplicaciones es WinWord.exe; se pueden tener muchos
documentos abiertos al mismo tiempo, y cada uno es un formulario. Al cerrar un
documento (formulario dependiente) no necesariamente se cierra Word
(formulario maestro).

Trabajemos en SDI o MDI, siempre habrá un formulario principal (objeto inicial).
La diferencia entre SDI y MDI es que en SDI el formulario maestro es el único que
existe.

Podemos configurar el entorno de Visual Basic de tal forma que resulte conveniente
para el trabajo, dependiendo de si elaboramos una aplicación SDI o MDI. Actual-
mente tenemos el entorno adecuado para MDI, pero los primeros programas que
desarrollaremos serán de un solo formulario, por lo que resultaría conveniente cam-
biar el entorno a SDI. De manera predeterminada Visual Basic se instala en MDI.
>> Cómo establecer el entorno de desarrollo a SDI. [01.04]

A continuación aprenderá a establecer su entorno de desarrollo en modo SDI.
Observe el entorno tal y como lo tiene actualmente.
1. Seleccione el menú Herramientas - Opciones... - Avanzado. Aparecerá el cuadro de
diálogo que se muestra en la figura 1.6.
2. Active la casilla de verificación Entorno de desarrollo SDI.

3. Haga clic en el botón de comando Aceptar.



Capítulo 1: Visual Basic como plataforma de desarrollo 15
La modificación que acaba de realizar requiere iniciar nuevamente la sesión en Visual
Basic. Aparecerá la ventana Microsoft Visual Basic (vea la figura 1.7), informándole
ese hecho.



Figura 1.7
Mensaje de
Visual Basic
4. Haga clic en el botón de comando Aceptar cuando Visual Basic le informe que el
cambio de la opción MDI/SDI será efectivo la próxima vez que inicie el entorno
de desarrollo.
5. Cierre la sesión de Visual Basic.
6. Inicie Basic nuevamente una sesión en Visual.
7. ¿Qué cambios nota en el entorno?



8. En el menú Herramientas - Opciones - Avanzado, desactive la casilla de veri-
ficación Entorno de desarrollo SDI, cierre la sesión y vuelva a entrar, para dejar
el entorno como estaba.

Entre los beneficios que puede obtener al desarrollar en SDI, es que los elementos
del IDE se comportan como ventanas independientes de Windows, muy conveniente
si considera que en MDI el hecho de mover o cambiar el tamaño de los elementos en
ocasiones resulta un problema, pues se ajustan entre sí (se acoplan) de manera arbi-
traria y complican la distribución de los objetos en la pantalla.


Nota: El acople inesperado de los elementos del IDE, en SDI o MDI, se controla
desde el menú Herramientas - Opciones - Acople. El modo SDI se ajusta más a lo
que queremos del entorno de desarrollo en estos momentos; sin embargo, mantendre-
mos la configuración predeterminada de Visual Basic, es decir, MDI. Es sólo
cuestión de práctica dominar ambos modos.






16 Parte 1: Entorno Integrado de Desarrollo

Tecnología orientada a objetos y Visual Basic
Al inicio del capítulo decíamos que Visual Basic es una mezcla de tecnologías. La
más importante de ellas es la tecnología orientada a objetos, ya que en Visual Basic
todo termina siendo un objeto.
Aprendamos un poco al respecto, ya que nos ayudará mucho para entender cómo
desarrollar eficientemente utilizando Visual Basic. Esta práctica requiere de mucha
imaginación; de ser posible genere en su mente las imágenes de lo que vamos a men-
cionar a continuación.
• Usted está sentado en una silla, frente a un escritorio.
• Sobre ese escritorio se encuentran dos cosas: un sombrero de mago y un botón rojo.
• Al presionar el botón rojo que se encuentra sobre el escritorio, del sombrero del
mago sale un conejo. A dicho conejo usted le llama "Fred".
• Usted presiona nuevamente el botón rojo y sale otro conejo igual al anterior, al cual
usted llama "Angus".
• En este momento sobre el escritorio se encuentran dos conejos, de igual color, ta-
maño y peso (mismas propiedades), y éstos corren alegremente sobre el escritorio.
• Sólo los puede diferenciar por el nombre, pero como saltan de un lugar a otro, es
posible que en un momento determinado no sepa quién es Fred y quién es Angus.
• A usted le gustaría que Fred fuera más pequeño, y de otro color que Angus.
• Usted toca a Fred y como por arte de magia (y como en nuestra imaginación todo
es posible), Fred se transforma en un conejo más pequeño y de un color diferente
que el de Angus.
Volvamos a lo técnico. En un mundo orientado a objetos, tenemos que:
• Lo que sale del sombrero del mago cada que presiona el botón rojo es un animal
de una naturaleza bastante definida, en este caso, un Conejo. Decimos entonces
que Conejo es una clase.
• Debido a que se presionó dos veces el botón rojo, se generaron dos instancias de
la clase. A las instancias de una clase las llamamos objetos.
• La clase define todas las propiedades que heredarán los conejos, es por ello que
Fred y Angus son iguales, y sólo se diferencian por el nombre, ya que no
puede haber dos objetos con el mismo nombre.















Capítulo 1: Visual Basic como plataforma de desarrollo 17
• Fred y Angus no son inertes, por sí mismos hacen algo, a veces saltan en el escritorio.
Lo que ellos pueden hacer por sí mismos se le llama método. Los métodos que un
objeto puede realizar, son sólo aquellos que la clase tiene definidos y permitidos. Ni
Fred ni Angus pueden ladrar; no está en su clase.
• A Fred le sucedió una transformación, que no se llevó a cabo sino hasta que usted lo
tocó. Lo que le sucede a un objeto por el hecho de interactuar con usted, se le llama
evento. Los eventos que le pueden suceder a un objeto, son sólo aquellos que la clase
tiene definidos y permitidos.
• La clase Conejo existe, pero no se manifiesta sino a través de sus instancias, mismas
que son generadas solamente a través del uso del botón rojo. Si no se presiona el botón
rojo, no hay conejos en el escritorio. Al elemento que sirve para crear la instancia de
una clase se le denomina control.
• El escritorio sería el objeto contenedor de los objetos. Cumple con la misma función
que cumplirá el formulario en sus aplicaciones de Visual Basic.
Suponga que Angus se queda inmóvil, gráficamente tendríamos lo siguiente:


Figura 1.8
Esquema de
clase – objeto-
propiedad









18 Parte 1: Entorno Integrado de Desarrollo
Controles
Los controles son representaciones gráficas que permiten generar elementos de inter-
faz de Windows, tales como botones de comando, cuadros de texto, gráficos, listas
desplegables, etiquetas, etcétera. Estos controles invocan una clase determinada, con
base en la cual se generan objetos con una forma y comportamiento predefinido. Los
controles en Visual Basic se encuentran en el elemento IDE llamado Cuadro de he-
rramientas.
Clase
Una clase es la definición formal de un elemento de interfaz de Windows. Una clase
actúa como plantilla para cada una de las instancias generadas a partir de un deter-
minado control cuando es agregado a un formulado; la clase define las propiedades de
un objeto y los métodos y eventos utilizados para controlar su comportamiento. Visual
Basic trata los términos clase y control como uno solo, ya que la clase no se manifiesta
sino a través de un control.


Objetos
Los objetos son ocurrencias de una clase en un formulario. Son controles una vez que
son insertados en una aplicación; el desarrollador les dará las propiedades que necesite
y el comportamiento que requiera. Puede haber un solo control llamado
CommandButton, pero muchos objetos generados a partir de él, es decir, múltiples
botones en el formulario.
Por cuestiones prácticas, en ocasiones los términos control y objeto se utilizan como
sinónimos; es posible usarlos de esta manera, pero no pierda de vista que son dife-
rentes. Un control es un medio para generar un objeto; un objeto es una ocurrencia del
control (que a su vez es el ejercicio de una clase), con nombre, tamaño, colores y otras
especificaciones particulares.

Nota: No somos partidarios del uso como sinónimos de las palabras "Objeto" y
"Control", porque evidentemente no son lo mismo. No obstante. Visual Basic tiene
muchos mensajes del sistema que utilizan dichos términos como equivalentes, y en la
ayuda en línea en ocasiones los utilizan de manera indistinta.








Capítulo 1: Visual Basic como plataforma de desarrollo 19
Cuadro de herramientas


El Cuadro de herramientas (vea la figura 1.9) es la ventana que muestra todos los
controles disponibles para la generación de objetos en una aplicación de Visual Basic.
El Cuadro de herramientas debería llamarse cuadro de controles, pero por cuestiones
históricas del producto su nombre persiste.

Figura 1.9
Cuadro de
herramientas
Los controles están representados de manera gráfica; por ejemplo, el control Label
está representado por una letra "a" mayúscula (A).
Si desconoce qué representación gráfica le corresponde a un determinado control, sólo
coloque el puntero del ratón sobre las figuras del Cuadro de herramientas, y
aparecerá un texto identificando el control del que se trata. Dicho texto se conoce
como Información sobre herramientas.

Nota: Visual Basic tiene una capacidad de expansión increíble; tal vez su carac-
terística más sobresaliente, base de su éxito, sea la de integrar controles de terceros







20 Parte 1: Entorno Integrado de Desarrollo
(conocidos como controles ActiveX u OCX). Al integrar un control ActiveX, su repre-
sentación gráfica se agregará al Cuadro de herramientas, por lo que es comprensible
que la misma no siempre luzca igual.
Si tiene la necesidad de un control que no está en el Cuadro de herramientas, puede
buscar entre los controles ActiveX que tiene en su equipo, y si no lo tiene, puede com-
prar uno que alguien haya hecho (hay cientos en el mercado, casi siempre orientados a
una determinada función, como estadística, graficación, bases de datos, etcétera.) En el
peor de los casos, si el control que necesita no ha sido desarrollado por terceros o no
quiere pagar por él, tiene la opción de desarrollarlo usted mismo.
Aunque tal vez sobre decirlo, Microsoft no se hace responsable de los controles que no
vienen integrados en Visual Basic de manera intrínseca.

Los controles que aparecen en el Cuadro de herramientas de manera intrínseca y
como parte del IDE, pueden dividirse en las siguientes categorías:
• Controles básicos: Definen objetos que permiten elaborar una interfaz de usuario
básica.
Label
TextBox
CommandButton
• Controles de selección: Definen objetos que permiten elegir un valor sin que sea
necesario teclear nada.
OptionButton
CheckBox
ComboBox

ListBox
HScrollBar
VScrollBar










Capítulo 1: Visual Basic como plataforma de desarrollo 21
• Controles contenedores: Definen objetos que pueden contener a otros objetos.
Frame
• Controles gráficos: Definen objetos que permiten el manejo de gráficos e imágenes.
PictureBox (también es contenedor)
Image
Shape
Line

• Controles de gestión de archivos: Definen objetos que permiten gestionar el sistema
de archivos de la máquina.
DriveLlstBox
DirListBox
FileListBox
• Controles de tiempo: Definen objetos que permiten manejar intervalos de ejecución
de una aplicación.
Timer
• Controles de datos: Definen objetos que permiten tener acceso a bases de datos.
Data
• Controles de vínculo: Definen objetos que permiten tener acceso otras aplicaciones o
funciones dentro del sistema.
OLE





22 Parte 1: Entorno Integrado de Desarrollo
Los controles que aparecen en el Cuadro de herramientas pueden incrementarse en la
medida en que se necesiten. En su momento verá cómo incluir algunos de suma
utilidad.

Nota: Si no tiene un formulario activo, los controles no aparecerán en el Cuadro de
herramientas. Esto es lógico, ya que no tiene en dónde insertar las ocurrencias de los
controles, es decir, los objetos.
>> Ubicación de los controles. [01.05]
A continuación aprenderá a identificar los controles mediante la consulta de los
Información sobre herramientas.


1. Si coloca el puntero del ratón sobre las imágenes del Cuadro de herramientas,
aparecerá información relativa al control del que se trata (esta información es llamada
Información sobre herramientas [vea la figura 1.10]).







Figura 1.10
Información sobre
herramientas: le
ayuda a identificar
los controles del
cuadro de
herramientas
Información sobre
herramientas
























Capitulo 1: Visual Basic como plataforma de desarrollo 23
2. Coloque al lado de cada una de las figuras representativas de los
controles, la Información sobre herramientas que aparece al colocar
el puntero del ratón sobre cada control.



Propiedades
Cada uno de los objetos que conforman un formulario, desde el formulario mismo
hasta los botones de comando, cuadros de texto, botones de opción, cuadros de imá-
genes, y demás objetos contenidos en él, tienen características particulares que los
hacen diferentes uno de otro. A estas características se les llama propiedades; las
propiedades le indican a Visual Basic la posición de un objeto en el formulario, su
nombre, alto, ancho, comportamiento inicial, valor predeterminado, etcétera.














24 Parte 1: Entorno Integrado de Desarrollo
Quizá la propiedad más importante sea la que identifica a los objetos dentro de una
aplicación: Name. Esta propiedad permite referir a un objeto determinado al momento
de programar en Visual Basic.

Métodos
Los métodos son órdenes predefinidas que realizan tareas específicas sobre los objetos.
Los métodos son muy útiles porque permiten manipular los objetos y sus carac-
terísticas asociadas.
Los objetos se crean en tiempo de diseño y en tiempo de ejecución se modifican las
características de estos objetos (propiedades) y se ejecutan tareas sobre los objetos
(métodos).

Ejemplificación de objeto - propiedad - método
Suponga que tiene un objeto llamado "Saxofón".

Saxofón
Dicho objeto podría tener muchas características, tales como tamaño, color, marca,
etcétera. Actualmente aparece en color blanco, por lo que puede interpretarse que la
propiedad Color del objeto Saxofón es igual a Blanco.
Para Visual Basic eso se codificaría de la siguiente manera:
Saxofón. Color = Blanco
Cambiar una propiedad modifica al objeto, por ejemplo, si cambiamos la propiedad
Color del objeto Saxofón a Amarillo, obtendríamos lo siguiente:







Capítulo 1; Visual Basic como plataforma de desarrollo 25



Saxofón. Color = Amarillo
En Visual Basic es una regla de sintaxis que las propiedades se refieran en conjunto
con el objeto al que pertenecen y se separan por un punto. En elcaso "Saxofón.
Color", "Color" es la propiedad del objeto "Saxofón".
Los métodos se refieren de la misma forma que las propiedades, pero éstos en lugar de
establecer una característica para un objeto, realizan una tarea sobre o a través del
objeto. Un método posible a través del objeto Saxofón es que éste toque música.
Por ejemplo:

Saxofón.TocarMúsica
Explorador de proyectos
La ventana Explorador de proyectos es una ventana que muestra los componentes del proyecto
Visual Basic, llamados módulos. A través de esta ventana puede ubicar y activar cualquier
módulo del proyecto; esto es especialmente útil cuando el proyecto se hace muy grande y que
cuenta con muchos módulos, de tal manera que resulta incómodo tener presente a todos los
componentes del proyecto en la pantalla.
Los módulos que se pueden tener en la ventana Explorador de proyectos son:
• Módulos de formulario (extensión .FRM). Puede contener objetos y los valores de sus
propiedades. También puede contener declaraciones a nivel formulario
26 Parte 1: Entorno Integrado de Desarrollo
de constantes, variables y procedimientos externos, procedimientos de evento, y
procedimientos generales.
• Módulos de clase (extensión .CLS). Son similares a los módulos de formulario,
a excepción de que no tienen una interfaz visible.
• Módulos estándar (extensión .BAS). Pueden contener declaraciones públicas o
a nivel módulo de tipos de datos, constantes, variables, procedimientos externos
y procedimientos públicos.



Figura 1.11
Ventana
Explorador
de proyectos
La ventana Explorador de proyectos muestra una estructura de jerarquía
similar a la del Explorador de Windows; los componentes que se pueden
seleccionar se encuentran a nivel módulo. En la figura 1.11 se puede apreciar
que está seleccionado el único formulario, Form1 (Form1), que se tiene en
el proyecto.
En la parte superior de la ventana aparecen tres botones:
• Ver código. Permite ver el código que se ha escrito del módulo que está
seleccionado.
• Ver objeto. Permite ver el objeto en el IDE.
• Alternar carpetas. Oculta y muestra las carpetas en el Explorador de
proyectos.
>> Cómo ocultar y mostrar formularios. [01.06]
A continuación aprenderá a ocultar y mostrar formularios utilizando la ventana Ex-
plorador de proyectos.












Capítulo 1: Visual Basic como plataforma de desarrollo 27
1. En este ejercicio asumimos que tiene un proyecto EXE estándar abierto. Si no lo
tiene, inicie sesión en Visual Basic.
2. En la jerarquía de elementos que aparece en la ventana Explorador de proyectos,
ubíquese donde aparece Proyecto1 (Proyecto1). Al lado izquierdo aparece un
pequeño símbolo, que puede ser de más (+) o de menos (-), dependiendo de si la
jerarquía está expandida o comprimida.
3. Haga clic en el símbolo hasta que se coloque un símbolo de más (+). Esto significa
que se comprimirá la jerarquía.
4. ¿Qué sucede con el formulario?



5. Expanda la jerarquía haciendo clic en el símbolo que aparece a la izquierda, tanto
en Proyecto1 (Proyecto1) como en Formularios, hasta que ambos sean
símbolo de menos (-).
6. Seleccione Form-1 (Form-1). El
formulario se desplegará.

7. Haga clic en el botón Ver objeto.
La utilidad de estas funciones se apreciará cuando veamos proyectos MDI, en
donde hayan varios formularios en el mismo proyecto.
Tiempos de desarrollo de Visual Basic
El IDE de Visual Basic le permite diseñar la interfaz que utilizará para realizar una
determinada tarea. Esto lo logra agregando objetos a los formularios, estableciendo
propiedades a los objetos, agregando código, etcétera. Prácticamente "dibuja" la in-
terfaz.
Una vez que concluye el diseño de la interfaz, puede poner en ejecución la interfaz
diseñada; en dicha ejecución puede modificar algunas cosas establecidas en tiempo
de diseño, por lo que es posible que el diseño se pueda afectar en tiempo de ejecu-
ción. Prácticamente se modifica "lo dibujado" con anterioridad.
En conclusión, en Visual Basic se determinan dos tiempos de desarrollo:
• Tiempo de diseño. Son las labores de desarrollo de aplicaciones que se realizan a
través del IDE, con la disponibilidad de todos sus elementos.



















28 Parte 1: Entorno Integrado de Desarrollo
• Tiempo de ejecución. Son las labores de desarrollo de aplicaciones que se reali-
zan durante la ejecución de un formulario, a través de código.

¿Cómo saber en qué tiempo se encuentra? Muy simple, si está utilizando el IDE con
la disponibilidad de todos los elementos para su uso, está en tiempo de diseño; si
está ejecutando un formulario y no dispone de todos los elementos del IDE para su
uso, está en tiempo de ejecución. Otra forma más fácil de saberlo es la siguiente: en
tiempo de diseño, en la ventana principal de Visual Basic aparecerá la palabra
"diseño". Más obvio no podía ser.

Hay cosas que sólo se pueden hacer en tiempo de diseño, por ejemplo, asignar el
nombre a los objetos, y hay otras cosas que sólo se pueden hacer en tiempo de
ejecución, como ver la Información sobre herramientas establecida para un
determinado objeto. En tiempo de diseño todo se hace visualmente, mediante el uso
de elementos del IDE, tales como el Cuadro de herramientas o la ventana
Propiedades; en tiempo de ejecución, todo se hace mediante el código que forma
parte del formulario.

Ya que conocemos los tiempos de desarrollo de Visual Basic, podemos establecer
una diferencia entre las propiedades y los métodos; las propiedades pueden
establecerse en modo de diseño y, la mayoría de las veces, también en tiempo de
ejecución. En cambio, los métodos no pueden ejecutarse más que en tiempo de
ejecución.
============================================================
Nota: En capítulos posteriores de este libro se explicarán los controles que se en-
cuentran en el Cuadro de herramientas. Se profundizará en cuáles son sus propie-
dades más útiles, así como los métodos más importantes que les aplican.
============================================================
Ventana Propiedades
La ventana Propiedades (vea la figura 1.12) es aquella en donde se identifica un
objeto y en donde se pueden modificar en tiempo de diseño las propiedades de dicho
objeto. Sus componentes son:
• Lista desplegable de objetos
• Cuadrícula de propiedades
• Cuadro de información de propiedades















Capitulo 1: Visual Basic como plataforma de desarrollo 29

Figura 1.12
Ventana Propiedades


En la parte superior de la ventana Propiedades siempre se muestra una lista desple-gable, llamada
Lista desplegable de objetos (vea la figura 1.13); esta lista contiene el nombre del objeto activo (que
se encuentra en negritas) y el tipo de control en el que está basado dicho objeto (Form).
Figura 1.13
Lista desplegable
de objetos



Posteriormente, se encuentra una lista de propiedades válidas para el objeto que se
está modificando; la distribución consiste en dos columnas, que forman la Cua-
drícula de propiedades. Las propiedades se encuentran clasificadas alfabéticamente
o por categorías; dicha lista aparece en forma de cuadrícula: en la columna izquierda
se muestra el nombre de las propiedades, y en la columna derecha aparecen los valo-
res que de manera predeterminada se le asignan a un objeto (vea la figura 1.14).



















30 Parte 1; Entorno Integrado de Desarrollo


Figura 1.14
Cuadrícula de
propiedades

Algunos valores de las propiedades se pueden modificar directamente, editando el
valor que aparece en la columna derecha de la propiedad que queremos modificar;
algunas propiedades tienen valor abierto, es decir, se puede colocar cualquier cosa
como valor, mientras que otras propiedades tienen valor limitado, es decir, tienen un
universo reducido de valores válidos que les pueden ser asignados, mismos que
aparecerán a manera de listas desplegables. De una u otra forma. Visual Basic siempre
sugiere, a través de los valores predeterminados, qué tipo de valor puede asignarse a
cada propiedad (texto, número, booleano, representación hexadecimal) y si el valor es
abierto o limitado.
En la parte inferior de la ventana Propiedades aparece el nombre de la propiedad en
la que está trabajando y la explicación de su utilidad, es decir, para qué sirve. A esta
área se le conoce como Cuadro de información de propiedades.
Uso de la ventana Propiedades. [01.07]
A continuación aprenderá algunas de las capacidades de la ventana Propiedades.
1. Observe los gráficos utilizados en este texto y apóyese en el proyecto que actualmente
tiene en su computadora. Haga clic en el formulario que se encuentra en su IDE.
Conteste lo siguiente:

a) La ventana Propiedades
indica que está trabajando sobre
un objeto. ¿Cómo se llama?
(Identifíquelo por el texto en negritas en
la Lista desplegable de objetos;
también basta con ver el título de la
ventana Propiedades, que dirá
Propiedades - <nombre del objeto>.)










Capítulo 1: Visual Basic como plataforma de desarrollo 31



b) ¿Qué tipo de control es?
(Identifíquelo por el texto que no
está en negritas en la Lista
desplegable de objetos.)

c) ¿Está viendo la Lista de
propiedades alfabéticamente o
por categorías?

d) ¿La propiedad Caption es
de valor abierto o limitado?


e) ¿La propiedad
Appearence es de valor
abierto o limitado?

f) ¿Cuáles son los 3 valores
posibles que puede tener la
propiedad PaletteMode?


g) Mencione para qué sirve la
propiedad
StartUpPosition.
(Consulte el Cuadro de información
de propiedades.)



El contenido de la ventana Propiedades dependerá del objeto que tenga seleccionado,
es decir, las propiedades que aparecen al tener seleccionado un objeto basado en el
control Form no son las mismas que aparecen cuando selecciona otro objeto basado en
el control TextBox.
Si no tiene seleccionado ningún objeto, la ventana Propiedades estará vacía.
Ventana Posición del formulario
En versiones anteriores de Visual Basic, era muy importante la posición en la que se
encontraba la ventana al estar en tiempo de diseño, ya que dicha posición determinaba
el lugar en donde el formulario se ubicaría al ejecutar la aplicación. En Visual Basic
6.0 la posición del formulario en tiempo de diseño es irrelevante, ya que existe una
ventana llamada Posición del formulario (vea la figura 1.15).




32 Parte 1: Entorno Integrado de Desarrollo


Figura 1.15
Ventana posición
del formulario



En la ventana Posición del formulario aparece representada la pantalla de un monitor
y el formulario que está diseñando dentro de ella; usted puede determinar dónde
quiere que aparezca su formulario en el momento en que sea ejecutado, arrastrando la
pequeña representación de su formulario dentro de la representación de la pantalla.

Pasos para crear una aplicación en Visual Basic
Para desarrollar una aplicación en Visual Basic, desde no tener nada hasta tener los
discos de distribución de su aplicación, transcurren siete pasos básicos:
• Crear la interfaz de usuario. Consiste en dibujar la interfaz con la que el usuario
va a interactuar. En este paso, lo importante es colocar en la interfaz la cantidad
suficiente de objetos, con los tamaños adecuados y la organización óptima para que
su uso sea más fácil.
• Establecer las propiedades de los objetos. Consiste en asignar los valores de
inicio para cada uno de los objetos, mismos que determinan la apariencia y com-
portamiento de dichos objetos.
• Escribir el código de los eventos. Consiste en escribir el código que ha de eje-
cutarse como respuesta a algo que sucede en la interfaz del usuario.
• Guardar el proyecto. Consiste en guardar, en algún medio de almacenamiento, el
proyecto que esté creando. Guarde su trabajo con regularidad, a efecto de reducir al
máximo el riesgo de perderlo.
• Probar y depurar la aplicación. Consiste en ejecutar la aplicación que ha creado,
detectar errores y corregirlos.
















Capítulo 1: Visual Basic como plataforma de desarrollo 33

• Compilar el ejecutable (EXE). Consiste en procesar la aplicación a efecto
de que se pueda ejecutar de manera independiente al entorno de desarrollo de
Visual Basic.
• Crear los discos de instalación. Consiste en utilizar el Asistente para empa-
quetado y distribución, a efecto de crear los discos que instalen su aplicación
de manera profesional.

Cada uno de estos pasos se explicará en los capítulos subsecuentes; el paso de
crear los discos de instalación se verá cuando tengamos un ejemplo lo
suficientemente representativo para la tarea.
La explicación se hará a través de su primer programa en Visual Basic, que
comenzará en el siguiente capítulo.

________________________________________________________________________
Resumen

En este capítulo:
• Vimos cuál es el objeto de la programación.
• Vimos por qué Visual Basic es más que un simple lenguaje de programación.
• Vimos de manera esquemática los conceptos que definen la orientación a
objetos de Visual Basic.
• Identificamos todos y cada uno de los componentes del IDE y explicamos para
qué sirven (no se preocupe por saber cómo se utilizan; en los siguientes capítu-
los lo sabrá).
• Vimos qué ediciones tiene Visual Basic 6.0.
• Vimos qué controles se encuentran disponibles en el Cuadro de herramientas
y a qué categoría pertenecen.
• Vimos en qué consisten los modos SDI y MDI.
• Vimos cuáles son los tiempos de desarrollo en Visual Basic.
• Vimos los conceptos objeto, control, propiedad, método y la relación que
guardan entre ellos.
• Vimos cuáles son los pasos para desarrollar una aplicación en Visual Basic.
Antes de seguir, es importante que domine todos los puntos anteriores.










34 Parte 1: Entorno Integrado de Desarrollo

Algunas respuestas a los ejercicios
[01.04] Cómo establecer el entorno de desarrollo a SDI.
7. Los elementos del IDE aparecen como ventanas independientes. Ya no hay una
ventana que contenga todos los elementos.
[01.06] Cómo ocultar y mostrar formularios.
3. Desaparece.
[01.07] Uso de la ventana Propiedades.
a) Forml.
b) Form.
c) Alfabéticamente.
d) Abierto.
e) Limitado.
f) Halftone, UseZOrder, Custom.

g) Devuelve o establece un valor que especifica la posición de un formulario cuando
aparece por primera vez.
























Capítulo
2
Creación de la interfaz
de usuario


Objetivo
Conocer los pasos para crear una interfaz de usuario efectiva para una aplicación
de Visual Basic.
Al finalizar este capítulo deberá:
• Saber cómo insertar objetos
• Saber cómo trazar objetos
• Conocer la forma de establecer la posición y las dimensiones de un objeto
• Conocer la forma en que se manejan las opciones del menú Formato
• Saber cómo manejar la ventana Posición del formulario
• Felicidades: comenzará a desarrollar su primer proyecto de Visual Basic
En este capítulo comenzará a desarrollar su primer programa; quizá piense "en
otros libros desde el primer capítulo se crea un programa". No se desespere: la
diferencia entre "copiar" un programa de un libro sin entenderlo y "hacer" un
programa es mucha. Preferimos que desarrolle una aplicación con todo el
conocimiento posible, de tal forma que pueda reproducir los procedimientos sobre
aplicaciones basadas en necesidades propias cuando así lo requiera.
Le aseguramos que una vez que haya visto los pormenores de la programación en
Visual Basic con el primer ejemplo, el libro tomará velocidad con respecto a los
demás
35











36 Parte 1: Entorno Integrado de Desarrollo
ejemplos, y lo mejor de todo, usted podrá ir a la misma velocidad que el libro, para
después ya no depender de él.

El punto de partida: ¿Qué desea hacer?
Para crear su aplicación, debe revisar el producto del análisis (saber qué quiere) y
comenzar el diseño.
Su primer programa será algo muy simple, pero que nos permitirá revisar todo el
proceso de desarrollo de aplicaciones en Visual Basic.
La figura 2.1 muestra la forma en que se debe ver la interfaz a diseñar.

Figura 2.1
interfaz a diseñar.

La figura 2.2 muestra lo que debe suceder cuando haga clic en el botón de comando
Mostrar Mensaje.
Figura 2.2
Respuesta
esperada al hacer
clic en Mostrar
Mensaje.

Al hacer clic en el botón de comando Salir, la aplicación deberá cerrarse.






Capítulo 2: Creación de la interfaz de usuario 37

Paso 1: Crear la interfaz de usuario
Los objetivos de este paso son los siguientes:
• Tener la cantidad de objetos necesarios para hacer lo que se quiere con la
aplicación. En la interfaz sólo debe tener los objetos que necesita; colocar objetos
innecesarios sólo hace confusa su interfaz y hace que su aplicación sea más
demandante de recursos, principalmente memoria RAM. La pregunta básica aquí
es: ¿cuántos objetos se necesitan para realizar la tarea?
• Tener los tipos de objetos adecuados para hacer lo que se quiere con la apli-
cación. Los objetos creados a partir de un determinado control tienen una deter-
minada función (TextBox, introducir datos; OptionButton, seleccionar una
opción; Label. mostrar un texto, etcétera.). Pretender realizar con un objeto una
tarea contraria a su naturaleza puede complicar el uso de la interfaz; una mala
elección de objetos puede hacer de su labor de desarrollo una pesadilla; no hay que
pedirles a los controles un imposible. La pregunta básica aquí es: ¿en qué controles
nos basaremos para definir los objetos?
• Definir la posición y las dimensiones adecuadas para los objetos. Es importante
colocar los objetos de acuerdo a una distribución que sea apegada a los estándares
del entorno de trabajo en Windows, con dimensiones proporcionadas, bien
alineadas. Para tomar ideas, analice los programas basados en Windows,
principalmente los desarrollados por Microsoft (Excel, Word, PowerPoint, et-
cétera), y vea cómo están distribuidos los objetos en los cuadros de diálogo. La
pregunta básica aquí es: ¿dónde debemos colocar los objetos y de qué tamaño?
• Distribución funcional. Los objetos deben estar distribuidos de tal forma que
faciliten el uso de la interfaz. La pregunta básica aquí es: ¿la captura se realiza de
manera natural y sencilla? Responder "NO" a esta pregunta es inadmisible.

Inserción de objetos
Si quisiera desarrollar la aplicación de la figura 2.1, requerirá lo siguiente:

• Un control Form en donde colocar el resto de los objetos. El formulario es una
ventana.
• Un control Label donde mostrar el mensaje.
• Un control CommandButton que al hacer clic en él muestre el mensaje en la eti-
queta.
• Un control CommandButton que permita salir de la aplicación.







38 Parte 1: Entorno Integrado de Desarrollo

Total de objetos requeridos: 4
Tipos de objetos requeridos: 1 Form
1 Label
2 CommandButton
>> Cómo insertar un objeto en la interfaz. [02.01]
A continuacióna aprenderá cómo insertar objetos en un formulario.
1. Inicie una sesión de Visual Basic y genere un nuevo proyecto EXE estándar.
2. En la ventana principal de Visual Basic (donde se encuentra la barra de menús y
la barra de herramientas Estándar) debe aparecer el encabezado Proyectol -
Microsoft Visual Basic (diseño). En este caso, Proyectol es el nombre que
Visual Basic les asigna de manera predeterminada a los proyectos al inicio. Tome
en cuenta que trabajaremos con proyectos EXE estándar solamente, hasta que
las necesidades del libro marquen lo contrario.
3. Aparecerá un formulario en blanco. En un proyecto de tipo EXE estándar siem-
pre debe existir al menos un formulario, por lo que al crear un proyecto de ese
tipo siempre dispondrá del primer objeto de la interfaz de usuario creada.

4.

Para insertar un objeto, haga doble che en el control CommandButton, que se
encuentra en el Cuadro de herramientas. Aparecerá un objeto de tipo Com-
mandButton en el centro del formulario (vea la figura 2.3); dicho objeto mostrará
el texto Cominandi (todos los objetos tienen valores predeterminados en Visual
Basic). Cuando agregamos un objeto haciendo doble che en un control del
Cuadro de herramientas, se dice que agregamos un objeto en modo de in-
serción.

============================================================
Nota: Si hace un solo clic, también puede insertar objetos, en lo que se llama modo
de trazo. Dicho modo será explicado más adelante en este capítulo; si hizo un solo
clic en lugar de doble clic, seguramente el puntero del ratón es una cruz delgada, que
indica que está en modo de trazo. Cancele este modo haciendo clic en el control
Puntero del Cuadro de herramientas. El control Puntero es el único del Cuadro
de herramientas que no genera un objeto en la interfaz.
============================================================












Capítulo 2: Creación de la interfaz de usuario 39


Figura 2.3
Objeto insertado al
hacer doble clic en
el control
CommandButton
del Cuadro de
herramientas


a) La ventana Propiedades indica
que está trabajando sobre un obje-
to. ¿Cómo se llama?

b) ¿En qué tipo de control está
basado?

c) El objeto que acaba de crear
tiene un nombre predeterminado.
¿Usted se lo asignó o lo hizo Visual
Basic?








Consideremos qué ha hecho hasta ahora:
• Creó un nuevo proyecto EXE estándar, por lo que se agregó un formulario nuevo. De
manera predeterminada, este formulario tiene diversas propiedades asignadas por
Visual Basic, entre las que se encuentran un nombre (Name), una posición (Top,
Left) y un tamaño predefinidos (Height, Width).













40 Parte 1: Entorno Integrado de Desarrollo
• Utilizando el Cuadro de herramientas agregó un objeto basado en el control
CommandButton. El objeto CommandButton, al igual que el formulario,
tiene diversas propiedades asignadas de manera predeterminada por Visual Basic,
entre las que se encuentran un nombre, una posición y un tamaño predefinidos.

En el formulario aparecerá un conjunto de puntos espaciados de forma regular, lla-
mados cuadrícula estándar. La cuadrícula estándar sólo aparece mientras está dise-
ñando su aplicación en el Entorno Integrado de Desarrollo (IDE), y sirve como refe-
rencia para distribuir los objetos de manera organizada y simétrica.
Nota: De manera predeterminada, los puntos de la cuadrícula están organizados cada
120 twips. Si desea modificar la distancia o eliminar la cuadrícula, seleccione
Herramientas - Opciones - General. Muy pronto sabrá qué es un twip.
El objeto CommandButton aparece bordeado por ocho recuadros llamados contro-
ladores de tamaño (vea la figura 2.4); éstos sirven para modificar las dimensiones de
un objeto.

Figura 2.4
Controladores
de tamaño

Arrastre hacia abajo para hacer
más ancho el objeto.
Arrastre hacia abajo para hacer
más ancho y más alto el objeto.
Arrastre hacia abajo para hacer
más alto el objeto.

Se le llama objeto activo al objeto sobre el cual está trabajando
actualmente. Los con-troladores de tamaño, además de permitir la
modificación de las dimensiones de un objeto, permiten identificar de
manera visual qué objeto es el que está activo; esto es muy importante, ya
que si no ubica con precisión a los objetos, puede estar trabajando con un
objeto que no quería trabajar, lo que sería tiempo perdido.
Una forma adicional para identificar qué objeto es el objeto activo, es
revisando la lista desplegable de objetos que se encuentra en la ventana
Propiedades (vea la figura 2.5), o bien, observando la barra de título de la
ventana Propiedades; esta última opción no es muy confiable, ya que es
inexacta cuando se tienen seleccionados varios objetos al mismo tiempo.






Capítulo 2: Creación de la interfaz de usuario 41

Es un objeto basado en
el control
CommandButton.
El objeto activo se llama
Command1.
El objeto activo será el que aparezca en la barra de título de la ventana Propiedades (en
este caso. Propiedades – Command1)

Propiedades de posición y dimensión

En Visual Basic no todos los objetos que se agregan en un formulario se ven en la
interfaz al ejecutar la aplicación, por lo que podemos decir que hay objetos visibles y
objetos invisibles en tiempo de ejecución; todos los objetos visibles que sean agregados
tendrán una posición dentro del formulario, así como un tamaño.

A las propiedades que determinan la posición de un objeto se les llaman propiedades de
posición, las cuales determinan el punto a partir del cual el objeto se comenzará a trazar,
a dibujar; dicho punto es llamado punto de inicio, y siempre es la esquina superior
izquierda del objeto. El tamaño del objeto está determinado por las propiedades de
dimensión, mismas que especifican la distancia entre el punto de inicio y la esquina
inferior derecha del objeto.

El tamaño de un objeto en Visual Basic está determinado en twips. Un twip es la vi-
gésima parte de un punto, y si consideramos que un punto es 1/72 de pulgada, un twip
sería 1/1440 de pulgada. No se quiebre la cabeza tratando de encontrar un significado
para "twip"; la unidad de medida pudo haberse llamado "xwin" o "flox", o como fuera.





42 Parte 1: Entorno Integrado de Desarrollo
Las propiedades de posición son:
Top Muestra la posición con respecto al margen superior de la pantalla
o del objeto contenedor.

Left Muestra la posición con respecto al margen izquierdo de la
pantalla o del objeto contenedor.
Las propiedades de dimensión son:
Height Altura del objeto.
Width Ancho del objeto.

La figura 2.6 muestra gráficamente cómo se interpretan las propiedades de
posición y las propiedades de dimensión. Vea como las dimensiones de Height
y Width comienzan a partir del punto de inicio.

Figura 2.6
Propiedades
de posición
y dimensión de
los objetos











Capítulo 2: Creación de la interfaz de usuario 43
Las formas para cambiar la posición de los objetos son:
• Arrastrando el objeto
• Utilizando las combinaciones de teclas Ctrl+<Flechas de dirección> Las formas para
cambiar el tamaño de los objetos son;
• Arrastrando los controladores de tamaño
• Utilizando las combinaciones de teclas Mayús+<Flechas de dirección>
>> Cómo cambiar la posición o las dimensiones de un objeto. [02.02]
A continuación aprenderá la forma de modificar las dimensiones y la posición a los objetos
que han sido agregados a un formulario.

1. Si no tiene seleccionado el objeto Command1, selecciónelo haciendo clic en el objeto.
Sabrá que el objeto está seleccionado si los controladores de tamaño se encuentran
alrededor de él. Observe dónde está ubicado y qué tamaño tiene.
==================================================================
Lo inesperado: Puede ser que queriendo seleccionar el objeto Command1 a través de un
clic, haya hecho doble clic. Si hace eso, aparecerá la ventana Código.
Aunque dicha ventana es muy importante, no es lo que queremos analizar en este momento,
por lo que deberá cerrarla. Presione Alt+F4, en tal caso.
==================================================================
2. En la ventana Propiedades localice las propiedades de posición y las propiedades de
dimensión; tome nota de los valores que tienen asignados en este momento.

Command1.Top = _____________________
Command1 .Left = _____________________
Command1.Height = _____________________
Command1.Width = _____________________










44 Parte 1: Entorno Integrado de Desarrollo

3. Arrastre el controlador de tamaño que se encuentra en la esquina inferior derecha del
objeto; trate de dejar el botón de comando al doble de su ancho y de su alto actual.
¿Qué valores tienen ahora las propiedades de dimensión?
Command1.Height = _____________________
Command1.Width = _____________________
4. Coloque el puntero del ratón en el centro del objeto y arrástrelo de tal forma que el
punto de inicio (esquina superior izquierda) quede cerca de la esquina superior
izquierda del formulario. ¿Qué valores tienen ahora las propiedades de posición?
Command1.Top = _____________________
Command1.Left = _____________________
5. Seleccione el objeto Command1 haciendo clic en él y presione la tecla Mayús y
manténgala presionada; al mismo tiempo utilice las teclas de movimiento (flechas)
hasta dejar el botón de comando de un tamaño similar al que tenía al inicio de esta
práctica. Suelte las teclas.

6. Presione la tecla Ctrl y manténgala presionada; al mismo tiempo utilice las teclas de
movimiento hasta dejar el botón de comando en la posición similar a la que tenía al
inicio de esta práctica. Suelte las teclas.

7. El botón de comando está en el centro del formulario; oriéntelo hacia la izquierda.
Ahora ya sabe cómo cambiar el tamaño y la posición de un objeto que se encuentra en un
formulario, ya sea con el ratón o con el teclado. ¿Y qué pasa con el formulario?
El formulario tiene algunas consideraciones especiales:

• Si el entorno se encuentra en modo SDI, el formulario no está dentro de ningún objeto
contenedor y al seleccionarlo no se colocan controladores de tamaño.
• Si el entorno se encuentra en modo MDI, el formulario está dentro de un objeto
contenedor, en este caso la Ventana de proyecto; al seleccionar el formulario se
colocarán los controladores de tamaño.
• Se muestren o no los controladores de tamaño, es posible cambiar el tamaño del
formulario.










Capítulo 2: Creación de la interfaz de usuario 45
>> Cómo seleccionar un formulario. [02.03]
A continuación aprenderá cómo seleccionar el objeto Form.
1. Para seleccionar un formulario tiene que hacer clic en cualquier parte del formu-
lario que no esté ocupado por algún otro objeto (de preferencia que no sea en la
barra de título).
=============================================================
Nota: Una forma de "hacer clic en cualquier parte del formulario, que no sea la
barra de título y que no esté ocupado por otro objeto" es hacer clic en cualquier
pequeño punto de la cuadrícula estándar. Si puede ver el punto de la cuadrícula están-
dar, resulta obvio que no tiene un objeto que lo cubre.
=============================================================
2. Seleccione el formulario como se indicó en el punto 1. Si tenía seleccionado
cualquier otro objeto, éste ya no lo estará más.
3. Revise la lista desplegable de objetos que se encuentra en la ventana Propiedades,
en donde debe aparecer Form1 Form.
>> Cómo cambiar el tamaño de un formulario. [02.04]
A continuación aprenderá cómo modificar et tamaño de un objeto Form.
1. Coloque el puntero del ratón exactamente sobre las esquinas del formulario y sobre
los márgenes superior, inferior, derecho e izquierdo, estén o no visibles los
controladores de tamaño (no deben estar presentes porque nos encontramos en
modoSDI).
2. Arrastrando la esquina inferior derecha del formulario, reduzca el tamaño de su
formulario a un tamaño suficiente para el desarrollo estético del ejemplo mostrado
en la figura 2.1.
3. Haga los movimientos necesarios para que el formulario tenga las siguientes
dimensiones: que su alto sea aproximadamente 4 veces el alto del botón, y que su
ancho sea aproximadamente 4 veces el ancho del botón de comando. La figura 2.7
muestra cómo debe tener hasta este momento su formulario.












46 Parte 1: Entorno Integrado de Desarrollo


Figura 2.7
Vista parcial
del formulario,
hasta este
momento

>> Cómo guardar su trabajo. [02.05]
A continuación aprenderá la forma de guardar su trabajo en Visual Basic.

Aunque es muy poco lo que ha hecho hasta ahora (aunque es mucho lo que ha apren-
dido con ese "poco"), no hay nada que desmoralice más a un programador que perder su
trabajo y tener que volver a hacerlo. Aquí le diremos rápidamente cómo guardar su
trabajo, aunque este tema se trata con mayor profundidad en capítulos posteriores.
1. Haga clic en el botón Guardar proyecto, que aparece en la barra de
herramientas. Recuerde que por organización del libro, deberá guardar sus
prácticas en /avbp/capnn, donde nn es el número del capítulo donde se desarrolla
la práctica. En este caso, lo que guarde en esta práctica debe ir a /avbp/cap02.
2. Aparecerá la ventana Guardar archivo como...; como Nombre de archivo, escriba
frmMensaje; en Guardar como tipo, debe estar seleccionado Formulario
(*.frm), mismo que aparece seleccionado de manera predeterminada.
3. Haga clic en Guardar.
4. Enseguida aparecerá la ventana Guardar proyecto como...; como Nombre de
archivo escriba Saludo; en Guardar como tipo, debe estar seleccionado Proyecto
(*.vbp), mismo que aparece seleccionado de manera predeterminada.

Los conceptos Formulario, Proyecto y Grupo de proyectos se analizarán a detalle
en el capítulo 5. Las ventanas Guardar... aparecerán sólo la primera vez que
guarde el proyecto y el formulario; después bastará con hacer clic en el botón
Guardar proyecto para almacenar los cambios hechos al trabajo.
Ya vimos que agregar objetos en modo de inserción es muy fácil: haciendo doble clic
en cualquier control del Cuadro de herramientas. El problema es que siempre se








Capítulo 2: Creación de la interfaz de usuario 47
agregarán en el centro del formulario; al agregar varios objetos de manera rápida,
provocará un juego de movimientos necesarios para poder disponer de cada uno de los
objetos (quitarle a un objeto los que tiene arriba). Lo ideal es agregar los objetos en el
lugar en donde cree que deben quedar de manera definitiva. Eso se realiza agregando
los objetos en modo de trazo, que no es otra cosa que hacer clic en un control que desea
agregar, para después trazar en el formulario el espacio que desea que ocupe el objeto
que quiere agregar.
>> Cómo agregar objetos en modo de trazo. [02.06]
A continuación aprenderá la forma de agregar objetos al formulario en modo de
trazo.

En este momento faltan de agregar dos objetos al formulario: un botón de comando
(CommandButton) y una etiqueta (Label).

Podríamos hacer doble clic en los controles CommandButton y Label para
insertarlos, tal y como lo hicimos con el primer botón de comando. En este ejercicio
optaremos por trazar los objetos.

1. Haga clic en el control CommandButton. Traslade el puntero del ratón a un área
no ocupada del formulario. Podrá darse cuenta que el puntero del ratón ha cambiado
su forma: dentro del formulario aparece como una cruz delgada. Este puntero del
ratón indica que está en modo de trazo.
2. Trace el área que desea que ocupe el botón de comando que está agregando. La figura
2.8 muestra cómo trazar ese objeto. En el proceso aparecerá un recuadro de
Información sobre herramientas que muestra el ancho por alto en twips del objeto que
está trazando. Deliberadamente provoque que el nuevo botón de comando que está
agregando sea un poco más grande que el primer botón de comando que ya había
insertado.


Figura 2.8
Adicion de un
Objeto en modo
De trazo






48 Parte 1: Entorno Integrado de Desarrollo
3. Acomode los botones de tal forma que queden más o menos a la misma altura, en la
parte inferior del formulario.
4. Trace el objeto Label arriba de los botones de control. La figura 2.9 muestra cómo
debe verse el formulario hasta el momento. De manera predeterminada, Visual Basic
le asigna nombres a cada uno de los objetos, en este caso, los nombres asignados a
cada objeto son visibles: Form1, Label1. Command1 y Command2.
Deliberadamente el objeto Command2 fue definido más grande que Command1.




Figura 2.9
Vista parcial
del formulario,
hasta este
momento



Organización de los objetos en el formulario
Probablemente no esté del todo satisfecho con el resultado obtenido, ya que los objetos están
desproporcionados y no están bien distribuidos; en pocas palabras, el formulario no se ve bien.
Visual Basic proporciona un conjunto de herramientas que facilitan la organización y
distribución de los objetos, a través de su menú Formato.
Algunas de las opciones de dicho menú funcionan para un solo objeto activo, otras funcionan
para un conjunto de objetos activos, a lo que se le llama modo de grupo, y otras funcionan para
ambos casos.
Cada que selecciona un objeto, los controladores de tamaño aparecen bordeándolo en forma de
recuadros azules. Cuando seleccione varios objetos en modo de grupo, se dará cuenta que todos
están rodeados por controladores de tamaño, sin embargo, sólo uno de los objetos tendrá los
controladores de tamaño de color azul y el resto los tendrán de color blanco. Aquel objeto que
tenga los controladores de color azul será el objeto principal del grupo; esto es muy importante,
ya que todos los demás objetos del grupo lo seguirán en sus propiedades.












Capítulo 2: Creación de la interfaz de usuario 49
>> Selección de objeto activo, en forma individual o en modo de grupo. [02.07]
A continuación aprenderá la forma de seleccionar los objetos en modo de grupo y
comprobará que a medida que agrupa objetos, la ventana Propiedades muestra sólo
aquellas propiedades que son aplicables a todos los objetos que conforman el grupo.
1. Para seleccionar un objeto y establecerlo como objeto activo, basta con hacer clic en
el objeto. Seleccione Command1 como objeto activo.
2. Presione la tecla Tab. ¿Qué sucede?





3. Seleccione el objeto Command1 . Vea en la ventana Propiedades. ¿Qué valor tiene
la propiedad Name y la propiedad CausesValidation?:
Command1 .Name = __________________
Command1 .CausesValidation = __________________


4. Seleccione en modo de grupo a los dos botones de comando; tiene dos opciones para
hacerlo. La primera, seleccione el botón de comando Command1 . presione la tecla
Mayús y no la suelte, haga clic en el botón de comando Command2 . suelte la tecla
Mayús. La segunda, trazando un cuadro o línea imaginaria que abarque el área que
ocupan los dos botones de comando. La figura 2.10 muestra cómo se ve su
formulario cuando selecciona en modo de grupo los objetos Command1 y
Command2 .
























50 Parte 1: Entorno Integrado de Desarrollo










5. Vea en la ventana Propiedades. ¿Qué valor tiene la propiedad Name y la propiedad
CausesValidation?:
Name = _________________
CausesValidation= _________________

¿Por qué cree que la propiedad Name ya no está disponible y CausesValidation sí?




6. Presione la tecla Mayús y sin dejar de presionarla haga clic en el objeto Label1.
7. Vea en la ventana Propiedades. ¿Qué valor tiene la propiedad Name y la propiedad
CausesValidation?:
Name = _________________
CausesValidation= _________________

Capítulo 2: Creación de la interfaz de usuario 51
¿Por qué cree que la propiedad CausesValidation ya no está disponible?



Hasta el momento ya sabe seleccionar, cambiar el tamaño y mover los objetos. Lo que
no
ha visto es cómo determinar la posición de un formulario. Para ello, utilice la ventana
Posición del formulario.
>> Cómo determinar la posición de un formulario en la pantalla. [02.08]
A continuación aprenderá la forma de determinar la posición de un formulario en la
pantalla.
Utilizará la ventana Posición del formulario, misma que no hace otra cosa que modi-
ficar visualmente los valores de las propiedades de posición del objeto Form.
1. Seleccione el formulario.
2. Vea qué valores tiene actualmente:
Form1.Top = ______________________
Form1.left = ______________________
3. Lo más sencillo es arrastrar el formulario tomándolo de la barra de título, si está en
SDI; en caso de que trabaje en MDI, utilice la ventana Posición del formulario.
4. Otra forma es utilizando la ventana Posición del formulario. Seleccione el menú
Ver - Ventana Posición del formulario. Aparecerá la ventana que se muestra en la
figura 2.11.












52 Parte 1: Entorno Integrado de Desarrollo

Figura 2.11
Ventana Posición
del formulario



5. La ventana representa la pantalla de un monitor, y dentro de dicha pantalla aparece
lo que sería su formulario (Form1).
6. Coloque el puntero del ratón sobre la representación de su formulario, hasta que el
puntero del ratón cambie a .
7. Arrastre el pequeño formulario a la posición que desea que ocupe en la pantalla en
modo de ejecución.
8. Qué valores tiene actualmente en las siguientes propiedades:
Form1.Top = ______________________
Form1.left = ______________________

============================================================
LO inesperado: Es posible que no aparezca formulario alguno en la ventana
Posición del formulario. Seleccione el menú Ejecutar - Iniciar (también puede opri-
mir la tecla F5). Esto provoca que su aplicación se ejecute (se coloque en tiempo de
ejecución); lo que su formulario haga en este momento no es relevante. Seleccione el
menú Ejecutar - Terminar (regresa a tiempo de diseño).
La ventana Posición del formulario deberá mostrar ya la representación de su for-
mulario.

============================================================

Cómo establecer las aplicaciones para diferentes
resoluciones de monitores
Es posible que usted desarrolle una aplicación que le parece vistosa y bien distribui-
da. Cuando libere la aplicación, no se impresione si uno de los usuarios de ésta se
queja de que la distribución de su aplicación en la pantalla es inadecuada ¿dónde está
el problema?

Capítulo 2: Creación de la interfaz de usuario 53
Recuerde que sugeríamos un monitor más grande (17" o 19") para desarrollar cómo-
damente. Seguir esa recomendación puede llevarlo a una involuntaria pérdida de per-
spectiva: con seguridad los usuarios finales de la aplicación dispondrán de un monitor
más reducido. Para asegurarse de que su aplicación tiene las dimensiones adecuadas
para los diferentes tipos de monitores y resoluciones que existen en el mercado, la
ventana Posición del formulario puede ayudarle, si establece lo que se conoce como
Guías de resolución, que sugieren las dimensiones de su aplicación, comparada
relativamente con el espacio de trabajo de las resoluciones más comunes de los
monitores actuales.
>> Cómo establecer las Guías de resolución. [02.09]
A continuación aprenderá la forma de establecer las Guías de resolución.
En el proyecto Saludo.vbp utilizará la ventana Posición del formulario.
1. Coloque el puntero del ratón en la ventana Posición del formulario.
2. Haga clic con el botón derecho del ratón y seleccione la opción Guías de resolución
del menú contextual que aparece (vea la figura 2.12).

Figura 2.12
La opción Guías
de resolución
3. En la figura 2.13 se muestra la forma en que se han agregado las Guías de resolución.
Ahora podrá dimensionar su aplicación, de acuerdo con el espacio real que el usuario
final puede tener.

Figura 2.13
Guías de reso-
lución en la
ventana Posición
del formulario





54 Parte 1: Entorno Integrado de Desarrollo
>>Cómo utilizar las herramientas del menú Formato para organizar objetos. [02.10]
A continuación aprenderá a organizar los objetos con las herramientas que Visual
Basic tiene en su menú Formato. También aprenderá por qué es importante el orden
en que los objetos sean seleccionados.
1. Seleccione el objeto Label1y el menú Formato - Centrar en el formulario —
Horizontalmente,
2. Seleccione en modo de grupo los objetos Command1 y Command2. Asegúrese de
que Command1 , que es el botón de comando más grande, quede como objeto prin-
cipal del grupo (controladores de tamaño en azul).
3. Seleccione el formulario, lo que implica dejar de tener seleccionados los botones de
comando.
4. Haga clic en el objeto Command1 , presione la tecla Mayús y no la suelte, haga clic
en el objeto Command2, deje de presionar la tecla Mayús. Los controladores de
tamaño del objeto Command1 deberán ser blancos, mientras que los del objeto
Command2 son azules. El último objeto integrado al grupo permanece como objeto
principal de grupo.
5. Seleccione el menú Formato - Igualar tamaño - Ambos. Observe que los objetos
del grupo siguen las características del objeto principal del grupo.
6. Deshaga la modificación que acaba de realizar. Para ello seleccione el menú Edición
- Deshacer tamaño (también puede presionar Ctrl+Z).
7. Para seleccionar otro objeto como objeto principal de grupo, haga clic en el objeto
que desee como objeto principal del grupo. Teniendo seleccionados en modo de
grupo a los objetos Command1 y Command2. haga clic en el objeto Command1 .
Los controladores de tamaño del objeto Command2 deberán ser blancos, mientras
que los del objeto Command1 deberán ser azules.
8. Seleccione el menú Formato - Igualar tamaño - Ambos. Observe que los objetos
del grupo siguen las características del objeto principal del grupo.
9. Todavía teniendo los objetos Command1 y Command2 seleccionados en modo de
grupo, seleccione el menú Formato - Espacio horizontal - Aumentar.
10. Seleccione el menú Formato - Bloquear controles.
11. Trate de mover cualquier objeto dentro del formulario. Comprobará que no se
puede; asimismo, cada que seleccione un objeto, los controladores de tamaño no
serán azules como lo eran antes, ahora son blancos.
12. Seleccione el menú Formato - Bloquear controles. Se deshabilitará el bloqueo de
los objetos; ahora ya podrá moverlos.
13. Su formulario deberá verse aproximadamente como se muestra en la figura 2.14.






Capítulo 2: Creación de la interfaz de usuario 55
Figura 2.14
Vista parcial
del formulario
hasta este momento

14. Guarde su trabajo haciendo clic en el botón Guardar proyecto de la barra
de herramientas Estándar.
____________________________________________________
Resumen
En este capítulo:
• Vimos cuáles son los objetivos que se persiguen al crear una interfaz de
usuario.
• Vimos cómo se insertan objetos en un formulario.
• Vimos cómo se agregan objetos a un formulario en modo de trazo.
• Vimos qué son los controladores de tamaño.
• Vimos qué es un objeto activo, la selección de un objeto, la selección de
objetos en modo de grupo y el establecimiento de un objeto como principal
del grupo.
• Vimos cómo mover y darle dimensión a los objetos.
• Vimos cómo establecer la posición de un formulario en la pantalla.
• Vimos para qué sirven las opciones del menú Formato de Visual Basic.
• Vimos cómo guardar nuestro trabajo.
Es importante que domine todos esos puntos antes de continuar.




56 Parte 1: Entorno Integrado de Desarrollo
Algunas respuestas a los ejercicios
[02.01] Cómo insertar un objeto en la interfaz.
5.a) Command1
5.b) CommandButton
5.c) Visual Basic lo asignó de manera predeterminada.
[02.07] Selección de objeto activo, en forma individual o en modo de grupo.
2. El control se mueve al siguiente objeto. Otro objeto es ahora el objeto activo.
3. Command1. Name = Command1 , Command1.CausesValidation = True.
5. Porque Name es una propiedad específica para un solo objeto; en virtud de que los
dos objetos no pueden compartir un mismo nombre de objeto, la propiedad Name
ya no está disponible. CausesValidation es una propiedad no exclusiva para
un solo objeto, y como aplica a los objetos basados en CommandButton y
ambos están basados en CommandButton, es posible asignarlo en modo de
grupo.
7. Porque no se aplica a todos los objetos del grupo. Puesto que los objetos basados
en el control Label no cuentan con la propiedad CausesValidation, ésta
desaparece en un grupo en donde se encuentre un objeto basado en el control
Label.













Capítulo
3
Cómo establecer
las propiedades
de los objetos
Objetivo
Aprender a establecer las características particulares de los objetos, en tiempo de di-
seño y en tiempo de ejecución.
Al finalizar este capítulo deberá:
• Dominar el manejo de la ventana Propiedades
• Saber cómo modificar la propiedad de identificación (Name)
• Saber cómo modificar las propiedades de apariencia y comportamiento
• Conocer la sintaxis que se sigue para modificar los valores de las propiedades en
tiempo de ejecución
• Saber cómo conformar una tabla de objetos y propiedades para las aplicaciones de
ejemplo de este libro
57







58 Parte 1: Entorno Integrado de Desarrollo
Consideraciones de diseño en Visual Basic
El diseño de las aplicaciones en Visual Basic no es tan sencillo como parece; no es
sólo agregar objetos en un formulario de manera estética y proporcionada.
En Visual Basic el desarrollo es minimalista, detallado, específico. Esto no puede ser
de otra manera debido a que la plataforma es orientada a eventos, es decir, cualquier
cosa que suceda en la interfaz de usuario, por mínima que sea, puede desencadenar
una tarea. Hacer un clic con el ratón, presionar una tecla determinada, pasar el puntero
del ratón sobre un objeto, arrastrar un objeto, cualquier cosa puede disparar una
acción; es donde las cosas se complican ya que usted tiene que anticiparse y prevenir
todo lo que puede pasar.
Lo primero que puede hacer para que su aplicación haga solamente lo que usted desea,
es establecer las propiedades adecuadas.
Al principio, la aplicación Saludo parecía muy sencilla. Al momento de estar dise-
ñando la aplicación los detalles aparecen por todos lados. Es un hecho que su aplica-
ción, tal como está, ni luce como usted quiere, ni hace lo que usted quiere.
Observe las especificaciones de la aplicación desde el punto de vista de diseño de
Visual Basic, es decir, cómo se espera que se vean y sucedan las cosas:
• En la barra de título del formulario debe aparecer Mensaje.
• Al ejecutarse la aplicación, el formulario debe colocarse en el centro de la pantalla.
• Al iniciar la ejecución de la aplicación, la etiqueta donde se mostrará el mensaje no
debe tener contenido.
• La etiqueta donde aparecerá el mensaje ¡¡¡Bienvenido a Visual Basic!!! debe estar
bordeado con el efecto 3-D estándar de Windows.
• El botón de comando (CommandButton) que sirva para desplegar el mensaje de
bienvenida debe decir Mostrar Mensaje; además, debe establecerse como tecla
de método abreviado para ese botón la combinación Alt+M, siendo visible dicha
capacidad en el estándar de Windows (la letra "M" debe aparecer subrayada).
• El botón de comando que sirva para salir de la aplicación debe decir Salir; además,
debe establecerse como tecla de método abreviado para ese botón la com-
binación Alt+S, siendo visible dicha capacidad en el estándar de Windows (la
letra "S" debe aparecer subrayada).
• Hacer clic en el botón de comando Mostrar Mensaje debe provocar que en la eti-
queta aparezca ¡¡¡Bienvenido a Visual Basic!!!
• Hacer clic en el botón de comando Salir debe provocar la salida de la aplicación
(terminación de la ejecución).






Capítulo 3: Cómo establecer las propiedades de los objetos 59
Todas las especificaciones anteriormente listadas son controladas a través de la asig-
nación de propiedades, excepto la relativa a lo que sucederá cuando se haga clic en los
botones Mostrar Mensaje, y Salir; esta tarea sólo puede ser realizada a través de
programación, en los procedimientos asociados a dicho uso de la interfaz.
Paso 2: Establecer las propiedades de los objetos
Los objetivos de establecer las propiedades de los objetos son:
• Validar que ya se tienen todos los objetos que se requieren en el formulario.
Consiste en revisar que ya se tienen todos los objetos que la interfaz requiere. Para ello
se utiliza la ventana Propiedades.
• Asignar el nombre adecuado a cada uno de los objetos. Consiste en darle un
nombre específico a cada uno de los objetos, a efecto de poder hacer referencia a
ellos en la aplicación y realizar operaciones con ellos, La propiedad de identificación
es la propiedad Name. Es necesario que respete las convenciones de prefijo de
objetos que son reconocidas mundialmente para código Visual Basic.
• Establecer las propiedades de apariencia y comportamiento. Consiste en asignar
los valores necesarios a las propiedades para que los objetos luzcan y se comporten
como el diseño lo requiere. Las propiedades diferentes a la propiedad Name son
llamadas propiedades de apariencia y comportamiento.

Validar que ya se tienen todos los objetos
que se requieren en el formulario
Al inicio de este capítulo se estableció lo siguiente para la aplicación de ejemplo:
Total de objetos requeridos: 4
Tipos de objetos requeridos: 1 Form
1n Label
2 CommandButton








60 Parte 1: Entorno Integrado de Desarrollo
Debe verificar que efectivamente en este momento tiene en el formulario todos los
objetos requeridos; debe tener la cantidad suficiente de objetos que le permita cubrir
las especificaciones del diseño, de tal forma que exista un balance exacto entre la
estética y la funcionalidad, con aplicación estricta de los estándares de todo programa
basado en Windows.
============================================================
Nota: Uno de los atributos del entorno de Windows es que la interfaz de los
programas cuenta con convencionalismos de funcionalidad que permiten que una
persona, una vez que aprenda a manejar un programa, pueda manejar cualquier otro;
todos se parecen.
Usted puede hacer magia con la interfaz, pero si no se apega a los estándares de Win-
dows será un programa incómodo para los usuarios. Uno de los atributos más valio-
sos de la interfaz de una aplicación es que sea fácil de usar y de aprender.
No rompa paradigmas de manera radical, a menos que sea estrictamente necesario.
============================================================
Aparte de tener el número correcto de objetos, es muy importante que sean el tipo de
objeto que necesita. Un error frecuente al desarrollar en Visual Basic es confundir los
controles, por ejemplo agregar al formulario un objeto basado en el control
TextBox en lugar de un objeto que debió estar basado en el control Label.
¿Qué pasará si hace esto? Al codificar hará referencia a propiedades del objeto tipo
Label creyendo que tiene uno de ese tipo definido en el formulario. En el momento
en que haga referencia a una propiedad que no esté disponible para el objeto que
definió (TextBox), su programa marcará error.
Si incurre en este error, necesita eliminar el objeto equivocado y agregar el correcto.
Esto es trabajo extra que puede ahorrarse con una verificación sencilla, que no le
quita mucho tiempo y que debe establecer en su forma de trabajo como un hábito útil
para la programación en Visual Basic.
Evite ese trabajo extra verificando desde un principio si tiene los objetos que requie-
re, en cantidad y tipo. La lista desplegable de objetos de la ventana Propiedades
sirve para tal efecto.
>> Cómo validar la cantidad y el tipo de objetos requeridos en una aplicación. [03.01]
A continuación aprenderá a verificar cuántos objetos tiene definidos en un formulario
y de qué tipo son.
1. Seleccione el formulario. Para ello haga clic en cualquier parte del formulario que
no sea la barra de título y que no esté ocupada por otro objeto. Otra forma de
decirlo, haga clic en cualquier punto de la cuadrícula.
2. Haga clic en la lista desplegable de objetos de la ventana Propiedades. La figura
3.1 muestra cómo se debe desplegar la información.




Capítulo 3: Cómo establecer las propiedades de los objetos 61

Figura 3.1
Verificación de
la cantidad de
obetos y sus
tipos, utilizando
la Lista
desplegable de
objetos
haciendo clic en esta
lista, aparecerán todos
los objetos que
componen el
formulario, incluyendo
el objeto contenedor












3. Marque afirmativamente si se da el caso:
¿Tiene definido un objeto basado en el control Form?
¿Tiene definido un objeto basado en el control Label?
¿Tiene definidos dos objetos basados en el control CommandButton?
¿Los anteriores son los únicos objetos definidos en la lista?


Si marcó afirmativamente a todas las preguntas anteriores, puede continuar con el
capítulo. Si no es así, éstas son las alternativas que tiene:
• Si sobran objetos. Seleccione los que no sean necesarios y presione la tecla Supr.
Con esto se eliminarán.
• Si faltan objetos. Agregúelos y acomódelos como debe ser (vea el capítulo
anterior).






62 Parte 1: Entorno Integrado de Desarrollo

• Si tiene la cantidad de objetos correcta, pero uno no es del tipo que esperaba.
Deberá seleccionar el objeto basado en un control equivocado, y eliminarlo
presionando la tecla Supr; posteriormente deberá agregar el objeto que haga falta
con el tipo de control correcto.

Cómo asignar el nombre adecuado
a cada uno de los objetos
En un formulario puede tener tantos objetos como la memoria RAM de la compu-
tadora lo permita; esto puede significar muchos objetos, algunos basados en el mismo
control.

Ya hemos visto que Visual Basic asigna un nombre predeterminado a cada uno de los
objetos que es agregado al formulario, a través de la propiedad Name (Form1,
Label1, Command1. Command2. son ejemplos de ello).
============================================================
Nota: Un solo proyecto puede contener hasta 32,000 "identificadores" (cualquier
palabra clave no reservada), asociados a nombres de formularios, controles, módulos,
variables, constantes, procedimientos, funciones y objetos. El número real de identi-
ficadores se limita a la memoria disponible.
============================================================

Utilizar los nombres proporcionados de manera predeterminada a los objetos no oca-
siona problemas en aplicaciones pequeñas, pero suponga que tiene un formulario con
diez botones de comando (Command1, Command2,...., Command10) y cada uno de
ellos tiene una función específica e importante que no debe confundirse con la
función de los otros botones de comando; en este caso, sería complicado mantener la
referencia de los objetos.
Para evitar estas complicaciones. Visual Basic permite modificar la propiedad Name
de los objetos, de tal forma que éstos sean identificados con un nombre acorde a su
función. Aquí surge una problemática nueva: aparte de que puede haber varios
objetos basados en un mismo control, puede haber objetos basados en otros
controles.
Para aquel que desarrolla aplicaciones en Visual Basic, lo ideal es tener un nombre
de objeto altamente significativo, que dé a entender para qué sirve un objeto deter-
minado, así como en qué control está basado. De esa manera podrá saber qué
propiedades estarán disponibles, así como el comportamiento y la apariencia que es
posible definir.
Por ejemplo, si tiene una etiqueta (Label) que servirá para desplegar un texto deter-
minado, podría asignarle el siguiente nombre:

Texto







Capitulo 3: Cómo establecer las propiedades de los objetos 63
Sin embargo, este nombre por sí mismo no proporciona información relativa al control
sobre el cual está basado el objeto; podría ser un objeto basado en el control Label. por
lo que para desplegar un mensaje tendría que modificar la propiedad Caption; pero
también podría ser un objeto basado en el control TextBox, por lo que para desplegar
un mensaje tendría que modificar la propiedad Text. Si no conoce con exactitud el tipo
de control sobre el cual está basado el objeto, podría utilizar propiedades que no se
apliquen a un objeto (por ejemplo, modificar la propiedad Text de un control un
Label, o la propiedad Caption de un control un TextBox), lo que generaría un error
en tiempo de ejecución.
¿Qué le parece este otro nombre para el objeto?

lblTexto
El prefijo lbl indica que el objeto está basado en el controLabelbel, y por otro lado,
el resto del nombre (Texto) nos da una idea en relación con el uso del objeto.
En Visual Basic se tienen las siguientes convenciones para los objetos:





64 Parte 1: Entorno Integrado de Desarrollo














Capítulo 3: Cómo establecer las propiedades de los objetos 65

A medida que vaya conociendo más controles agregará las convenciones de prefijos para
cada uno de ellos. Revise el apéndice 1: Convenciones, para ver la lista completa de
prefijos, entre otras cosas.
La propiedad Name de un objeto, al igual que los nombres de variables de memoria en
Visual Basic, debe comenzar con una letra y puede tener un máximo de 40 caracteres.
Puede incluir números y caracteres de subrayado (_), pero no signos de puntuación,
espacios en blanco, caracteres compuestos o caracteres especiales. Le recomendamos el
uso sólo de letras, números y el carácter de subrayado. Un formulario no puede tener el
mismo nombre que otro objeto público como Clipboard, Screen o App.
Aunque el valor de la propiedad Name puede ser una palabra clave, un nombre de
propiedad o el nombre de otro objeto, esto puede crear conflictos en el código.

===============================================================
Lo inesperado: Si por equivocación intenta ponerle a un objeto un nombre ya
utilizado por otro objeto, Visual Basic asume que desea crear una matriz de controles
(varios objetos identificados por un mismo nombre, diferenciados por un subíndice). La
utilidad de una matriz de controles se verá en otro capítulo; si por descuido intenta en
este momento repetir nombres, cuando Visual Basic le pregunte ¿Desea crear una matriz
de controles?, conteste No. Este es uno de los casos en que Visual Basic utiliza el
término "controles" cuando debería utilizar "objetos".
===============================================================

Si analizamos nuestro ejemplo, podríamos asignar los siguientes nombres de objeto:
frmMensaje (Form1), lblTexto (Label1), cmdDespliega (Command1) y
cmdSalir (Command2) (vea la figura 3.2).











66 Parte 1: Entorno Integrado de Desarrollo

>> Cómo modificar la propiedad Name de los objetos. [03.02]
A continuación aprenderá a modificar la propiedad Name de los objetos.
1. Seleccione el formulario.
2. Asegúrese de que la cuadrícula de propiedades esté en orden alfabético.
3. Haga doble clic en la cuadrícula de propiedades donde diga Name. Observe que el
valor asignado actualmente, en este caso Form1, se sombrea en azul al hacer doble
clic en el valor asignado a la propiedad.
4. Escriba frmMensaje. Presione la tecla Intro.

===============================================================
Nota: Las propiedades se asignan cuando presiona la tecla Intro, o bien cuando traslada
el control hacia otra propiedad u objeto; se dice que la propiedad se acepta. Mientras no
acepte un nuevo valor para una propiedad, puede presionar la tecla Esc y dar marcha atrás
a los cambios que haya realizado.
===============================================================

5. Vea que en la lista desplegable de objetos aparecerá frmMensaje Form, lo que
indica que el objeto de tipo Form ahora se llama frmMensaje. Usted ha cambiado
el nombre del objeto.
6. En la lista desplegable de objetos seleccione Label1 Label; haga doble clic en la
cuadrícula de propiedades donde diga Name, escriba lbITexto.









Capítulo 3: Cómo establecer las propiedades de los objetos 67
7. En la lista desplegable de objetos seleccione Command1 CommandButton; haga
doble clic en la cuadricula de propiedades donde diga Name, escriba cmdDes-
pliega.
8. En la lista desplegable de objetos seleccione Command2 CommandButton; haga
doble clic en la cuadrícula de propiedades donde diga (Name), escriba cmdSalir.
9. Vea el contenido actual de la lista desplegable de objetos de la ventana. Debe decir
Propiedades, como se muestra en la figura 3.3.

Cómo establecer las propiedades de apariencia y
comportamiento
Cambiar el valor de la propiedad Name y cambiar el valor de cualquier otra propiedad
es exactamente igual.
Para establecer el valor de una propiedad en tiempo de diseño:
• Seleccione el objeto al que pertenece la propiedad que desea modificar. Esto lo
puede hacer de dos formas: seleccionando el objeto en la lista desplegable de objetos,
o bien haciendo clic en el objeto.






















68 Parte 1: Entorno Integrado de Desarrollo
• Busque en la cuadricula de propiedades la propiedad que desea modificar. Haga doble clic en
el nombre de la propiedad que desea modificar (columna izquierda de la cuadrícula de
propiedades).
• Escriba o seleccione el valor deseado.

===================================================================
Nota: Un formulario es un objeto contenedor (es decir, puede contener objetos basados en otros
controles); existe un límite fijo de 254 nombres diferentes de objetos.
===================================================================

Para establecer el valor de una propiedad en tiempo de ejecución:
• Debe realizar una igualación entre la propiedad de un objeto y el valor que se desea asignar.

Ejemplo:
Usted quiere establecer, para la propiedad Caption del objeto frmMensaje, la siguiente
expresión: Mensaje.
Sintaxis:
Objeto.Propiedad = ValorAEstablecer
Ejemplo:
frmMensaje.Caption = "Mensaje"
>> Cómo modificar las propiedades de apariencia y comportamiento. [03.03]
Enseguida aprenderá a modificar las propiedades de apariencia y comportamiento. El diseño nos
dice lo siguiente:
• En la barra de título del formulario debe aparecer Mensaje.
• Al ejecutarse la aplicación, el formulario debe colocarse en el centro de la pantalla.
1. Seleccione el objeto frmMensaje. El título de la ventana Propiedades debe decir
Propiedades - frmMensaje.

===================================================================
Nota: Si el título de la ventana Propiedades no dice Propiedades - frmMensaje, quiere decir
que usted está modificando las propiedades de otro objeto. Ese es el primer paso para arruinar el
funcionamiento de su aplicación. Cerciórese de que está modificando las propiedades del objeto
que realmente desea afectar.
===================================================================






Capítulo 3: Cómo establecer las propiedades de los objetos 69
2. Localice en la cuadrícula de propiedades la propiedad Caption. Haga doble clic en el
nombre de la propiedad; se iluminará en azul el valor actual de la propiedad. Escriba Mensaje
y acepte la propiedad. Esto sería en tiempo de diseño; en tiempo de ejecución el código que
modificaría la propiedad sería:
frmMensaje.Caption = "Mensaje"
3. Localice en la cuadrícula de propiedades la propiedad StartUpPosition, haga doble clic
en el nombre de la propiedad; como esta propiedad es de valor limitado, necesita seleccionar
en la lista desplegable el valor que requiera (vea la figura 3.4).

4. Seleccione el valor 2- Center Screen. Esto sería en tiempo de diseño; en tiempo de ejecución
el código que modificaría la propiedad sería:
frmMensaje.StartUpPosition = 2

===================================================================
Nota: StartUpPosition es un ejemplo de aquellas propiedades que se ven afectadas por
otros movimientos y asignaciones realizadas posteriormente. StartUpPosition con valor
2 establece que al cargarse el formulario para su ejecución, éste se colocará exactamente en el
centro de la pantalla. Si después de haber colocado dicho















70 Parte 1: Entorno Integrado de Desarrollo
valor a la propiedad usted mueve el formulario de posición, ya sea arrastrando el formulario por
su barra de título o utilizando la ventana Posición del formulario, la propiedad cambiará de
forma automática a O (Manual).
Al ejecutar la aplicación se preguntará ¿por qué no se colocó en el centro si yo se lo especifiqué?
Simplemente porque hizo algo en tiempo de diseño que ocasionó modificaciones automáticas en
la propiedad que así lo establecían.
===================================================================
El diseño nos dice:
• Al iniciar la ejecución de la aplicación, la etiqueta, donde se mostrará el mensaje no debe tener
contenido.
• La etiqueta donde aparecerá el mensaje ¡¡¡Bienvenido a Visual Basic!!! debe estar bordeado
con el efecto 3-D estándar de Windows.
5. Seleccione el objeto indicado, en este caso lblTexto. (La ventana Propiedades debe decir
en su barra de título Propiedades - lblTexto.)
6. Localice en la cuadrícula de propiedades la propiedad Caption, haga doble clic en el
nombre de la propiedad, y presione la tecla Supr para eliminar el contenido; acepte la
propiedad. En tiempo de ejecución el código que modificaría la propiedad sería:
lblTexto.Caption = ""

7. Localice en la cuadrícula de propiedades la propiedad BorderStyIe, haga doble clic en el
nombre de. la propiedad y seleccione el valor 1 - Fixed single. Esto sería en tiempo de
diseño; en tiempo de ejecución el código que modificaría la propiedad sería:
lblTexto.BorderStyle = 1
El diseño nos dice:
• El botón de comando que sirva para desplegar el mensaje de bienvenida debe decir Mostrar
Mensaje; además, debe establecerse como tecla de método abreviado para ese botón de
comando la combinación Alt+M, siendo visible dicha capacidad en el estándar de Windows
(la letra "M" debe aparecer subrayada).
8. Seleccione el objeto indicado, en este caso cmdDespliega. (La ventana Propiedades debe
decir en su barra de título Propiedades - cmdDespliega.)
9. Localice en la cuadrícula de propiedades la propiedad Caption, haga doble clic en el
nombre de la propiedad, escriba &Mostrar Mensaje. Esto sería en tiempo













Capítulo 3: Cómo establecer las propiedades de los objetos 71
de diseño; en tiempo de ejecución el código que modificaría la propiedad sería
(vea la figura 3.5):
cmdDespliega.Caption = "&Mostrar Mensaje"

===================================================================
Nota: Al establecer la propiedad Caption de los objetos, anteponer a cualquier letra un signo
"&" hace que dicha letra sea asignada como tecla de método abreviado. En tiempo de
ejecución, presionar Alt+<letra> es lo mismo que seleccionar el objeto por otro medio.
Es importante que planee las teclas de método abreviado, a efecto de que no tenga dos iguales
en un mismo formulario.
===================================================================
10. Guarde su trabajo haciendo clic en el botón Guardar proyecto de la barra de
herramientas Estándar.

Debido a que es poco usual tener un botón de comando con dos líneas de contenido, es
recomendable ampliar el tamaño del objeto.

===================================================================
Nota: Los objetos deben tener el tamaño suficiente en relación con su contenido. Si el
contenido excede el tamaño del objeto, dicho contenido se truncará o se dividirá. En el caso
de nuestro ejemplo, el contenido se dividió en dos líneas.
===================================================================







72 Parte 1: Entorno integrado de Desarrollo
11. Localice en la cuadrícula de propiedades la propiedad Width, haga doble clic en el nombre
de la propiedad, escriba 1500. Esto sería en tiempo de diseño; en tiempo de ejecución el código
que modificaría la propiedad sería:
cmdDespliega.Width = 1500

12. Con este cambio, el tamaño de los botones de comando queda desproporcionado. Para
corregir el problema seleccione en modo de grupo los objetos cmdDespliega y cmdSalir,
cuidando que el objeto cmdDespliega sea el objeto principal del grupo; después seleccione
el menú Formato - Igualar tamaño - Ambos. Los dos botones de comando deben tener
establecida su propiedad Width a 1500 twips.
El diseño nos dice:
• El botón de comando (CommandButton) que sirva para salir de la aplicación debe decir
Salir; además, debe establecer como tecla de método abreviado para ese botón la combinación
Alt+S, siendo visible dicha capacidad en el estándar de Windows (la letra "S" debe aparecer
subrayada).
13. Seleccione el objeto indicado, en este caso cmdSalir. (La ventana Propiedades debe decir
en su barra de título Propiedades - cmdSalir.)
14. Localice en la cuadrícula de propiedades la propiedad Caption, haga doble clic en el
nombre de la propiedad, escriba &Salir. Esto sería en tiempo de diseño; en tiempo de
ejecución el código que modificaría la propiedad sería;
cmdSalir. Caption = "&Salir"
15. Como ya no hay más modificaciones de tamaño ni de dimensión, se recomienda bloquear los
controles para no mover de manera involuntaria la interfaz que ya creó. Seleccione el objeto
frmMensaje y el menú Formato - Bloquear controles.
16. Guarde su trabajo haciendo clic en el botón Guardar proyecto de la barra
de herramientas.
====================================================================
Nota: De ahora en adelante, grabe su trabajo cada que lo considere conveniente. Le
recomendamos que lo haga antes de ejecutar una aplicación, ya que en el transcurso de la
ejecución podría surgir un anidamiento permanente o un error que impida hacerlo
posteriormente.
====================================================================
En este momento ya estableció todas las propiedades de su aplicación.













Capítulo 3: Cómo establecer las propiedades de Sos objetos 73
Tablas de objetos y propiedades
Sugerir los objetos y las propiedades a utilizar, así como los valores que deberán asignarse en
tiempo de diseño a las propiedades, puede ser algo muy complejo si se realiza de manera
narrativa, como tal vez lo haya notado en la práctica 03.03.
Para simplificar el proceso, recurriremos a una alternativa esquemática: una tabla en donde se
listará lo siguiente:
• Contenedor. La identificación del objeto sobre el que deberá trabajar.
• Objeto. Indica en qué clase ha de basarse el objeto a integrar a la interfaz.
• Propiedad. Indica la propiedad que ha de modificarse en tiempo de diseño.
• Valor. Representa el valor que debe asignarse a la propiedad.
• Orden. El orden en que se mencionan los objetos en la tabla, es el sugerido para la interfaz.
A esta tabla la llamaremos tabla de objetos y propiedades; vea cómo quedaría la tabla de objetos
y propiedades para la aplicación que hemos estado desarrollando:
Tabla de objetos y propiedades de frmMensaje



Formulario: frmMensaje.frm
Objeto Propiedad Valor
Project

(Name)

Saludo

(Name) frmMensaje
StartUpPosition 2-CenterScreen
Form

Caption Mensaje
(Name) lblTexto
Caption Borre el texto
Label

BorderStyle 1-Fixed Single
(Name) cmdDespliega
Caption &Mostrar Mensaje
CommandButton

Width 1500
(Name) cmdSalir
Caption &Salir
CommandButton

Width 1500





















74 Parte 1: Entorno Integrado de Desarrollo
_________________________________________________
Resumen
En este capítulo:
• Vimos que algo simple en teoría, se puede complicar al especificar el diseño de la aplicación.
• Vimos cómo validar la cantidad y tipos de objeto que se requieren para una aplicación.
• Vimos cómo establecer el valor de la propiedad de identificación.
• Vimos cómo utilizar la ventana Propiedades.
• Vimos las convenciones para identificar objetos en Visual Basic, atendiendo a la función y el
tipo de control en el que están basados los mismos.
• Vimos cómo establecer valores a las propiedades de apariencia y comportamiento, tanto en
tiempo de diseño como en tiempo de ejecución.
• Vimos cómo se conforma una tabla de objetos y propiedades, herramienta que nos será de
mucha utilidad en el desarrollo de programas detallados de este libro.
Es importante que comprenda muy bien todos estos puntos antes de continuar con el libro.





















Capítulo
4
Escritura del código
de los eventos


Objetivo
Conocer la forma en que el código de programación es escrito y ejecutado en Visual Basic.

Al finalizar este capítulo deberá:
• Conocer en qué consiste la programación orientada a eventos
• Saber utilizar todas las características que brinda el editor de código de Visual Basic
• Conocer la estructura de los procedimientos de evento
• Conocer algunos caracteres con significado especial en la codificación en Visual Basic
75










76 Parte 1: Entorno Integrado de Desarrollo
Paso 3: Escribir el código de los eventos
Antes de escribir código de eventos, es necesario entender en qué consisten los eventos y
la forma de trabajo orientado a eventos que plantea Visual Basic.
Un evento es una acción reconocida por un formulario o control. Los eventos pueden
ocurrir como el resultado de una acción determinada por el usuario, por el código de
programa, o bien puede ser invocada por el sistema. Puede escribir el código que desee
que se ejecute cuando ocurra un evento; en Visual Basic prácticamente cualquier cosa
está asociado a un evento, lo que le proporciona un control muy estricto sobre todo lo que
sucede en su aplicación. Si presiona una tecla, es un evento, si deja de presionarla, otro
evento, si hace clic es un evento, si mueve el puntero del ratón, también;
como puede ver, casi todo es un evento. La pregunta ahora es: ¿qué desea que ocurra
cuando se presente un evento?
Los siguientes son ejemplos de eventos:
Change Cuando cambia algo en el objeto
Cllck Cuando hace clic en el objeto
DblClick Cuando hace doble clic en el objeto
KeyPress Cuando presiona alguna tecla
MouseMove Cuando mueve el puntero del ratón en un objeto
La programación en Visual Basic se basa en la existencia y reconocimiento de los
eventos, por lo cual se dice que es una. programación orientada a eventos. En este tipo
de programación, la aplicación responde a los eventos causados por el teclado, ratón o
por el sistema operativo.
===============================================================
Nota: No descarte algunos otros dispositivos de entrada, tales como lectores de código
de barras, tarjetas electrónicas, etcétera.
===============================================================
Dependiendo de la clase o el control en el que esté basado un objeto, serán los eventos
disponibles para dicho objeto.
El código de una aplicación de Visual Basic se divide en bloques menores llamados
procedimientos, que no son otra cosa que un conjunto de órdenes que se ejecutan de
manera secuencial, que tienen un nombre, un principio y un fin. Un procedimiento














Capítulo 4: Escritura del código de los eventos 77
de evento es el procedimiento que se ejecutará para cuando a un objeto le suceda un evento.
Como vimos en el capítulo anterior, las propiedades deben asociarse al objeto al que pertenecen
(Objeto. Propiedad); pues bien, de la misma forma, los eventos deben asociarse al objeto al que le
suceden o afectan. Una representación óptima sería:
Objeto_Evento
Ejemplo:
CmdDespliega_Click
Volviendo a los requerimientos del ejemplo que nos ha acompañado en los primeros capítulos de este
libro, necesitamos de la aplicación lo siguiente:
• Hacer clic en el botón de comando Mostrar Mensaje debe provocar que en la etiqueta que sirva para
mostrar el mensaje aparezca ¡¡¡Bienvenido a Visual Basic!!!
• Hacer clic en el botón de comando Salir debe provocar la salida de la aplicación (terminación de la
ejecución).
La figura 4.1 muestra cómo se manejaría el código en Visual Basic:
















78 Parte 1: Entorno Integrado de Desarrollo
Analicemos la estructura de los procedimientos de evento. Tomaremos el procedimiento
que se ejecutará cuando haga clic en el objeto cmdDespliega (vea la figura 4.2).
Se ve simple. Analicémoslo.

Todos los procedimientos de evento tienen un inicio (Sub) y un fin (End Sub). El
inicio y el fin delimitan la totalidad del código que se va a ejecutar cuando suceda el
evento.
El evento Click existe para todos los objetos que lo permiten. Por tal motivo, es
necesario identificar a qué objeto le sucede el evento.

El nombre del procedimiento de evento siempre estará compuesto por el nombre del
objeto ...
... y el nombre del evento, separados por un carácter de subrayado.
Todas las líneas de código que se encuentren entre el inicio y el fin del procedi-
miento de evento se llama código de evento. El código de evento es lo que se ejecutará
de manera secuencial en el momento en que sucede un evento.











Capítulo 4: Escritura del código de los eventos 79

===============================================================
Nota: Es posible que antes de la palabra Sub, en el inicio del procedimiento aparezca
automáticamente Private o Public, que indica el alcance del procedimiento.
Analizaremos posteriormente el alcance de los procedimientos.
===============================================================

Todo el código debe encontrarse en el área de declaraciones generales, procedimientos
de usuario o procedimientos de evento. Si agrega código fuera de cualquiera de estas
zonas, nunca se ejecutará. Por ejemplo:
Sub cmdDespliega_Cllck()

LbITexto.Caption = "¡ ¡ ¡Bienvenido a Visual Basic! ! !”
End Sub
frmMensaje.Caption = "Bienvenida"

Sub cmdSalir_Cllck()

End
End Sub
La línea frmMensaje.Caption = "Bienvenida" no se ejecutará nunca, ya que no forma
parte del código de evento de ningún procedimiento.

El editor de código de Visual Basic
Visual Basic posee una poderosa herramienta para editar código; entre las ventajas del
editor podemos mencionar las siguientes:
• Clasificación de elementos por colores que le permiten identificar los elementos del
programa.
• Reconoce los objetos y asiste en el uso de propiedades y métodos.
• Interpreta el lenguaje mientras se escribe el código; detecta errores de sintaxis al
momento de editar.
• Posee ayuda interactiva y contextual.






80 Parte 1: Entorno Integrado de Desarrollo
Antes de ver las posibilidades de edición, es necesario que comprendamos que un
lenguaje de programación siempre tiene reglas que determinan su estructura, tanto de
forma como de significado:
• Reglas de sintaxis (o sintácticas): Determinan la única forma de manifestar ins-
trucciones y expresiones, correctas y completas.
• Reglas de semántica (o semánticas): Determinan la validez del uso de expre-
siones dentro de una sintaxis correcta. El cumplimiento de las reglas semánticas
por lo general se ve en tiempo de ejecución, cuando se sabe el significado de las
expresiones.


===============================================================
Nota: Por expresión se debe entender todo valor o referencia de un valor:
• "A" & "B" (concatenación) es una expresión de tipo carácter que equivale a
"AB".
• 20/5 (división) es una expresión numérica que equivale a 4.
• 5 > 3 (comparación) es una expresión lógica que es True (verdadera).
===============================================================

Es importante comprender estos dos conceptos en virtud de que los errores en Visual
Basic serán violaciones a las reglas sintácticas o semánticas. Los errores de sintaxis no
deben preocuparle, ya que Visual Basic los reconoce en el mismo instante en que los
comete y le sugiere corregirlos, pero los errores de semántica pueden convertirse en
verdaderos dolores de cabeza, ya que son difíciles de identificar; es una buena práctica
que documente sus desarrollos a efecto de evitar errores.
En Visual Basic sólo podrá incluir como código instrucciones y funciones del lenguaje,
funciones y procedimientos definidos por el usuario, operadores y expresiones, cuidando
siempre la sintaxis y la semántica.
Al editor de código de Visual Basic se le llama ventana Código; ésta se puede utilizar
para escribir, mostrar y editar código de Visual Basic. El código de Visual Basic está
asociado a un módulo, por lo que puede abrir tantas ventanas Código como módulos
tenga, lo que facilita ver el código en diferentes formularios o módulos y copiarlo y
pegarlo entre ellos. En estos momentos, en su proyecto sólo tiene un módulo creado, que
es el formulario mismo.
Puede abrir una ventana Código:

• Utilizando la ventana Explorador de proyectos, seleccionando un formulario o módulo
y haciendo clic en el botón Ver código.
• Haciendo doble clic en un control o formulario.











Capítulo 4: Escritura del código de los eventos 81
• Seleccionando el menú Ver - Código.
• Presionando F7.
>> Cómo abrir la ventana Código. [04.01]
A continuación aprenderá cómo abrir la ventana Código.
1. En la ventana Explorador de proyectos seleccione el módulo frmMensaje.
2. Haga clic en el botón Ver código
3. Presione Alt+F4 para cerrar la ventana Código.
4. Presione la tecla F7.
5. Presione Alt+F4 para cerrar la ventana Código.
6. Seleccione el menú Ver - Código.
7. Presione Alt+F4 para cerrar la ventana Código.
8. Haga doble clic en el objeto cmdDespliega.
9. Presione la tecla Ctrl+F4 para cerrar la ventana Código.
Elementos de la ventana Código
La ventana Código está compuesta de los siguientes elementos:
• Cuadro Objeto, Muestra el nombre del objeto seleccionado. Haga clic en la flecha
situada a la derecha del cuadro de lista para mostrar una lista de todos los objetos
asociados con el formulario.
• Cuadro Procedimiento/Evento. Presenta una relación de todos los eventos re-
conocidos por Visual Basic para un formulario o control mostrado en el cuadro
Objeto. Cuando seleccione un evento, el procedimiento de evento asociado con ese
evento se muestra en la ventana Código.
• Barra de división. Si arrastra hacia abajo esta barra, la ventana Código se divide en
dos paneles horizontales, cada uno de los cuales tiene sus propias barras de
desplazamiento. Puede ver diferentes partes del código a la vez. La información
que aparece en los cuadros Objeto y Procedimiento/Evento se aplica al código del
panel que tiene el enfoque. Si arrastra la barra a la parte superior o inferior de la
ventana o hace doble clic en ella, se cierra un panel.
• Botón Ver procedimiento. Muestra el procedimiento seleccionado. En la
ventana Código sólo se muestra un procedimiento a la vez.















82 Parte 1: Entorno integrado de Desarrollo
• Botón Ver módulo completo. Muestra todo el código del módulo.
La figura 4.4 muestra dónde se localizan cada uno de los componentes.

>> Cómo manejar los componentes de la ventana Código. [04.02]
A continuación aprenderá a manejar los elementos de la ventana Código.
1. Seleccione el objeto frmMensaje.
2. Presione la tecla F7.
3. Haga clic en el botón Ver procedimiento. Observe que solamente se mostrará el
procedimiento que tiene el enfoque.

===============================================================
Nota: En Visual Basic, aquel objeto o elemento que posee el cursor (que puede res-
ponder al teclado) tiene el enfoque.
===============================================================


















Capítulo 4: Escritura del código de los eventos 83
4. Haga clic en el botón Ver módulo. Se mostrarán todos los procedimientos defi-
nidos hasta el momento.
5. En el cuadro Objeto seleccione el objeto cmdSalir.
6. En el cuadro Procedimiento/Evento seleccione LostFocus.
7. Arrastre la barra de división hasta que quede a la mitad de la ventana Código.
Debe verse aproximadamente como se muestra en la figura 4.5.



8. Puede editar en cualquiera de las dos mitades. Esta característica es muy
valiosa en proyectos con código muy extenso. Haga doble clic en la barra de
división para eliminarla.
9. Marque todo el código que tenga en la ventana Código y presione Supr para
eliminarlo. La ventana Código debe quedar sin contenido.
10. Presione Alt+F4 para cerrar la ventana Código.

















84 Parte 1: Entorno Integrado de Desarrollo

===============================================================
Nota: La ventana Código tiene la misma funcionalidad que cualquier editor de texto
basado en Windows, por lo que seleccionar texto, eliminar, copiar, pegar, reemplazar,
etcétera, se realiza de la misma forma que si lo estuviera haciendo en Word, WordPad o
Notepad.
===============================================================

Caracteres especiales
Antes de que comencemos con la edición de código, es recomendable que sepa la exis-
tencia de caracteres especiales con significado en el lenguaje de Visual Basic.
• Apóstrofe (‘). Todo el código que continúe en la misma línea (hasta encontrar fin de
línea) será interpretado como comentario.
• Comillas dobles ( “ ”). Siempre engloban una expresión de tipo carácter, por lo que
siempre que abra unas comillas, tendrá que cerrarlas.
• Carácter de subrayado ( _ ). Es el continuador de línea de Visual Basic. Antes de
éste siempre debe haber cuando menos un espacio en blanco, y después de éste nunca
debe haber nada, o de lo contrario se generará un error.


Asistencia en la edición de código
Una de las capacidades más sobresalientes de Visual Basic es el soporte a la edición que
da la ventana Código. Cuando edita código en algún procedimiento, se dice que está en
modo de edición de código. El soporte se brinda de varias maneras:
• Manejo de colores. Permite identificar por colores lo que se está editando; las
palabras reservadas e instrucciones de Visual Basic aparecerán en azul, los errores de
sintaxis que Visual Basic detecte en tiempo de edición aparecerán en rojo, las
expresiones aparecerán en negro y los comentarios que se hagan en el código
aparecerán en verde; lo que aparezca en verde carecerá de significado para el
compilador.
• Sugerencia de propiedades y métodos en modo de edición. Visual Basic sugiere qué
propiedades y métodos son aplicables para un objeto determinado, reconocido por el
simple hecho de formar parte de un formulario.
• Sugerencia de sintaxis. Muestra en modo de edición de código la sintaxis correcta de
la función o instrucciones que está a punto de escribir.
• Ayuda contextual. Proporciona ayuda contextual sobre lo que está tecleado, siempre
y cuando exista ayuda disponible.
• Formato de texto. Aplica autoformato al código, a efecto de que sea más legible y
estándar en cuanto al estilo.












Capítulo 4: Escritura del código de los eventos 85
>> Manejo de colores y autoformato al editar código. [04.03]
A continuación aprenderá a utilizar las formas de asistencia en la edición de código que
proporciona Visual Basic.
1. Haga doble clic en el objeto cmdDespliega. Visual Basic determina que el proce-
dimiento de evento más común para un objeto basado en el control
CommandButton es Click, por lo mismo procede a editar de manera
predeterminada dicho procedimiento.
¿De qué color están las palabras Sub y End Sub, y por qué tienen ese color?
Color: ______________
¿Por qué?
________________________________________________________

===============================================================
Nota: En Visual Basic una línea de código no es evaluada y aceptada hasta que cambia
de línea, ya sea utilizando las flechas de dirección o la tecla Intro.
===============================================================

2. Teclee lo siguiente como código de evento (el primer carácter es un apóstrofe).
' Instrucción que emite sonido por el altavoz
¿De qué color se puso la línea y por qué tiene ese color?
Color: ______________
¿Por qué?
________________________________________________________
3. Teclee la siguiente línea de código debajo del comentario que acaba de escribir
(escríbalo todo en mayúsculas).
BEEP

¿Aplicó Visual Basic autoformato a su instrucción?. ______________________









86 Parte 1: Entorno Integrado de Desarrollo
Hasta el momento su código debe lucir como se muestra en la figura 4.6.

>>Compilación y detección de errores en modo de edición. [04.04]
1. Continúe editando el código; escriba la siguiente línea (escriba hasta el punto, pero
NO ACEPTE LA LÍNEA TODAVÍA):
MiObjeto.

¿Existe algún objeto en su formulario llamado MiObjeto?. _______________
¿Al teclear el punto Visual Basic respondió de alguna forma?. _______________


















Capítulo 4: Escritura del código de los eventos 87

2. Ahora sí, acepte la línea (utilice las flechas de dirección o Intro para pasar a la siguiente
línea). Visual Basic detecta un error de sintaxis y envía un error, como se muestra en la
figura 4.7. Observe que la línea que causa el error se pone en rojo; cualquier línea en
rojo en modo de edición de código es sinónimo de problemas.


3. Elimine la línea que causa el problema.
>> Sugerencia de propiedades y métodos en modo de edición. [04.05]
1. A continuación teclee una línea de código, pero hágalo en partes, sin presionar
Intro y sin cambiarse de línea, comenzando con lo siguiente:
LblTexto.



















88 Parte 1: Entorno Integrado de Desarrollo


Observe que al llegar al punto, Visual Basic determina que efectivamente existe un
objeto llamado lblTexto, identifica en qué tipo de control está basado el objeto
(Label) y muestra todas las propiedades y métodos válidos para dicho control (vea la
figura 4.8) a través de un cuadro de lista combinado de sugerencias. Vea que de
momento no está seleccionada ninguna propiedad o método de la lista.
2. En cuanto comience a teclear un poco más, alfabéticamente se ubicará en la lista la
propiedad o método que corresponda con lo que está tecleando (vea la figura 4.8).


Proyect
3. Continúe tecleando en la misma línea lo siguiente:
lblTexto.Ca
4. Observe que el simple hecho de comenzar a teclear la continuación de la línea,
encuentra la probable palabra que desea. Teclee sólo las letras que requiera basta
encontrar la palabra Caption.
5. Una vez que esté seleccionada la opción que desea, en este caso Caption (vea la
figura 4.9), presione la barra espaciadora y Visual Basic colocará el nombre de la
propiedad por usted. Quizá en propiedades como Top o Left le resulte más












Capítuio 4: Escritura del código de los eventos 89

simple teclear de manera completa el nombre de la propiedad; sin embargo, algunos
objetos tienen propiedades de nombre muy largo, como StartUpPosition, en donde
una ayuda no está de más. Un beneficio adicional: dejar que Visual Basic le asista en el
nombre de las propiedades le garantiza que no tendrá errores de sintaxis, debido a
nombres de propiedades mal escritos.


6. Termine de capturar, de tal forma que la línea completa quede como se muestra a
continuación:
lblTexto.Caption = "¡¡¡Bienvenido a Visual Basic!!!"
7. Borre todo el código que tenga tecleado y cierre la ventana Código.


















90 Parte 1: Entorno Integrado de Desarrollo
El evento predeterminado de los objetos
Como puede ver. Visual Basic y su editor de código permiten una interacción intuitiva
entre los objetos y lo que puede hacer con ellos; ya comprobó que cada objeto, al
momento de hacer doble clic en él en tiempo de diseño, activa la ventana Código en el
procedimiento de evento que Visual Basic considera como el más usual, a lo que
llamaremos evento predeterminado.
Por ejemplo, cada objeto creado basado en el control CommandButton tendrá como
evento predeterminado al evento Click; ¿para qué puede servir un botón, si no es para
hacer clic en él?
No obstante, en ocasiones no desea editar el evento predeterminado. Para editar cualquier
otro evento, puede utilizar el cuadro Objeto (la lista desplegable que aparece a la
izquierda, debajo de la barra de título de la ventana Código) y del cuadro Proce-
dimiento/Evento (la lista desplegable que aparece a la derecha, debajo de la barra de
título de la ventana Código). Puede, sin necesidad de estar haciendo doble clic en los
objetos que tiene en modo de diseño, editar todos los procedimientos de todos los objetos
disponibles en la interfaz.
>> Uso de los cuadros Objeto y Evento para la selección y codificación de un proce-
dimiento de evento determinado. [04.06]
1. Haga doble clic en el objeto cmdDespliega.
¿Qué procedimiento de evento se puso en modo de edición?


2. Escriba el siguiente código en dicho procedimiento:
Private Sub cmdDespliega_Click()
' Instrucción que emite sonido por el altavoz
Beep
' Cambia en modo de ejecución la propiedad
' Caption del objeto lblTexto

lblTexto.Caption = "¡¡¡Bienvenido a Visual Basic!!!"
End Sub








Capítulo 4: Escritura del código de los eventos 91

3. Despliegue la lista del cuadro Procedimiento/Evento; aparecerán los eventos
disponibles para el objeto cmdDespliega. Seleccione el evento GotFocus. El
procedimiento deberá agregarse en la ventana Código.
4. Despliegue nuevamente la lista del cuadro Procedimiento/Evento.
¿Qué diferencia existe, visualmente, entre Cllck y GotFocus?



5. Seleccione nuevamente GotFocus y escriba el siguiente código (asegúrese de dar
entrada a la línea de código, tecleando Intro al final de la línea):

Private Sub cmdDespliega_GotFocus()
' Comentario de prueba
End Sub
6. Despliegue nuevamente la lista del cuadro Procedimiento/Evento. Debe verse como
se muestra en la figura 4.10.



















92 Parte 1: Entorno Integrado de Desarrollo
¿Qué significa si un nombre de evento aparece en negritas?



7. Cierre la ventana Código y seleccione el objeto cmdDespliega (haciendo clic en
él).
8. Abra la ventana Código (F7).
9. Despliegue la lista del cuadro Objeto. Seleccione lblTexto.
¿Fue necesario hacer doble clic en el objeto lblTexto, en tiempo de diseño en el for-
mulario para poder editar su código?
____________________
10. Cierre la ventana Código.
¿Por el hecho de haber solicitado editar código para el objeto lblTexto, el objeto
cmdDespliega dejó de estar seleccionado?
____________________
>>Uso del carácter de subrayado y la ayuda contextual en modo de edición. [04.07]
1. Ya debe tener tecleadas todas las líneas del procedimiento cmdDespliega _Click
sin errores. Colóquese en la última línea que tecleó, exactamente después del signo de
igual ( = ) y antes de las comillas, teclee un espacio en blanco, seguido de un carácter
de subrayado (_), y después teclee Intro. El continuador de línea hizo su trabajo.
2. Ahora colóquese después la palabra "Bienvenido", inserte un espacio, teclee un
carácter de subrayado ( _ ) y después teclee Intro. Vaya una línea más abajo en el
código. Generará error, un continuador de línea nunca debe dejar incompleta




















Capítulo 4: Escritura del código de los eventos 93
una expresión. Corrija el problema eliminando el continuador de línea que causó el
error.
3. Su procedimiento debió haber quedado como se muestra a continuación:
Private Sub cmdDespliega_Click()
' Instrucción que emite sonido por el altavoz
Beep
' Cambia en modo de ejecución la propiedad
' Caption del objeto lblTexto
lblTexto.Caption = _
"¡¡¡Bienvenido a Visual Basic!!!"
End Sub


===============================================================
Lo inesperado: En la figura 4.3 se mostró el esquema de un procedimiento de
evento. En dicha figura no se hace referencia a la palabra Private, que como vemos en
los subsecuentes ejemplos, sí aparece. Esa palabra se agrega de manera predeterminada e
indica el alcance del procedimiento; no es obligatoria. Con o sin la indicación Private,
el procedimiento funciona; quisimos dejarla para que no se sorprenda cuando la vea.
===============================================================
4. En el cuadro Objeto seleccione el objeto cmdSalir y en el cuadro Procedimien-
to/Evento seleccione Click. Escriba el siguiente código:

Private Sub cmdSalir_Click()

End
End Sub
5. ¿Para qué sirve la instrucción End? Para saberlo, coloque el cursor exactamente sobre la
palabra End( entre la "E" y la "n" estaría bien). Presione F1. Aparecerá la ventana de
ayuda de Visual Basic con la ayuda relativa a la orden. Si tiene dudas de alguna
instrucción o función, esta ayuda contextual puede ser de gran utilidad. Cierre la
ventana de ayuda presionando Alt+F4. En este caso, End termina con la ejecución de
la aplicación.







94 Parte 1: Entorno Integrado de Desarrollo
6. Estando en la ventana Código, presione Alt+F4 para cerrar dicha ventana.
Una de las cosas más importantes al estar codificando en Visual Basic es la de dar már-
genes a la izquierda, a lo que se llama sangría. Vea lo siguiente:


Observe que la distribución A deja en claro cuál es el código de evento, dónde inicia y
dónde termina el procedimiento. La distribución B es más confusa, y una vez teniendo más
procedimientos y estructuras de control en el código, el problema se complica.
Al estar detallando los ejemplos en este libro, pondremos las tabulaciones ideales;
trate de escribir el código tal y como aparece en el texto. Aunque en este libro también
ponemos la línea de inicio y de conclusión del procedimiento (Sub, EndSub), usted no
tendrá que teclear esas líneas, pues Visual Basic las escribe automáticamente.
Convenciones para la codificación
Hasta ahora, en el libro ha visto que para codificar un procedimiento de evento, per-
teneciente a un objeto, decimos "seleccione el objeto y presione F7, o bien haga doble clic
en el objeto"; también podemos decir "abra la ventana Código y en el cuadro Objeto
seleccione el objeto que desea codificar, después en el cuadro Procedimiento/Evento,
seleccione el evento que desea codificar".
Suponga que deseamos editar en el procedimiento cmdSalir_click, por lo cual
diríamos "seleccione el objeto cmdSalir y presione F7, o bien haga doble clic en el
objeto cmdSalir en tiempo de diseño en el formulario"; también podemos decir "abra la
ventana Código, despliegue el cuadro Objeto, seleccione el objeto cmdSalir y en el
cuadro Procedimiento/Evento, seleccione Click". ¡Qué tedioso! Es más fácil hacerlo
que leerlo.
Puesto que en este libro codificará todo el tiempo y seguirá siempre estos procedimientos,
es recomendable que establezcamos una convención para decir lo mismo, pero más fácil.
¿Qué le parece lo siguiente?

















Capítulo 4: Escritura del código de los eventos 95
Editar código: cmdSalir, Evento: Clíck.
Con ello asumimos que no tendremos que repetir que en caso de que no se encuentre en la
ventana Código, es necesario que la abra; asimismo, no será necesario que le digamos a
detalle cómo llegar a editar el procedimiento de evento mencionado para el objeto referido.
Estamos seguros de que está de acuerdo con nosotros en que entender de una vez esto le
puede ahorrar mucha lectura de lo que ya resulta obvio. Después de todo, siempre sabrá
qué objeto es el que desea codificar, y en qué evento.
También sabemos que todo procedimiento tiene inicio y fin:
Private Sub cmdSalir_Click()
End
End Sub
Por lo tanto no es necesario que coloquemos las líneas de inicio y fin todo el tiempo; por
ejemplo, para obtener el código anterior sería suficiente lo que se muestra a continuación:
Editar código: cmdSalir, Evento: Click.
End

Existen algunas excepciones que es recomendable precisar para el funcionamiento óptimo
de esta convención; por ejemplo, su formulario se llama frmMensaje, y es el objeto
contenedor de todos los demás objetos. Si lo busca en el cuadro Objeto de la ventana
Código, se topará con la sorpresa de que es el único objeto de su interfaz que no aparece.
Esto se debe a que dicho objeto actúa como contenedor del módulo, y Visual Basic lo
llama, para efecto de los eventos, simplemente Form, llámese como se llame el objeto
Form.
También es importante que sepa que sí es posible editar código fuera de un procedimiento,
siempre y cuando se escriba al principio de toda codificación, en una parte conocida como
declaraciones generales.














96 Parte 1: Entorno Integrado de Desarrollo
Para editar las declaraciones generales podemos decir: "escriba en las declaraciones
generales el siguiente código", o bien. Editar código: (General) Evento: (Declarations).
También será necesario, con aquellos procedimientos muy largos, agregar código después
de la última línea que hayamos codificado; para ello haremos la referencia:
Continuar editando código: cmdSalir, Evento: Click.
Que indica que continuaremos codificando después de la última línea que hayamos
codificado del procedimiento en cuestión.
En caso de que necesitáramos agregar código en una parte que no está después de la última
línea codificada, haremos la siguiente referencia:
Modificar código: cmdSalir, Evento: Click.
Private sub cmdSalir_Click( )
MsgBox "Muchas gracias por utilizar este programa"
End
Se hace la referencia del evento a modificar, se escriben las líneas que se mantienen
intactas en letra normal, y lo que se modifica se pone en negritas.
Especificaciones de codificación
Será la forma en que se codificarán los programas en este libro. Las especificaciones de
codificación estarán integradas por las siguientes partes:
• Identificación del módulo (formulario) sobre el que hay que trabajar.
• Especificación de código a agregar. Abrir la ventana Código, seleccionar el objeto del
que desea editar un procedimiento de evento, a través del cuadro Objeto; seleccionar el
evento en el que desea agregar código de evento, a través del cuadro
Procedimiento/Evento. Escribir el código de evento.
• Especificación de código a editar. Seleccionar el procedimiento de evento que está
inconcluso, y continuar con la codificación.
• Especificación de código a modificar. Seleccionar el procedimiento de evento que se va a
modificar, haciendo los cambios deseados.
















Capítulo 4: Escritura del código de los eventos 97
En nuestro ejemplo, la codificación quedaría cómo se muestra a continuación:
Codificación de frmMensaje
• Editar código: cmdDespliega, Evento: Click.

‘ Instrucción que emite sonido por el altavoz
Beep
lblTexto.caption = _
"¡¡¡ Bienvenido a Visual Basic!!!"
• Editar código: cmdSalir, Evento: Click.
End

¿Qué hacer con los procedimientos de evento sin código?
Visual Basic asume muchas cosas con tal de facilitarle el trabajo. Por ejemplo, ya vimos
que al hacer doble clic en modo de diseño en un botón de comando, automáticamente se
abre la ventana Código sobre el procedimiento de evento Click para dicho objeto; Visual
Basic hace esto porque asume que la tarea más común que se hace con un botón de
comando es hacer clic en él para desencadenar una tarea.
Cada objeto, dependiendo del control sobre el que esté basado, tendrá un procedimiento de
evento predeterminado que se editará con el simple hecho de que invoque la ventana
Código cuando el objeto está seleccionado.
Sin embargo, hay ocasiones en las que no se desea editar un determinado procedimiento
que Visual Basic coloca de manera predeterminada al invocar la ventana Código. Quizá
resulte molesto tener que eliminar procedimientos que usted no haya agregado La figura
4.5 muestra muchos procedimientos que realmente no se utilizan.
No se preocupe por aquellos procedimientos de evento que no tienen código de evento
(procedimientos que entre el inicio y fin del procedimiento no tienen nada de código). Para
visual Basic es como si no existieran.
Al momento de ejecutar la aplicación. Visual Basic detectará que no tienen código de
evento, y procederá a borrarlos automáticamente.









98 Parte 1: Entorno Integrado de Desarrollo
__________________________________________________________________________
Resumen
En este capítulo:
• Vimos qué son los eventos y los procedimientos de evento. ,
• Vimos qué nomenclatura se aplica a los procedimientos de evento.
• Vimos la utilidad de las herramientas que están integradas en la ventana Código.
• Vimos los elementos que componen a la ventana Código.
• Vimos qué caracteres especiales tienen significado particular en la codificación en Visual
Basic.
• Vimos la asistencia en modo de edición, mediante colores.
• Vimos la asistencia en modo de edición, a través de sugerencias de propiedades y
métodos.
• Vimos la importancia de la distribución del código para que éste sea legible.
• Establecimos convenciones para utilizar en el resto del libro.
Es muy importante que domine todos los puntos antes mencionados, para que el proceso de
codificación sea lo más asistido posible.

Algunas respuestas a los ejercicios
[04.03] Manejo de colores y autoformato al editar código.
1. Color: Azul, ¿por qué? Porque son palabras reservadas de Visual Basic.
2. Color: Verde, ¿por qué? Porque es un comentario, sin significado para el compilador de
Visual Basic.
3. Sí lo aplicó.
[04.04] Compilación y detección de errores en modo de edición.
1. No existe ningún objeto llamado MiObjeto. Al llegar al punto después de MiObjeto,
Visual Basic no respondió de ninguna forma.






















Capítulo 4: Escritura del código de los eventos 99
[04.06] Uso de los cuadros Objeto y Evento para la selección y codificación de un
procedimiento de evento determinado.
1. Click
4. Click está en negritas y GotFocus no lo está.
6. Si está en negritas indica que el evento para el objeto en cuestión tiene código escrito
dentro de sí.
9. No
10. No



















































100
























































Capítulo
5
Cómo guardar
y ejecutar
aplicaciones
Objetivos
Conocer la forma en que se guardan las aplicaciones desarrolladas en Visual Basic,
cómo se ejecutan para su depuración y cómo compilarlas para generar un programa
ejecutable.
Al finalizar este capítulo deberá:
• Saber cómo guardar aplicaciones
• Saber de qué forma se almacena su trabajo en Visual Basic
• Saber cómo ejecutar sus aplicaciones y depurarlas
• Saber cómo compilar las aplicaciones para generar un programa ejecutable
(EXE)
Después de este capítulo tendrá todos los elementos para desarrollar aplicaciones en
Visual Basic de manera rápida. Prepárese, porque a partir de este capítulo adquirirá la
destreza en la programación en Visual Basic, propia del que sabe.
101






102 Parte 1: Entorno Integrado de Desarrollo
¿Cómo se almacena su trabajo en Visual Basic?
Si está acostumbrado a trabajar con programas como Word o PowerPoint, sabe que al
guardar su trabajo, éste es almacenado en un solo archivo de extensión doc o ppt,
respectivamente. Como ya sabrá gracias a su experiencia en el manejo de Windows,
hay archivos de extensión específica que se identifican como trabajo propio en un
programa determinado.
Visual Basic también tiene sus archivos específicos, aunque su conceptualización no
es tan primaria y simple como en el caso de Word o PowerPoint. Visual Basic tiene
muchas variantes que pueden darse en la creación de los proyectos, tan es así que
algunos recursos útiles para una aplicación no lo son para otras. La consecuencia
directa de este hecho es la división del trabajo en archivos de diferente tipo.
Cuando desarrolla una aplicación en Visual Basic, trabaja con un archivo de proyecto
para administrar todos los diferentes archivos que se crean. Un proyecto puede
constar 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 pro-
piedades de controles del formulario (.frx). Estos archivos no se pueden mo-
dificar y son generados automáticamente por cualquier archivo de formulario
(.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 aso-
ciados con el proyecto, así como información acerca de las opciones de entorno esta-
blecidas. Esta información se actualiza cada vez que se guarda el proyecto.
Todos los archivos y objetos presentes en un proyecto se pueden compartir con otros
proyectos, lo que le da a Visual Basic una facilidad de reuso de código, muy impor-
tante para aquellas organizaciones que tienen una forma estándar de trabajar y que no
desean invertir tiempo en desarrollar lo ya desarrollado.




Capítulo 5: Cómo guardar y ejecutar aplicaciones 103
Cómo guardar aplicaciones
Una vez que ha creado la interfaz, asignado propiedades a los objetos y agregado el
código de los eventos, lo recomendable es que guarde su trabajo en un medio de alma-
cenamiento donde se pueda recuperar posteriormente. Mientras no guarde su trabajo,
éste se encontrará en la memoria RAM, que por su naturaleza temporal no es con-
fiable; una interrupción en la energía eléctrica o un error de la estación de trabajo
pueden ocasionar la pérdida de todo el trabajo que ha estado realizando.
Para almacenar su trabajo. Visual Basic tiene una jerarquía de contenedores, formada
por lo siguiente:
• Módulos. El código en Visual Basic se almacena en módulos; hay 3 tipos de mó-
dulos: formulario, estándar y de clase. En los módulos se pueden colocar decla-
raciones de constantes, tipos, variables y procedimientos de bibliotecas de vínculos
dinámicos (DLLs) al nivel de módulo; también pueden estar contenidos los
procedimientos, en cualquiera de sus modalidades (Sub, Function o
Property). Un módulo siempre está asociado a un proyecto de Visual Basic;
la forma más común de encontrar un módulo en un proyecto es en forma de
formulario.
• Proyectos. Es uno de los denominados objetos genéricos de colección; estos objetos
permiten agrupar diversos elementos, manteniéndolos relacionados como un todo.
En el caso de los proyectos de Visual Basic, permiten agrupar todos los módulos
que componen una determinada aplicación. Un proyecto en Visual Basic siempre
contiene uno o más módulos.
• Grupos de proyectos. Es una colección de proyectos. Consiste en un archivo que
relaciona como miembros de un todo a varios proyectos de Visual Basic. El grupo
de proyectos no es un objeto, y puede o no existir.
La figura 5.1 muestra la jerarquía de contenedores que existe en Visual Basic. Consi-
dere lo siguiente: para poder utilizar un módulo, deberá pertenecer a un proyecto; un
proyecto sin módulos no tiene razón de ser, por lo tanto, los módulos y los proyectos
son inseparables. El grupo de proyectos sólo existe cuando dos o más proyectos coin-
ciden en una sesión de trabajo de Visual Basic.

=============================================================
Nota: Un proyecto en Visual Basic (.vbp) tiene sus propiedades específicas, por lo
que al seleccionarlo en la ventana Explorador de proyectos, la ventana Propiedades
mostrará las que le corresponden. No son muchas, de hecho un proyecto tiene una
sola propiedad (Name), que permite referir al proyecto con un nombre lógico, evitan-
do la necesidad de hacer referencia al nombre físico del archivo que se guarda (.vbp).


104 Parte 1: Entorno Integrado de Desarrollo
No descarte la posibilidad de que en versiones posteriores de Visual Basic, el número
de propiedades para un proyecto se incremente.


Los módulos y proyectos son tan dependientes entre sí que cuando guarda por primera
vez su trabajo, se sigue la secuencia que se describe a continuación:
• Visual Basic le pide que guarde el módulo, porque sin módulo no existe proyecto.
• Visual Basic le pide que guarde el proyecto, porque sin proyecto el módulo no se
puede ejecutar.
• Por último. Visual Basic le pide que guarde el grupo de proyectos. Esto es opcional
y sólo es posible en caso de que su aplicación tenga más de un proyecto abierto
en una misma sesión de Visual Basic.
Existen otros objetos contenedores que no fueron mostrados en la figura 5.1, como los
objetos basados en los controles Frame e Image; sólo mencionamos el grupo,
proyecto y formulario porque son los únicos manejados a nivel archivo del sistema
operativo.
Frame e Image pueden contener objetos, pero éstos a su vez ya están dentro de un
formulario y no requerirían un archivo para su existencia.
>> Archivos de trabajo en Visual Basic. [05.01]
A continuación aprenderá qué archivos almacenan su trabajo en Visual Basic y en qué
orden se guardan. Comprobará que siempre, y como mínimo, se guardará un formu-






Capítulo 5: Cómo guardar y ejecutar aplicaciones 105
lario y un proyecto; en caso de que existan más de dos proyectos en la sesión de tra-
bajo, opcionalmente podrá guardar un grupo de proyectos.
1. Si tiene abierta una sesión en Visual Basic, ciérrela utilizando el menú Archivo
Salir, o bien presionando Alt+Q.
2. Inicie nuevamente sesión en Visual Basic y genere un nuevo proyecto EXE
estándar.
3. Observe la ventana Explorador de proyectos; en la jerarquía está representado un
solo proyecto (Proyecto1), mismo que contiene un solo formulario (Form1).
¿Qué dice la barra del título de la ventana Propiedades?


4.. Sabemos que al proyecto le corresponde un archivo de extensión .vbp, y al for-
mulario un archivo de extensión .frm.
=============================================================
Nota: Visual Basic asigna nombres predeterminados a los formularios (Formn.frm),
a los proyectos (Proyecton.vbp) y a los grupos (Grupon.vbg), ya que desde el inicio
deben tener un nombre. No utilice estos nombres, ni siquiera como trabajo de prueba;
acostúmbrese a asignar sus propios nombres.
Utilizar los nombres predeterminados es inseguro y confuso; considere dichos nom-
bres como reservados para el uso de Visual Basic.
=============================================================
5. Guarde su trabajo por primera vez haciendo clic en el botón Guardar
proyecto de la barra de herramientas.
6. Si es ser la primera ocasión que guarda su proyecto. Visual Basic le preguntará
cómo desea que se llamen sus archivos; actualmente tienen los nombres prede-
terminados que Visual Basic asigna. Guarde sus archivos de prueba en el direc-
torio que corresponde a las prácticas de este capítulo (\avbp\cap05\).
7. Aparecerá el cuadro de diálogo Guardar archivo como; en Nombre de archivo
escriba frmBorra1 (observe que en el cuadro de texto Guardar como tipo dice
Formulario (*.frm), es decir, primero se guarda el formulario).
8. Después de guardar el formulario, aparecerá el cuadro de diálogo Guardar
proyecto como; en Nombre de archivo escriba Borra1 (observe que en el cuadro
de texto Guardar como tipo dice Proyecto (*.vbp), es decir, después del
formulario se guarda el proyecto). En este momento ya tiene guardado el formu-
lario y el proyecto, físicamente, en su computadora.


106 Parte 1: Entorno Integrado de Desarrollo
9. Haga clic en el botón Agregar proyecto EXE estándar.
10. Vea la ventana Explorador de proyectos y observe que se ha agregado a la
jerarquía un nuevo proyecto (Proyecto2) con su formulario correspondiente
(Form1).
¿Qué dice la barra del título de la ventana Propiedades?


11. Guarde su trabajo haciendo clic en el botón Guardar proyecto de la barra de
herramientas.
12. Aparecerá el cuadro de diálogo Guardar archivo como; en Nombre de archivo
escriba frmBorra2 (observe que en el cuadro de texto Guardar como tipo dice
Formulario (*.frm), es decir, primero se guardan los formularios pendientes de
guardarse).
13. Después de guardar los formularios pendientes de guardarse, aparecerá el cuadro
de diálogo Guardar proyecto como; en Nombre de archivo escriba Borra2
(observe que en el cuadro de texto Guardar como tipo dice Proyecto (*vbp), es
decir, después de los formularios se guardan los proyectos pendientes de guar-
darse). En este momento ya tiene guardado el formulario y el proyecto que
faltaban de guardarse, físicamente, en su computadora.
14. A continuación aparecerá la ventana Guardar grupo de proyectos como; en
Nombre de archivo escriba grpBorrar (observe que en el cuadro de texto
Guardar como tipo dice Grupo de proyectos (*.vbg), es decir, al detectar 2 o
más proyectos en la sesión, Visual Basic procede a guardarlos como grupo).
15. Guarde su trabajo haciendo clic en el botón Guardar proyecto de la barra
de herramientas.
Ya no aparecen las ventanas de Guardar cómo... ¿Por qué?









Capítulo 5: Cómo guardar y ejecutar aplicaciones 107
>> Cómo abrir un proyecto previamente guardado. [05.02]
A continuación aprenderá cómo abrir un proyecto existente.
1. Abra un proyecto existente, utilizando el menú Archivo - Abrir proyecto, o bien
presionando Ctrl+0.
2. Abra el archivo que se encuentra en el directorio \avbp\c02, llamado Saludo.vbp.
3. Si el formulario no aparece en primera instancia, expanda la jerarquía en la ventana
Explorador de proyectos, hasta que vea el formulario Form1 (frmMensaje).
Haga clic en el botón Ver objeto, de la misma ventana.
Recomendaciones para nombrar archivos en Visual Basic
Actualmente ya sabe cómo guardar su trabajo. Unas últimas recomendaciones para
nombrar los archivos:
• Es recomendable que el archivo de formulario (.frm) se llame igual que la propiedad
Name del formulario que almacena. En nuestro ejemplo, el objeto basado en el
control Form se llama frmMensaje, y por tanto, el archivo de formulario ter-
minó llamándose frmMensaje.frm.
• Es recomendable que el archivo de proyecto (.vbp) se llame de una forma repre-
sentativa de la aplicación que contiene. Esto es importante, ya que el proyecto se
compilará para generar un programa ejecutable (.exe), y su nombre debe ser natural
y atractivo.
=============================================================
Nota: Un ejemplo de la conveniencia de la representatividad del nombre del pro-
grama ejecutable es el siguiente: la mayoría de los programas instaladores se llaman
Instalar.exe o Setup.exe; el nombre del programa da una idea clara de la función que
realizan.
Si el programa instalador se llamara inpvb60.exe (porque es la Instalación de su
Nuevo Proyecto en Visual Basic 6.0), el nombre sería poco natural y hasta inade-
cuado. El programa ejecutable puede llamarse de manera diferente al proyecto a partir
del cual se genere, pero le sugerimos que no complique las cosas; procure que el
programa ejecutable se llame de la misma forma que el proyecto a partir del cual se
genera. Esto, en última instancia, tendrá injerencia en la forma en que el proyecto sea
nombrado.
=============================================================
• Es recomendable que el archivo del grupo de proyectos se llame de una forma re-
presentativa a lo que agrupa; no llame al grupo de programas igual que un pro-


108 Parte 1: Entorno Integrado de Desarrollo
yecto contenido en él. Eso pone en evidencia que quizá la creación de un grupo de
proyectos no era necesaria.
=============================================================
Nota: Visual Basic permite el uso de un mismo formulario en varios proyectos; un
formulario no pertenece de manera exclusiva a un proyecto. Si desea agregar un for-
mulario existente (.frm) a un proyecto, seleccione el proyecto en la ventana
Explorador de proyectos, haga clic con el botón derecho de su ratón, con lo que
aparecerá un menú contextual. Seleccione Agregar - Agregar archivo y el formulario
que desee integrar.
=============================================================
Cómo ejecutar su aplicación
Visual Basic le proporciona herramientas que le permiten desarrollar y diseñar apli-
caciones, incluso le permiten ejecutar la aplicación que desarrolló sin haber guardado
su trabajo. Esto tiene algo de aventura, ya que en la ejecución misma de la aplicación
pueden surgir problemas que no permitan regresar al entorno de desarrollo, siendo
imposible entonces guardar lo que no haya guardado. En esta parte del libro veremos
cómo ejecutar y depurar su aplicación, pero aprenda la regla de oro: guarde su trabajo
antes de ejecutar su aplicación.
Visual Basic le asistirá al momento de ejecutar su aplicación para que le sea más sen-
cillo comprobar que sus programas hacen lo que deben; básicamente se trata de cubrir
dos tareas fundamentales de la programación:
• Ejecutar consiste en poner en operación los elementos diseñados y codificados en
tiempo de diseño. Al ejecutar la aplicación Visual Basic entra en tiempo de
ejecución, se pone sensible a todos los eventos, y por supuesto, es cuando suce-
den los errores, sean de sintaxis o de semántica.
• Depurar consiste en probar el funcionamiento de la aplicación, provocar los errores
y corregirlos. Al momento de depurar sus aplicaciones debe cambiar de actitud
con respecto a sus programas, debe ser el crítico más feroz y el usuario más necio
e impredecible, debe hacer lo que nadie en todos sus sentidos haría; debe
intentar, de manera decidida, que su aplicación genere errores y comportamientos
equivocados. El tiempo que dedique a depurar será recompensado con la
confianza que tendrá en que su aplicación esté correcta.
=============================================================
Nota: El tiempo de ejecución se divide en dos partes: el modo ejecución, cuando la
aplicación está ejecutándose brindando total atención a las acciones que el usuario
realiza, y el modo de interrupción, cuando la aplicación está ejecutándose de manera





Capítulo 5: Cómo guardar y ejecutar aplicaciones 109
parcial, ya que aparte de atender las acciones del usuario, atiende las facilidades de
depuración de Visual Basic.
=============================================================
En la figura 5.2 se muestran los botones de la barra de herramientas que permiten
controlar la ejecución de su aplicación.


A continuación se detalla cuál es la función de cada uno de los botones:
• Iniciar (menú Ejecutar - Iniciar, o F5). Inicia la ejecución del formulario;
cuando se inicia la ejecución, se dice que está en modo de ejecución. En caso de que
desee iniciar la ejecución después de corregir un error, haga che en el botón Iniciar y
la ejecución iniciará en donde se había interrumpido.
• Interrumpir (menú Ejecutar - Interrumpir, o Ctrl+Inter). Suspende o
interrumpe la ejecución iniciada de una aplicación. Una ejecución interrumpida
puede continuarse a partir del momento en que se interrumpió, mediante el uso del
botón Iniciar. Cuando la ejecución de un formulario está interrumpida, dicho
formulario puede estar visible, pero realmente no está ejecutándose; se dice que está
en modo de interrupción.
=============================================================
Nota: La interrupción de un programa sucede de tres maneras: haciendo clic en el
botón Interrumpir, por la presencia de un error o por haber encontrado un punto de
interrupción (breakpoint).
=============================================================




110 Parte 1: Entorno Integrado de Desarrollo
• Terminar (menú Ejecutar - Terminar). Da por concluida la ejecución de la
aplicación.
La figura 5.3 muestra la manera en que el desarrollo en Visual Basic termina con la

ejecución de las aplicaciones; todo lo que se hace en tiempo de diseño es bueno y
necesario, al igual que todo lo que se haga en modo de interrupción, sin embargo, lo
más importante es que su aplicación funcione finalmente, por lo que la ejecución es la
conclusión de todo proceso de desarrollo:


>> Cómo ejecutar e interrumpir su programa. [05.03]
A continuación aprenderá a ejecutar e interrumpir una aplicación.
Su aplicación está preparada para mostrar el mensaje ¡¡¡Bienvenido a Visual Basic!!!
al hacer clic en Mostrar Mensaje y concluir la ejecución al hacer Salir.
1. Haga clic en el botón Iniciar o presione la tecla F5 para iniciar la ejecución.
¿En qué modo se encuentra?

2. Haga clic en el botón Mostrar Mensaje. Vea cómo el programa responde como se
esperaba, haciendo un sonido y mostrando el mensaje indicado.





Capítulo 5: Cómo guardar y ejecutar aplicaciones 111
3. Haga clic en el botón Salir. Vea cómo el programa responde como se esperaba,
terminando la ejecución de la aplicación.
4. Haga clic en el botón Iniciar o presione la tecla F5 para iniciar nuevamente la
ejecución.
5. Haga clic en el botón Interrumpir.
¿En qué modo se encuentra?

6. Haga clic en el botón Salir.
La ejecución de la aplicación no se dio por concluida, en otras palabras, el botón Salir
no hizo lo que debía. ¿A qué se debió?

7. Haga clic en el botón Iniciar o presione la tecla F5 para reanudar la ejecución.
8. Haga clic en el botón Terminar para concluir con la ejecución de la aplicación.
Al iniciar la ejecución, Visual Basic optó por ejecutar el formulario frmMensaje;
eso es obvio y comprensible, ya que es el único formulario del único proyecto que se
encuentra actualmente cargado en la sesión de Visual Basic. Pero ¿qué pasa cuando
hay varios proyectos cargados y éstos tienen varios formularios? En ese caso, debe
especificar claramente cuál es el proyecto inicial, y en dicho proyecto inicial, el
objeto inicial (formulario). El objeto inicial siempre pertenece al proyecto inicial.
>> Cómo seleccionar el proyecto inicial. [05.04]
A continuación aprenderá a determinar qué proyecto de entre varios será el inicial.
1. Haga clic en el botón Agregar proyecto de EXE estándar. Tendrá lo que se
muestra en la figura 5.4:




112 Parte 1: Entorno Integrado de Desarrollo

Proyecto1(Saludo.vbp) aparecerá en negritas, ya que es el proyecto considerado
inicial.
2. Seleccione el Proyecto2 (Proyecto2), haga clic con el botón derecho del ratón para
que aparezca el menú contextual seleccione Establecer como inicial. Dicho proyecto
deberá establecerse como el inicial.
3. Haga clic en el botón Iniciar o presione la tecla F5 para iniciar la ejecución.
No se ejecutó frmMensaje, ¿Por qué?



4. Seleccione el Proyecto1(Saludo.vbp), haga clic con el botón derecho del ratón
para que aparezca el menú contextual y seleccione Establecer como inicial. Dicho
proyecto deberá establecerse como el inicial.
5. Haga clic en el botón Iniciar o presione la tecla F5 para iniciar la ejecución.
Deberá ejecutarse frmMensaje.
6. Haga clic en el botón Terminar, para concluir con la ejecución de la aplicación.





Capítulo 5: Cómo guardar y ejecutar aplicaciones 113
7. Seleccione el Proyecto2 (Proyecto2), haga clic con el botón derecho del ratón para
que aparezca el menú contextual y seleccione Quitar proyecto. Este comando elimina un
proyecto de un grupo de proyectos. Si Visual Basic le pregunta si quiere guardar
Proyecto2 y Form1, haga clic en No.
8. Guarde su trabajo haciendo clic en el botón Guardar proyecto de la barra de
herramientas.
9. En términos generales, el proyecto quedó como estaba, pero Visual Basic, por el simple
hecho de haber trabajado en un momento dado con dos proyectos simultáneamente,
asume que se está trabajando con un grupo de proyectos. Visual Basic le solicita un
nombre para guardar el grupo de proyectos. NO guarde el grupo de proyectos.
10. Salga de Visual Basic (No guarde el grupo de proyectos).
11. Entre nuevamente a Visual Basic y abra el proyecto Saludo.vbp. Al hacer esto, Visual
Basic pierde la referencia de que estamos trabajando con un grupo de proyectos.
Si tuviera varios formularios en un mismo proyecto, podría especificar qué formulario
desea que se ejecute al inicio, para ello debe seleccionar en la ventana Explorador de
proyectos, el proyecto en el que desea definir el objeto de inicio.
>> Cómo seleccionar el objeto de inicio en un proyecto. [05.05]
A continuación aprenderá dónde puede determinar cuál será el objeto inicial.
1. Seleccione el Proyecto1 (Saludo.vbp), haga clic con el botón derecho del ratón para
que aparezca el menú contextual y seleccione Propiedades de Proyecto1..., y aparecerá
la ventana Propiedades del proyecto que se muestra en la figura 5.5.
===============================================================
Nota: Tanto en la ventana Propiedades como en la ventana Propiedades del proyecto,
aparece como Nombre de proyecto el que Visual Basic le asignó de manera predeterminada
(Proyecto1). Quizá en estos momentos el nombre del proyecto sea irrelevante porque no
hemos tenido que referir de manera lógica un proyecto; no obstante, cuando trabaje con
múltiples proyectos simultáneamente, la forma en que llame a los proyectos para
diferenciarlos en la codificación cobra importancia. Acostúmbrese a asignar a la propiedad
Name el nombre que desee para su proyecto; en este caso, le sugerimos que en lugar de
Proyecto1 le asigne Saludo.
===============================================================



114 Parte 1: Entorno Integrado de Desarrollo

2. En la ficha General, en la lista desplegable Objeto inicial, aparecerán los objetos
(formularios) con los que puede iniciar la ejecución del proyecto.
3. Haga clic en el botón de comando Cancelar.
Depuración y control del programa
La depuración es la actividad que consiste en dejar su aplicación sin errores. Es importante
que sepa depurar sus aplicaciones porque es probable que tenga problemas con el código
alguna vez.
Los errores más comunes en Visual Basic son de semántica, ya que como pudimos ver, los
errores de sintaxis son detectados al momento de escribir el código.
================================================================
Lo inesperado: Los errores más comunes, aplicables a lo que hemos aprendido hasta
ahora, son tres:
• No se encontró método o elemento de datos (error de compilación). Ocurre cuando se
utiliza una propiedad o método en un objeto que no dispone de dicha propiedad o
método. Por ejemplo, si define un objeto basado en el control Label






Capítulo 5: Cómo guardar y ejecutar aplicaciones 115
y utiliza en tiempo de ejecución una propiedad o método no disponible para dicho objeto
(por ejemplo, Text o Value. Este error también sucede cuando comete un error al
escribir el nombre de la propiedad o del método. Soluciones: escriba bien el nombre de la
propiedad o método, utilice una propiedad o método que sea válido.
• Procedimiento Sub o Function no definido (error de compilación). Sucede cuando
escribimos mal una instrucción, de tal forma que Visual Basic piensa que es un
procedimiento definido por usted, mismo que no existe. También sucede cuando usted
hace un llamado a algún procedimiento existente, pero que al escribir el nombre comete
un error. Soluciones: escriba correctamente las instrucciones de Visual Basic, si está
haciendo una llamada a un procedimiento, asegúrese de que antes de ejecutar su
programa, dicho procedimiento ya haya sido creado.
• Se requiere un objeto (error 424 en tiempo de ejecución). Así como se genera un error
cuando se aplica una propiedad o método que no es válido para un determinado objeto,
también se puede cometer un error al escribir el nombre del objeto. En ese caso estaremos
haciendo una llamada a un objeto que no existe y Visual Basic lo requerirá. Este error es
muy frecuente cuando pensamos que definimos un nombre para un objeto y realmente no
lo hicimos; al hacer uso de ese objeto el error aparecerá. Soluciones: escriba
correctamente el nombre del objeto que está mal escrito, revise que el objeto que usted
cree que ya existe no tiene aún el nombre asignado de manera predeterminada por Visual
Basic.
================================================================

Indicadores de margen
Visual Basic proporciona elementos visuales al momento de editar el código que tienen
injerencia en tiempo de ejecución. En la ventana Código aparece un pequeño margen
gris a la izquierda, llamada barra indicadora de margen; en dicha barra pueden aparecer
iconos, llamados indicadores de margen.
Veremos dos de estos indicadores de margen:









116 Parte 1: Entorno Integrado de Desarrollo

>> Despliegue de errores en tiempo de ejecución. [05.06]
A continuación conocerá la forma en que Visual Basic reporta los errores.
1. Cierre la ventana Posición del formulario para liberar espacio en el escritorio de
Windows.
2. En tiempo de diseño, haga doble clic en el botón Mostrar Mensaje para que aparezca la
ventana Código en el procedimiento cmdDespliega_Click.
3. Haga los ajustes necesarios para que los elementos del entorno y su formulario estén
distribuidos como se muestra en la figura 5.6.

4. Modifique el código del procedimiento cmdDespliega_Click; cambie la instruc-
ción Beep por Beeep. Esta situación es la que pasaría si cometiera un error al




Capitulo 5: Cómo guardar y ejecutar aplicaciones 117
teclear alguna instrucción; Visual Basic no reportará error de sintaxis porque desconoce si
posteriormente agregará un procedimiento llamado Beeep.
5. Haga clic en el botón Iniciar o presione la tecla F5 para iniciar la ejecución.
6. Haga clic en el botón Mostrar Mensaje. La aplicación generará un error y su entorno lucirá
como se muestra en la figura 5.7.

7. Haga clic en el botón Aceptar.
La ventana Código al depurar una aplicación
Al momento en que sucede un error, Visual Basic entra en modo de interrupción y traslada el
control a la ventana Código, esperando que usted proceda a corregir el código y reanude la
ejecución o bien, que termine la ejecución.
Como puede ver, en la barra indicadora de margen aparece el icono Call Stack Marker, que
indica que la ejecución está en posesión del procedimiento cmdDespliega_Click.
También puede observar que está seleccionada la línea que causó el error, en este caso
Beeep.





118 Parte 1: Entorno Integrado de Desarrollo

>> Cómo corregir código en modo de interrupción. [05.07]
A continuación aprenderá a corregir código y reanudar la ejecución a partir de donde
se interrumpió.
1. Corrija el código para que en lugar de Beeep diga Beep.
2. Haga clic en el botón Iniciar para reanudar la ejecución.
3. ¿Cómo sabemos que la ejecución se reanudó (es decir, que no se reinició)? Muy sencillo:
si se hubiera reiniciado la ejecución, hubiera sido necesario hacer clic nuevamente en
Mostrar Mensaje para que el mensaje ¡¡¡Bienvenido a Visual Basic!!! se desplegara, y
no lo hizo.
Ejecución paso a paso
Visual Basic permite ejecutar las aplicaciones paso a paso, a efecto de vigilar de manera
particular las tareas que se realizan mediante código, línea tras línea. Esta característica es
especialmente útil cuando quiere saber la secuencia de ejecución que se está siguiendo
entre procedimientos y entre las líneas de los procedimientos.
Para ello es necesario ejecutar la aplicación presionando la tecla F8, o bien seleccionar el
menú Depuración - Paso a paso por instrucciones.







Capítulo 5: Cómo guardar y ejecutar aplicaciones 119
>> Cómo ejecutar un programa línea por línea. [05.08]
A continuación aprenderá a ejecutar un programa paso a paso.
1. Presione la tecla F8. El programa se comenzará a ejecutar paso a paso.
2. Haga clic en el botón Mostrar Mensaje.
3. El icono Call Stack Marker aparecerá en la barra indicadora de margen de la ventana
Código, justo en la línea de inicio del procedimiento cmdDespliega_Click.
4. Presione F8 varias veces y vea qué hace cada una de las líneas que se están ejecutando.
Deje de presionar F8 hasta que ya no se vea el icono Call Stack Marker (una vez que se
ejecutan todas las líneas del procedimiento).
El icono Call Stack Marker no se colocó en la línea de comentario, ¿Por qué?




5. Haga clic en el botón Salir. Presione F8 varias veces, hasta que la aplicación ejecute la
instrucción End y se termine la ejecución.
Puntos de interrupción
Una de las particularidades del modo de interrupción es que se mantienen los valores que la
aplicación guarda hasta el momento.
Suponga que su interfaz pregunta diez cosas que son obligatorias y al capturar la octava
genera error. No será lo mismo corregir en modo de interrupción y reanudar la ejecución
donde se quedó, que iniciarla nuevamente. Si la iniciara nuevamente, tendría que probar
nuevamente su interfaz y capturar todos los elementos que anteceden al que generó el error.
El modo de interrupción es muy útil, pero hasta ahora sólo ha visto que puede entrar a ese
modo si la aplicación genera error o si se hace clic en Interrumpir; en caso de que quiera
entrar en modo de interrupción de manera voluntaria, la segunda opción resulta ser la más
recomendable, pero requiere precisión para poder hacerlo en la línea exacta.
Una forma más práctica es haciendo clic en la barra indicadora de margen, justo al lado de
la línea en que quiera que Visual Basic entre en modo interrupción; hacer esto




120 Parte 1: Entorno Integrado de Desarrollo
agrega un punto de interrupción, mismo que se eliminará haciendo clic en el indicador
de margen Breakpoint.
>> Cómo agregar y eliminar un punto de interrupción. [05.09]
A continuación aprenderá a agregar y eliminar puntos de interrupción en el código.
1. Presione F7 para que aparezca la ventana Código.
2. Busque el procedimiento cmdDespliega_Click.
3. Haga clic en la barra indicadora de margen exactamente al lado de la línea Beep.
4. Se deberá colocar el indicador de margen Breakpoint, y se resaltará toda la línea.
5. Haga clic en el botón Iniciar o presione la tecla F5 para iniciar la ejecución.
6. Haga clic en el botón Mostrar Mensaje. Vea cómo la aplicación se pone en modo de
interrupción al llegar a la línea que posee el Breakpoint. Observe que dos indicadores
de margen pueden coincidir en una misma línea; en este caso los indicadores
Breakpoint y Call Stack Marker se encuentran en la misma línea.
7. Haga clic en el botón Iniciar o presione la tecla F5 para reanudar la ejecución.
8. Haga clic en el botón Salir.
9. Presione F7 para que aparezca la ventana Código.
10. Busque el procedimiento cmdDespliega_Click.
11. Haga clic en la barra indicadora de margen exactamente al lado de la línea Beep. El
indicador de margen debe desaparecer.
Cómo generar un archivo ejecutable (EXE)
Una vez que la aplicación está depurada, tenemos la opción de generar a partir de ella un
programa ejecutable (EXE) que no requiera del entorno de desarrollo de Visual Basic
para ser utilizada.
Usted sabe que un proyecto en Visual Basic puede incluir muchos archivos (.fnn, .vbp,
.vbg, .bas, etcétera). Cuando usted genera un programa ejecutable, todos los elementos
involucrados en su proyecto son conjuntados en el programa ejecutable.








Capítulo 5: Cómo guardar y ejecutar aplicaciones 121
Más aun, Visual Basic contiene en los archivos ejecutables que genera los archivos de
imágenes que son insertados en la aplicación, iconos asociados y otros archivos adjuntos
que no tendrá que distribuir por separado a su programa EXE.
>> Cómo compilar un proyecto para generar un ejecutable en Visual Basic. [05.10]
A continuación aprenderá cómo compilar un proyecto para generar un programa
ejecutable (EXE) en Visual Basic. Aprovecharemos para que usted cambie el icono de la
aplicación.
1. Debe tener abierto el proyecto Saludo.vbp, que se encuentra en \avbp\cap02\.
2. Seleccione el formulario frmMensaje.
3. Localice la propiedad Icon, haga doble clic en ella para que aparezca el cuadro de
diálogo Cargar icono, que permite seleccionar un archivo de icono (.ico o .cur) que
sustituirá el icono estándar que Visual Basic asigna de manera predeterminada.
Seleccione el icono cdrom01.ico que se encuentra en el directorio \avbp\cap05\. El
icono que aparece en la esquina superior izquierda del formulario cambiará.
4. Seleccione en el menú Archivo - Generar Saludo.exe (el nombre del programa variará
dependiendo del nombre de su proyecto). El nombre que coloque será el que asumirá
el programa ejecutable; por lo general. Visual Basic asignará el nombre del proyecto.
No obstante, usted puede cambiar el nombre, sin importar cuál sea el nombre del
proyecto.
5. Asegúrese de que en Nombre de archivo se encuentre Saludo.exe y que quede
almacenado en \avbp\cap05\.






122 Parte 1: Entorno Integrado de Desarrollo
6. Haga clic en el botón Opciones. Aparecerá el cuadro de diálogo Propiedades del
proyecto.



7. Seleccione la casilla de verificación Incremento automático.
¿Qué valores se tienen en número de versión (principal, secundario, revisión)?

8. Haga clic en el botón Aceptar.
9. Haga clic en el botón Aceptar del cuadro de diálogo Generar proyecto. Visual Basic
comenzará a compilar su programa. En la barra de herramientas aparecerá una barra
de progreso, que dirá Compilando... y posteriormente Generando EXE.
10. Seleccione nuevamente Archivo - Generar Saludo.exe, haga clic en el botón
Opciones.
¿Qué valores se tienen en número de versión (principal, secundario, revisión) y
explique qué pasó?




Capitulo 5: Cómo guardar y ejecutar aplicaciones 123



Ya compiló a ejecutable su programa, lo que generó un programa llamado
Saludo.exe, de un tamaño muy pequeño: tan sólo 20 KB.
Un programa por más simple que sea, que pueda ubicarse dentro de la pantalla, que
tenga todos los atributos de un programa de Windows, tales como minimizar, maxi-
mizar, cerrar, movimiento de la ventana, cambio de tamaño de la ventana, sensibili-
dad a eventos, etcétera, no puede ser tan pequeño. El secreto es que el programa
utiliza una biblioteca llamada Msvbvm60.dll, que tiene un tamaño de 1,376 KB y que
debe estar presente en su equipo para que el programa funcione.
Dicha biblioteca se instala junto con Visual Basic, casi siempre en el directorio
\Windows\system; cuando genere los discos de instalación puede seleccionar que la
biblioteca se agregue o no a los discos. El archivo de biblioteca es grande en tamaño,
pero una vez que ya lo tiene en su equipo, podrá ejecutar cualquier programa ejecu-
table creado en Visual Basic, sin necesidad de tener que instalarlo más de una vez.
Saludo.exe ya incluye todos los archivos involucrados en el proyecto, por lo que no
es necesario distribuirlos con su aplicación. Lo único que debe agregar para su apli-
cación ejecutable son otras bibliotecas ActiveX (.ocx), bases de datos (.mdb) u otros
archivos que usted designe para controlar su aplicación (.ini).

============================================================
Nota: Puede distribuir libremente tanto su programa ejecutable como la biblioteca
Msvbvm60.dll, sin incurrir en violaciones a los derechos de autor. Si su proyecto
involucra componentes ActiveX (.ocx) o bibliotecas (.dll) generadas por terceros, cer-
ciórese de que no está distribuyendo componentes sin pagar los derechos corres-
pondientes. En todos los casos, revise la licencia de uso y distribución del producto.
============================================================
Forma esquemática de presentación de aplicaciones
Hasta este punto ya hemos desarrollado una aplicación. Como podrá haberse dado
cuenta, el camino para desarrollar una aplicación simple fue largo, en virtud de que
nos aprovechamos de ella para explicar a detalle los elementos de Visual Basic.






124 Parte 1: Entorno Integrado de Desarrollo
Ahora que ya conoce los elementos del entorno de desarrollo es necesario que las
especificaciones de los programas sean más concretas y prácticas, ya que de otra forma
el libro sería tedioso.
Simplifique la forma en que serán presentadas las especificaciones de las aplicaciones
para que pueda desarrollarlas fácilmente.
Por ejemplo, ya guardo el proyecto con un nombre Saludo.vbp, y éste contiene el
formulario frmMensaje.frm. Si este proyecto, se encontrara en alguna parte del libro
posterior a esta página se describiría mediante las siguientes secciones:
• Implementación visual. Se mostrará en primera instancia lo que se busca realizar,
para ello se colocará el nombre del formulario que se está creando y la forma en que se
deberá ver en tiempo de ejecución.
• Tabla de objetos y propiedades. Contendrá los objetos que el formulario debe
contener; se especifican las propiedades y los valores que deben tener las mismas para
cada objeto. Aquellas propiedades que no se manifiestan deberán ser establecidas de
acuerdo a la representación gráfica del formulario en tiempo de ejecución. Se sugiere
que se ingresen los objetos y propiedades en el orden en que aparecen en esta tabla.
• Propiedades nuevas. Le dará una breve descripción de las propiedades nuevas que
están siendo utilizadas en el formulario. Como éste es el primer programa, todo es
nuevo y por tanto aparecen todas.
• Eventos nuevos. Le dará una breve descripción de los eventos nuevos que están siendo
utilizados en el formulario. Como éste es el primer programa, todo es nuevo y por
tanto aparecen todos.
• Métodos nuevos. Le dará una breve descripción de los métodos nuevos que están
siendo utilizados en el formulario. Como éste es el primer programa, todo es nuevo y
por tanto aparecen todos.
• Codificación. Muestra los procedimientos que hay que agregar en forma de código.
• Ejecución. Muestra la ejecución demostrativa de la aplicación. En esta parte se hacen
observaciones del comportamiento del programa, así como el código que lo origina.
Vea nuestro primer ejemplo en esta modalidad:
frmMensaje.Trm
A continuación aprenderá a agregar objetos en un formulario, establecer sus propiedades
y escribir código de eventos




.
Capítulo 5: Cómo guardar y ejecutar aplicaciones 125
Implementación visual

===============================================================
Nota: En algunos casos, la implementación visual se deberá ilustrar mediante el uso de
varias figuras. En caso de que los colores sean protagonistas en la ejecución del
programa, se hará una breve descripción de lo que se deberá ver en la pantalla, en virtud
de que el manejo de colores es difícil de trasladar al texto impreso.
===============================================================
Tabla de objetos y propiedades de frmMensaje

126 Parte 1: Entorno Integrado de Desarrollo
Propiedades nuevas en frmMensaje

Eventos nuevos en frmMensaje
Codificación de frmMensaje
• Editar código: cmdDespliega, Evento: Clic

‘ Instrucción que emite sonido por el altavoz
Beep
lblTexto.Caption = _
"¡¡¡Bienvenido a Visual Basic!!!"
• Editar código: cmdSalir, Evento: Click.
End





Capítulo 5: Cómo guardar y ejecutar aplicaciones 127
Ejecución
• Haga clic en el botón de comando Mostrar Mensaje.
El procedimiento cmdDespliega_Click emite un sonido y posteriormente modifica la
propiedad Caption del objeto lblTexto a efecto de que adquiera como valor
¡¡¡Bienvenido a Visual Basic!!!; eso se representa visualmente como un mensaje
desplegado.
• Haga clic en el botón de comando Salir.
El procedimiento cmdSalir_Click sólo condene la instrucción End, que da por
terminada la sesión de trabajo.
________________________________________________________________________________
Resumen
En este capítulo:
• Vimos cómo se almacena el trabajo en Visual Basic.
• Vimos algunas extensiones asociadas a los archivos de trabajo en Visual Basic.
• Vimos la jerarquía de contenedores manejada en Visual Basic.
• Vimos sugerencias para nombrar archivos en Visual Basic.
• Vimos la forma en que se puede ejecutar una aplicación en Visual Basic.
• Vimos cómo seleccionar un proyecto como proyecto de inicio, asimismo, vimos cómo
seleccionar un objeto como objeto de inicio.
• Vimos qué son los indicadores de margen y la barra indicadora de margen.
• Vimos el uso y funcionamiento de los indicadores de margen Call Stack Marker y
Breakpoint.
• Vimos cómo ejecutar un programa línea por línea.
• Vimos cómo establecer y remover puntos de interrupción.
• Vimos la forma en que se esquematizarán los programas en el resto del libro.
Es necesario que entienda los conceptos anteriores antes de continuar.






128 Parte 1: Entorno Integrado de Desarrollo
Algunas respuestas a los ejercicios
[05.01] Archivos de trabajo en Visual Basic.
3. Proyecto – Proyecto1. Visual Basic asume que se está trabajando a nivel proyecto.
10. Grupo de proyectos – Grupo1. Visual Basic, por el hecho de estar trabajando con
2 o más proyectos simultáneamente, asume que se desea tener un esquema de grupo de
proyectos.
15. Visual Basic sólo muestra las ventanas Guardar como cuando hay algo pendiente de
guardar que aún tenga el nombre proporcionado de manera predeterminada.
[05.03] Cómo ejecutar e interrumpir su programa.
1. En modo de ejecución.
5. En modo de interrupción.
6. La aplicación no se concluyó porque se encuentra en modo de interrupción;
Visual Basic destina recursos para depuración en dicho modo, de tal forma que no atiende
todos los eventos que están sucediendo en la aplicación.
[05.04] Cómo seleccionar el proyecto inicial.
3. Porque frmMensaje es un objeto perteneciente a un proyecto que no se encuentra
establecido como inicial. Para que se ejecutara sería necesario que Proyecto1 (que
contiene a frmMensaje) fuera el proyecto inicial y que frmMensaje fuera el objeto de
inicio.
[05.08] Cómo ejecutar un programa línea por línea.
4. Porque es un comentario, sin valor para el compilador.
[05.10] Cómo compilar un proyecto para generar un ejecutable en Visual Basic.
7. 1.0.0
10. 1.0.1; el número de versión se actualiza automáticamente cada vez que se genera una
nueva versión del ejecutable.










129

Parte 2
Elementos
de programación
En el ámbito del desarrollo de aplicaciones, el dilema de qué fue
primero, si el huevo o la gallina, no existe. Una verdad irrefutable
es que primero existió la codificación, y luego existieron las
herramientas de desarrollo basadas en objetos, interfaces
gráficas de desarrollo, herramientas CASE, RAD, etcétera.
Incluso las herramientas más gráficas de desarrollo, tenemos
que admitirlo, están codificadas. Es por ello que se consideró
oportuno revisar los elementos de codificación antes que los
elementos gráficos que proporciona el Entorno Integrado de
Desarrollo.
En esta parte se familiarizará con las estructuras de control y
con los operadores aritméticos, lógicos y de comparación.
Aprenderá la sintaxis de las funciones implícitas del lenguaje, el
manejo de procedimientos y las funciones definidas por el
usuario, en fin, el lado BASIC de Visual Basic.
Además, conocer estos elementos de programación, le permitirá
practicar de manera más extensa y profunda el manejo de
objetos y elementos gráficos en la tercera parte.
Desarrollar aplicaciones en Visual Basic sin conocer los ele-
mentos de programación mostrados en esta parte resulta poco
útil, pues con la experiencia llegará a la misma conclusión que
nosotros: los elementos gráficos reducen la codificación, pero el
espíritu de fineza de la aplicación estará siempre en el código, en
aquellas cosas que ya no pueden hacerse mediante utilerías
gráficas.
Capítulos:
6, 7, 8, 9
Número de prácticas: 26





130






















































Capítulo
6
Variables y tipos
de datos
Objetivos
Comprender la forma en que se pueden declarar en Visual Basic las variables de me-
moria, así como la nomenclatura que se les debe dar basándose en su alcance y contenido.
También verá algunas instrucciones que le permitirán realizar pruebas rápidas de
codificación.
Al finalizar este capítulo deberá:
• Saber cómo utilizar MsgBox e InputBox
• Saber cómo declarar variables y constantes en Visual Basic
• Saber cómo definir matrices de una y dos dimensiones
• Conocer los diferentes tipos de datos con que cuenta Visual Basic
• Saber darles un nombre significativo estándar a las variables y constantes
• Manejar las constantes de Visual Basic
• Saber cómo forzar las declaraciones de variables en Visual Basic
• Conocer las funciones de conversión y formato de datos que tiene Visual Basic
131












132 Parte 2: Elementos de programación
A partir de este capítulo comenzará a programar de manera regular y progresiva; con ello
adquirirá la destreza necesaria para desarrollar aplicaciones profesionales en Visual Basic.
Si entendió los fundamentos tratados en la parte I, la tarea será fácil.
Usted puede comenzar a desarrollar en Visual Basic, y ser hábil en el manejo de la interfaz
y rápido para implementar visualmente las aplicaciones que desea; no obstante, de nada le
servirá diseñar una pantalla bonita si carece de sentido, es decir, si no hace nada.
Antes de dominar todos los objetos que puede manejar en Visual Basic, son necesarios
algunos elementos de codificación que le permitan darle sentido a las cosas a través de una
funcionalidad que resulte explicativa. Al menos en este capítulo, olvídese de que existen
los objetos y los controles en Visual Basic: trabajará prácticamente en el terreno del código
puro (lo que algunos llaman hardcore code), donde no importa lo bonito sino lo eficiente.
MsgBox
La función MsgBox le permite indicar la aparición de una ventana de notificación en Vi-
sual Basic, también llamadas cuadros de diálogo, en el formato estándar de Windows.
La sintaxis de la función es la siguiente:
MsgBox ( Mensaje [ , CódigoDeBotón [ , TítuloDeVentana] ] )
Los elementos de la sintaxis son los siguientes:
El Mensaje es un argumento requerido. Consiste en una expresión String (texto) que
representa el mensaje que aparecerá en el cuadro de diálogo. La longitud máxima de
mensaje es de aproximadamente 1024 caracteres, según el ancho de los caracteres
utilizados. Si el mensaje consta de más de una línea, puede separarlas utilizando un
Character de retorno de carro (Chr(13)), un Character de avance de línea (Chr(10))
o una combinación de caracteres de retorno de carro/avance de línea (Chr(l3) y
Chr(10)) entre cada línea y la siguiente.

=================================================================
Nota: Posteriormente verá que Visual Basic le asiste en el uso de valores constantes;
Chr(l3) + Chr(10) es igual a vbCrL-f.
=================================================================
El CódigoDeBotón es un argumento opcional. Consiste en una expresión numérica que
corresponde a la suma de los valores que especifican el número y el tipo de los





Capítulo 6: Variables y tipos de datos 133
botones que se pretenden mostrar, el estilo de icono que se va a utilizar, la identidad del
botón predeterminado y la modalidad del cuadro de mensajes. Si se omite este
argumento, el valor predeterminado para CódigoDeBotón es 0.
El TítuloDeVentana es opcional. Consiste en una expresión String que se muestra en
la barra de título del cuadro de diálogo. Si se omite TítuloDeVentana, en la barra de
título se coloca el nombre de la aplicación.
Dependiendo de la función que MsgBox desempeñe, devolverá o no valores. En el caso
del ejemplo, sólo despliega un mensaje y como su única función es informar, aparecerá
sólo el botón Aceptar (código de botón 0), con el mensaje.
A continuación pruebe MsgBox a través de un formulario que no será necesario guardar,
ya que lo importante es ver qué hace el código. Para ello utilizara el procedimiento
Form_Activate, que se ejecuta al momento en que el formulario está activo y
visible.

==============================================================
Nota: No se requiere guardar todos los ejemplos que se desarrollan en el libro, no
obstante, si desea guardar sus trabajos para revisiones posteriores, le recomendamos
que lo haga en el directorio de prácticas correspondiente (en este caso \avbp\cap06).
Cuando el libro indique que genere un nuevo proyecto EXE estándar, implica crear un
nuevo proyecto y trabajar única y exclusivamente con ese proyecto. Si trabaja con dos o
más proyectos simultáneamente, puede confundirse, ya que Visual Basic asume que
está trabajando en modo de grupo de proyectos y tendrá que especificar continuamente
el proyecto y el formulario de inicio, perdiendo tiempo sin ningún aprendizaje que
valga la pena.
==============================================================
>> MsgBox: creación de cuadros de información y confirmación de manera rápida.
[06.01]
A continuación aprenderá a utilizar MsgBox y a comprobar código sin necesidad de
agregar objetos en un formulario.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).

• Editar código: Form, Evento: Activate.
MsgBox ("Operación concluida satisfactoriamente")
MsgBox ("Esto " & Chr(13) & Chr(10) & " está genial")
Print MsgBox("Desea borrar el archivo", 1)
Print MsgBox("Desea borrar el archivo", 1, "Confirmación")







134 Parte 2: Elementos de programación

2. Ejecute el formulario todas las veces que requiera para contestar las preguntas que se
presentan a continuación.
3. En su opinión, el primer MsgBox para qué sirvió:



4. Cuál es la diferencia entre los resultados obtenidos entre el último y el penúltimo
MsgBox.




5. La instrucción Print sirve para enviar a una salida (en nuestro caso al formulario)
un determinado contenido. En nuestro ejemplo realizamos un Print que envía al
formulario lo devuelto por MsgBox; ¿qué devuelve si selecciona Aceptar y qué
devuelve si selecciona Cancelar?



6. Elimine la instrucción Print de cualquiera de los últimos ejemplos. Ejecute el
formulario. Causa un error. ¿Por qué? ¿Por qué en los primeros dos ejemplos, que
no tienen Print, no causa error?

















Capítulo 6: Variables y tipos de datos 135
Constantes de Visual Basic
Cuando citamos la sintaxis de MsgBox, en el tercer ejemplo colocamos lo siguiente:

MsgBox("Desea borrar el archivo", 1)
¿Qué le dice ese número 1? Si reemplazáramos el número 1 por un 32, un 64 o un 256,
¿sabría lo que significa?
Si en el segundo argumento de la función MsgBox (CódigoDeBotón / Número de códi-
go) no coloca ningún número. Visual Basic asume que es un valor de O, lo que indica que
usted desea que en el cuadro de diálogo sólo aparezca un botón Aceptar, que al hacer clic
cierre el cuadro de diálogo. En este caso, la función MsgBox tiene un objetivo
eminentemente informativo y no devuelve valores.
Si coloca el número 1, Visual Basic interpreta que usted desea que en el cuadro de
diálogo aparezcan dos botones: Aceptar y Cancelar. Ahora dispone de dos opciones y
por tanto puede decidirse por alguna de ellas con un propósito definido. En este caso,
MsgBox devuelve un valor, dependiendo del botón en el que haya hecho clic. Si hace
clic en el botón Aceptar, devolverá el valor 1; si hace clic en el botón Cancelar,
devolverá el valor 2.
Considere que dispone de 16 diferentes estilos de cuadros de diálogo y como respuesta
MsgBox puede devolver 7 diferentes respuestas. Por supuesto que creemos que usted
tiene la suficiente memoria como para aprender qué significan 16 números co-
rrespondientes a CódigoDeBotón y los 7 números correspondientes a los valores
devueltos, sin embargo, quizá no todos los que lean sus programas tengan esa misma
capacidad.
Para simplificar la programación y hacer más legibles los programas, existen las cons-
tantes de Visual Basic, con las cuales se puede hacer referencia al significado de un valor
y no al valor mismo; pasamos de algo muy abstracto como lo es un número de código, a
un nombre equivalente, comprensible en su propia lectura.
Si el número de código 0, para efecto de la función MsgBox, equivale en Visual Basic
(vb) a ver el botón Aceptar (OK) solamente (Only), ¿qué nombre le daría a ese 0 para
identificarlo de manera significativa? Qué le parece la siguiente propuesta:
0 vbOKOnly





136 Parte 2: Elementos de programación
Y si el número de código 1 equivale en Visual Basic (vb) a ver el botón Aceptar (OK) y
Cancelar (Cancel), ¿qué nombre le daría a ese uno para identificarlo de manera sig-
nificativa? Qué le parece lo siguiente:
1 vbOKCancel
Si en lugar de escribir 0 escribiera vbOKOnly, o bien, si en lugar de 1 escribiera la
palabra vbOKCancel, sin duda alguna obtendría un código más claro para usted y
para los demás que lean su programa.
En MsgBox, los números de código además de determinar el comportamiento del cua-
dro de diálogo y la cantidad de botones que han de mostrarse, determinan la apariencia
que identifica el propósito del cuadro de diálogo; para ello basta hacer la suma de los
diferentes valores, por ejemplo:
MsgBox("Desea borrar el archivo", 1 + 48)

Le indican a Visual Basic que deben aparecer dos botones. Aceptar y Cancelar (nú-
mero de código 1) y que además debe aparecer como icono del cuadro de diálogo la
figura de advertencia estándar de Windows (número de código 48).
Sin la existencia de constantes de Visual Basic, el código sería muy oscuro. Vea cómo
luce el código utilizando constantes de Visual Basic:

MsgBox("Desea borrar el archivo", vbOKCancel + vbExclamation)
A continuación se muestra una lista de las constantes de Visual Basic que se aplican a
MsgBox, para efecto de mostrar el cuadro de diálogo.

==============================================================
Nota: Las constantes son de Visual Basic, no de MsgBox; por tal motivo, se encontrará
estas mismas constantes en otros elementos de programación, con la misma fun-
cionalidad.
==============================================================





Capítulo 6: Variables y tipos de datos 137




El primer grupo de valores (O a 5) describe el número y el tipo de los botones mos-
trados en el cuadro de diálogo; el segundo grupo (16, 32, 48, 64) describe el estilo del
icono, el tercer grupo (O, 256, 512) determina el botón predeterminado y el cuarto
grupo (0,4096) determina la modalidad del cuadro de mensajes. Cuando se suman nú-
meros para obtener el valor final del argumento CódigoDeBotón, se utiliza solamente
un número de cada grupo.
A continuación se muestra una lista de las constantes de Visual Basic que se aplican a
MsgBox como valores devueltos.



138 Parte 2: Elementos de programación



Utilizar constantes de Visual Basic es una de las tantas formas que la herramienta de
desarrollo proporciona para asistirle en la programación, al mismo tiempo que estandariza
la forma de trabajo.
>> Uso de constantes de Visual Basic. [06.02]
A continuación aprenderá a seleccionar las constantes de Visual Basic para los cuadros de
diálogo que necesite.
1. En la parte de la derecha escriba el código MsgBox que utilizaría para generar lo que se
solicita; no olvide utilizar las constantes de Visual Basic. Deberá obtener lo siguiente:








Capítulo 6: Variables y tipos de datos 139

InputBox
La función InputBox sirve para desplegar un cuadro de diálogo que permite ingresar
datos.
Devuelve un valor String, correspondiente a lo que se capturó; el valor puede aceptarse
(Aceptar), o en su caso, también se puede Cancelar la captura. En caso de que se dé
Cancelar a la captura, InputBox devolverá un valor String vacío ("").
La sintaxis de la función es la siguiente:
InputBox ( Mensaje [ ,Título [ , Predeterminado [ ,PosX ( ,PosY] ] ] ] )
Los elementos de la sintaxis son los siguientes:
El argumento Mensaje es requerido. Consiste en una expresión String (texto) que
representa el mensaje que aparecerá en el cuadro de diálogo. La longitud máxima de







140 Parte 2: Elementos de programación
mensaje es de aproximadamente 1024 caracteres, según el ancho de los caracteres uti-
lizados. Si el mensaje consta de más de una línea, puede separarlos utilizando un
Character de retomo de carro (Chr(13)) o un Character de avance de línea
((Chr(10)) o una combinación de caracteres de retomo de carro/avance de línea
(Chr(l3) y Chr (10)) entre cada línea.
El argumento Título es opcional. Consiste en una expresión String que se muestra en
la barra de título del cuadro de diálogo. Si se omite Título, en la barra de título se coloca
el nombre de la aplicación.
El argumento Predeterminado es opcional. Consiste en el valor sugerido que aparecerá
al inicio en el cuadro de diálogo.
El argumento PosX es opcional. Consiste en especificar la posición horizontal donde
debe desplegarse el cuadro de diálogo (eje de las X).
El argumento PosY también es opcional. Consiste en especificar la posición vertical
donde debe desplegarse el cuadro de diálogo (eje de las Y).
>> InputBox: acceso rápido de datos. [06.03]
A continuación aprenderá a utilizar InputBox, a declarar variables de memoria para
utilizarse en los programas y a colocar comentarios en las líneas sin afectar la ejecución.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
• Editar código: Form, Evento: Activate. I
' Define una variable de tipo String para utilizarla
' en el programa
Dim mstrSoftware As String ' Definición de la variable
' Usos de InputBox
mstrSoftware$ = InputBox("¿Cuál es su software preferido?")
Print "Captura: " & mstrSoftware$



Capítulo 6: Variables y tipos de datos 141
mstrSoftware$ = InputBox("¿Cuál es su software preferido?", _
"Preferencias")
Print "Captura: " & mstrSoftware$
mstrSoftware$ = InputBox("¿Cuál es su software preferido?", _
"Preferencias", "Visual Basic")
Print "Captura: " & mstrSoftware$

mstrSoftware$ = InputBox("¿Cuál es su software preferido?", _
"Preferencias", "Visual Basic", 2000, 4000)
Print "Captura: " & mstrSoftware$
2. Ejecute el formulario todas las veces que requiera para contestar las preguntas que a continuación se
presentan.
3. ¿Cuál es la diferencia entre el primer ejemplo y el segundo?, ¿qué aparece como título del cuadro de
diálogo si no especifica algún título para él?



4. ¿Cuál es la diferencia entre el tercer ejemplo y el cuarto?



5. ¿Qué valor devuelve la función InputBox en caso de hacer clic en el botón Cancelar?












142 Parte 2: Elementos de programación
6. Al declarar la variable, después de la instrucción "Dim mstrSoftware As
String" se colocó un comentario (' Definición de la variable). ¿Afecta
la ejecución del programa, sí o no, por qué?




Declaración de variables
En la explicación de InputBox requerimos declarar una variable que nos permitiera
almacenar de manera temporal un dato en la memoria RAM. En la programación eso
es el pan de cada día, en virtud de que la secuencia lógica no permite desarrollar un
proceso en una sola línea; es necesario procesar algo y mantener los resultados del
proceso en alguna parte para su uso posterior.
Las variables o constantes de memoria son posiciones de memoria RAM, referidas a
través de un nombre, disponibles para almacenar datos en ellas . Las variables tienen
tres atributos esenciales: nombre, tipo y alcance.
• Nombre. Permite identificar el contenido de la memoria; deberá estar compuesto
como sigue: debe comenzar con una letra, puede tener un máximo de 40 caracteres,
puede incluir números y guiones bajos (_), pero no signos de puntuación ni espacios
en blanco. Una variable no puede tener el mismo nombre que otro objeto público
como Clipboard, Screen o App. Los nombres de variable pueden repetirse en
múltiples procedimientos y módulos, cuidando siempre el alcance.
• Tipo de datos. Determina cómo se almacenan los bits que representan los valores
en la memoria del equipo. Cuando declara una variable, puede proporcionarle un
tipo de datos; todas las variables desde su creación tienen un tipo de datos que
determina la clase que pueden almacenar, por lo cual una variable nunca carece de
un tipo de datos. De forma predeterminada, si no proporciona un tipo de datos al
momento de declarar una variable, ésta toma el tipo de datos Variant, que permite
almacenar cualquier tipo de contenido soportado por Visual Basic.
• Alcance. Determina la validez del uso de una variable entre procedimientos,
módulos y aplicaciones. Pueden ser de nivel procedimiento (sólo válidas para un
procedimiento), a nivel módulo (válidas para todos los procedimientos de un mó-
dulo, como podría ser un formulario) o globales (válidos para todos los procedi-
mientos de todos los módulos de todas las aplicaciones).





Capítulo 6: Variables y tipos de datos 143

==============================================================
Nota: Optamos por no traducir la palabra "Character" al español; lo correcto seria
escribir "Carácter", lo cual tiene un significado muy diferente. Colocar "símbolo" o
"literal" tampoco satisface la semántica que se persigue. Podríamos decir que Character
es una representación simbólica, de una posición de longitud.
=============================================================
El tipo de datos de las variables determina dos cosas: el consumo en bytes de memoria y el
Character de declaración de tipo. Este último es un Character que permite identificar y
declarar a una variable como perteneciente a algún tipo de datos específico; no todos los
tipos de datos tienen Character de declaración de tipo. Por citar un ejemplo, aquellos datos
que sean de tipo String (texto) podrán ser identificados por el Character de moneda "$",
de tal manera que si vemos una variable de nombre MiVaríable$, podremos saber que
se trata de una variable de tipo String.
El tipo de datos Variant puede almacenar cualquier cosa, por lo cual parecería práctico
utilizar sólo ese tipo de datos; sin embargo, es el de más consumo de memoria RAM, por lo
que su uso no se recomienda más que para inexpertos. Si sabe que una variable almacenará
siempre un tipo de datos determinado. Visual Basic tratará de forma más eficiente los datos
si declara la variable con el tipo que le corresponda. Antes de declarar una variable piense
en las siguientes preguntas:
• ¿Qué almacenará la variable? Esto es fundamental para poner el nombre a las
variables, ya que éstas deben ser representativas de su contenido, su tipo de datos y su
alcance. Los nombres de variable deben respetar las convenciones de Visual Basic, por
lo que le sugerimos que revise el apéndice I: Convenciones.
• ¿Qué tipo de datos almacenará la variable? Dependiendo de qué desea almacenar,
seleccione el tipo de datos adecuado, que consuma el mínimo suficiente y necesario de
memoria RAM; más adelante se mostrará qué puede contener cada tipo de datos.
• ¿En dónde será utilizada la variable? Se debe conocer en qué partes del código se
utilizará una variable, a efecto de determinar qué alcance se le debe proporcionar al
momento de la declaración. Como regla general, debe declarar las variables con el
mínimo de alcance.

Tipos de datos
Los tipos de datos básicos de Visual Basic permiten el manejo de prácticamente cualquier
cosa. Es muy común utilizar aplicaciones en Visual Basic como aplicaciones front-end de
bases de datos robustas como SQL Server y Oracle.
En Visual Basic se pueden manejar los siguientes tipos de datos:





144 Parte 2: Elementos de programación









Capítuio 6: Variables y tipos de datos 145


DIM: declaración de variables de memoria
Como quizá ya se haya dado cuenta en la tabla de tipos de datos y en ejemplos anteriores,
la declaración de variables de memoria se hace a través de la instrucción Dim.
La sintaxis de la instrucción es la siguiente:
Dim NombreVariable { CharacterDeclaración | As TipoDatos }
NombreVariable es el nombre que desea asignarle a su variable. CharacterDeclaración es
el Character de declaración del tipo de datos, en caso de que lo tenga. TipoDatos es
cualquier nombre de tipo de datos reconocido por Visual Basic.
En la sintaxis se ilustran dos posibilidades de declaración de variables, que son mu-
tuamente excluyentes: una es utilizando el Character de declaración de tipo (decla-














146 Parte 2: Elementos de programación
ración implícita) o utilizando un nombre de tipo de datos reconocido por Visual Basic
(declaración explícita).
En la tabla de tipos de datos hay una columna llamada "Character de declaración de
tipo", que muestra los caracteres asociados a los diferentes tipos de datos para la
declaración implícita. Como verá, no todos los tipos de datos tienen Character de de-
claración de tipo, y por tanto, no pueden ser declarados de manera implícita.
Para declarar una variable que almacene el número de asistentes a una conferencia en un
recinto relativamente grande, tendríamos las siguientes posibilidades:
Declaración explícita:

Dim intAsistentes As Integer
Declaración implícita:
Dim intAsistentes%

============================================================
Lo inesperado: Cuando trabaja con declaración de variables, los errores más
comunes son los siguientes:
• Se esperaba el fin de la instrucción (error de compilación). Sucede cuando hace una
doble declaración, es decir, intenta una declaración implícita y explícita al mismo
tiempo, por ejemplo Dim intAsistentes% As Integer. Al momento en que la
instrucción Dim se encuentra un Character de declaración de tipo, asume la
declaración implícita y no espera nada más. Soluciones: decídase, o coloca el
Character de declaración de tipo o el As TipoDatos, pero no ambas.
• Desbordamiento (error 6 en tiempo de ejecución). Sucede cuando trata de almacenar
un valor que excede los límites que permite un determinado tipo de datos, por
ejemplo, un valor sobre 32, 767, en el caso de datos de tipo Integer. Esto se
presenta particularmente cuando no tiene claro el dominio de los datos o bien ela-
bora cálculos y no se percata de que puede exceder el límite: una suma de datos
Integer (por ejemplo, 20,000 + 40,000) no siempre da un tipo de datos Integer
(60,000). Soluciones: revise bien los tipos de datos que utiliza, determine el dominio
de los datos (conjunto de valores válidos para un dato) y defina las variables en
consecuencia. Si no está seguro de los valores, asigne un tipo de datos con capacidad
sobrada.
============================================================





Capítulo 6: Variables y tipos de datos 147
Es una convención de programación de Visual Basic que si las variables de un tipo de
datos que disponga de Character de declaración de tipo, muestren este último durante
todo el desarrollo del programa.

============================================================
Lo inesperado: Cuando trabaja con Characteres de declaración de tipo, los errores
más comunes son:
• El Character de declaración de tipo no coincide con el tipo de datos declarado (error
de compilación). Sucede cuando declara una variable de un determinado tipo de datos,
con su correspondiente Character de declaración de tipo, pero al hacer referencia a
dicho tipo de datos en alguna parte del programa, le coloca un Character de declaración
de tipo que no le corresponde. Por ejemplo: define intAsistentes como Integer,
pero en el código utiliza una referencia intAsistentes&, que es equivocada, ya
que el Character & corresponde al tipo de datos Long. Soluciones:
memorice los Characteres de declaración de tipo y utilícelos adecuadamente.
• El Character no es válido (error de compilación). Sucede cuando deja un espacio
entre el nombre de la variable y el Character de declaración de tipo. Soluciones: no deje
espacios en blanco entre el nombre de la variable y el Character de declaración de tipo.
============================================================

Alcance
El alcance determina la validez del uso de una variable entre procedimientos, módulos y
aplicaciones. Los diferentes alcances que puede tener una variable en Visual Basic son
los siguientes:








148 Parte 2: Elementos de programación Nombre
El nombre debe ser claramente representativo de lo que almacena y además debe incluir
como prefijo los aplicables al alcance y tipo de datos que se pretende almacenar. Suponga
que en una aplicación dada, en un formulario dado, desea utilizar una variable que
almacene las ventas acumuladas de un mes, misma que pueda ser utilizada por cualquier
procedimiento dentro del mismo módulo, ¿cómo se debería llamar la variable? La figura
6.1 nos resuelve esa incógnita:

>> Determinación del nombre, tipo de datos y alcance indicado para las variables de
memoria. [06.04]
Con respecto a las variables de memoria, aprenderá a determinar cuál es el tipo de datos
adecuado para una necesidad de almacenamiento y de alcance, así como darle nombre a las
variables respetando las convenciones internacionales sugeridas por Microsoft para la
codificación en Visual Basic. Conteste según el ejemplo.
1. Declare una variable que almacene el tipo de cambio peso-dólar, que pueda ser
utilizada en cualquier parte de una aplicación de instrumentos de inversión.

2. Se requiere crear un efecto visual en un procedimiento, consistente en manipulación
aleatoria de colores; en Visual Basic los colores RGB se representan a través









Capítulo 6: Variables y tipos de datos 149
de números de color de O a 255. La variable sólo se utilizará para manejar colores
RGB en ese procedimiento.



3. En un formulario se realiza manejo de bases de datos; cuando se hace una búsqueda
secuencial, es importante saber si la búsqueda a partir de un criterio encontró (True) o
no (False) registros que coincidan con el patrón buscado, a efecto de determinar si un
informe se envía o no a impresión. Se requiere una variable que indique si se
encontraron o no registros de acuerdo al patrón de búsqueda seleccionado.



4. Al iniciar una aplicación, el usuario escribe su nombre de usuario y su contraseña como
medida de seguridad; una vez que la aplicación le permite el acceso, en cada uno de los
formularios que componen la aplicación, internamente se evalúa qué usuario fue el que
ingresó a la aplicación, a efecto de determinar cuáles son los privilegios de uso que
tiene. Se requiere una variable que guarde el nombre de usuario, que pueda utilizarse en
todos los formularios de la aplicación.





150 Parte 2: Elementos de programación
Constantes
Las constantes, como su nombre lo indica, son referencias de valores en memoria que
no pueden variar su valor.
La sintaxis para declarar constantes es:
Const Variable [As TipoDeDatos] = ValorConstante
Ejemplo:
Const msngPI As Single = 3.1416
Const msngPI! = 3.1416
La especificación del tipo de datos es opcional, aunque se recomienda no omitirla. Las
constantes deben declararse a nivel módulo, es decir, se colocan en las declaraciones
generales de un formulario, o bien en un archivo .bas.
Matrices
Las matrices son parte de todo lenguaje de programación de propósito general; per-
miten la organización, a través de subíndices, de un conjunto de valores, bajo un
mismo nombre de referencia en memoria (nombre de variable).
Ya vimos que la instrucción Dim sirve para declarar variables:
La sintaxis de la instrucción es:
Dim Variable As TipoDeDatos
Por ejemplo, para declarar una variable que almacene las ventas netas de un producto
en el mes de enero (el mes 1 del año), sería como se muestra a continuación:
Dim curVentas1 As Currency

Capitulo 6: Variables y tipos de datos 151
Por otro lado, si queremos almacenar el mismo dato para el primer semestre del año, tal
vez sería conveniente lo que se muestra a continuación:
Dim curVentas1 As Currency
Dim curVentas2 As Currency
Dim curVentas3 As Currency
Dim curVentas4 As Currency
Dim curVentas5 As Currency
Dim curVentas6 As Currency
Lo que implica 6 posiciones en memoria, referenciadas por 6 identificadores o nombres
de variables. Como sabemos. Visual Basic tiene un número limitado de identificadores
posibles para una aplicación y aunque ciertamente estamos muy lejos de agotar el límite
máximo, estamos contribuyendo a reducir los identificadores disponibles. Además, entre
más nombres de variables diferentes utilicemos, más trabajo le costará a Visual Basic (y a
usted) mantener siempre presente de qué se trata cada uno de ellos.
Debido a que cada una de las variables contendrá información de la misma naturaleza, en
cierta forma relacionada, ¿no se podría reducir a uno el número de identificadores
utilizados?
La respuesta es sí, a través de las matrices. La sintaxis de la instrucción para definir
matrices es:
Dim Variable(NúmeroDeSubíndices) As TipoDeDatos
Una matriz es un conjunto de posiciones de memoria (dimensión) que almacenan datos de
una misma naturaleza (elementos), mismos que pueden ser referenciados a través de un
número consecutivo de posición (subíndice), que se encuentra entre un número mínimo y
un número máximo (intervalo). Por ejemplo, para definir una matriz que sustituya a las
seis variables del ejemplo anterior, podríamos hacer lo siguiente:
Dim curVentas(5) As Currency
Se preguntará por qué se definió como número de subíndice el 5 y no el 6, ya que se trata
de representar el equivalente a 6 variables; la respuesta es que Visual Basic siempre
considera el inicio de los subíndices a partir del cero, de tal forma que se tendría en
memoria realmente lo siguiente:








152 Parte 2: Elementos de programación
curVentas@(0)
curVentas@(1)
curVentas@(2)
curVentas@(3)
curVentas@(4)
curVentas@(5)
Es decir, 6 posiciones. En resumen: esto es una matriz llamada curVentas, tiene una
sola dimensión, almacena 6 elementos y el intervalo de sus subíndices va de 0 a 5.
Si regresamos a la idea original, quizá resulte extraño que curVentas(0) almacene las
ventas del mes 1, que curVentas(1) almacene las ventas del mes 2, y así
sucesivamente; no resulta natural. Para omitir el comportamiento predeterminado de
Visual Basic, puede indicar de manera explícita qué números de subíndices desea, por
ejemplo:
Dim curVentas(1 to 6) As Currency
Equivale a:
curVentas@(1)
curVentas@(2)
curVentas@(3)
curVentas@(4)
curVentas@(5)
curVentas©(6)
Con lo que tendría una representación natural, acorde a lo que quiere.
Las matrices pueden ser de 2 y 3 dimensiones, es decir, incluir doble o triple subíndice. Suponga
que ya no le basta saber cuánto se vendió en cada uno de los primeros 6 meses: desea saber
cuánto se vendió en cada uno de los meses del segundo semestre del año (meses del 7 al 12) y
además desea conocer de manera específica cuánto se vendió de cada uno de los tres productos
que maneja la compañía (productos A, B y C).
Una solución podría ser la siguiente:
Dim curVentas(7 to 12, 1 to 3) As Currency






Capítulo 6: Variables y tipos de datos 153
Las posiciones de memoria se distribuirían de la siguiente manera:

La primera dimensión tiene 6 elementos, con subíndices en un intervalo de 7 a 12 y la segunda
dimensión tiene 3 elementos, con subíndices en un intervalo de 1 a 3.
Fundones de límite de posiciones
El hecho de que Visual Basic permita determinar de manera específica el intervalo en el que se
encontrarán los subíndices de las matrices es una ventaja, pero también es una nueva preocupación,
ya que si usted hace referencia a un subíndice que no existe, Visual Basic generará error.
En el ejemplo anterior, invocar la variable curVentas(1,1) generaría error, ya que no existe un
subíndice 1 para la primera dimensión de la matriz.
=============================================================
Lo inesperado: Los errores más comunes cuando trabaja con matrices son los siguientes:
• El subíndice está fuera del intervalo (error 9 en tiempo de ejecución). Se hace referencia a un
subíndice que no se encuentra en el intervalo de una dimensión. Soluciones: determine
claramente los límites del intervalo de subíndices para una dimensión dada; también verifique que
no está haciendo referencia a una dimensión en lugar de otra. No es lo mismo
curVentas(7,2) que curVentas(2,7).
• No se puede asignar a una matriz, (error de compilación). Es común que olvide que una variable
se trata de una matriz y que pretenda asignarle un valor directamente, sin especificar el subíndice
correspondiente. En nuestro ejemplo, colocar la asignación curVentas = 20000. generaría
un error. Soluciones: una vez que defina una matriz, no olvide especificar los subíndices, ya que
de lo contrario, Visual Basic no sabrá a qué elemento de la matriz se está refiriendo.
• El número de dimensiones es incorrecto (error de compilación). Se presenta cuando el número de
subíndices proporcionados no corresponde al número de dimensiones de la matriz. Soluciones:
verifique el número de subíndices que requiere proporcionar, basado en el número de
dimensiones que tiene definidas. Up error clásico es que al definir la matriz sustituyamos la
declaración To por una





154 Parte 2: Elementos de programación
coma (1 To 3 < > 1,3), lo que genera un número equivocado de dimensiones;
esta confusión sucede porque en casi todas las funciones la separación de argumentos se da
utilizando la coma y es inusual colocar To entre paréntesis.
=============================================================
Para resolver el desconocimiento de los límites mínimos y máximos de un subíndice dentro de un
intervalo, están las funciones Lbound () y Ubound().
La sintaxis de las funciones es la siguiente:
Lbound ( NombreMatriz. [, Dimensión])
Lbound ( NombreMatriz. [, Dimensión])
Donde NombreMatriz es el nombre de la matriz que desea explorar. Dimensión es el número de
dimensión (contando de izquierda a derecha con respecto a la declaración) que desea evaluar.
>> Uso de matrices y determinación de límites mínimos y máximos del intervalo de
subíndices. [06.05]
A continuación definirá matrices en Visual Basic y determinará los valores mínimos y máximos del
intervalo de subíndices. Imagine que desea almacenar los nombres de los alumnos que obtuvieron
las 2 mejores calificaciones en los primeros 3 exámenes de inglés que han sido aplicados en una
escuela determinada.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
• Editar código: Form, Evento: Activate.

Dim strAlumno(1 To 2, 1 To 3) As String

strAlumno$(1, 1) = InputBox("1er lugar en el primer examen:")
strAlumno$(1, 2) = InputBox("1er lugar en el segundo examen:")
strAlumno$(1, 3) = InputBox("1er lugar en el tercer examen:")
strAlumno$(2, 1) = InputBox("2o lugar en el primer examen:")
strAlumno$(2, 2) = InputBox("2o lugar en el segundo examen:")
strAlumno$(2, 3) = InputBox("2o lugar en el tercer examen:")

Print "Reconocimientos por examen"
Print "Primer examen"
Print "1.-"; strAlumno$(1, 1)
Print "2.-"; strAlumno$(2, 1)





















Capítulo 6: Variables y tipos de datos 155

Print "Segundo examen"
Print "1.-"; strAlumno$(1, 2)
Print "2.-"; strAlumno$(2, 2)
Print "Tercer examen"
Print "1.-"; strAlumno$(1, 3)
Print "2.-"; strAlumno$(2, 3)

Print "Inicio intervalo, dimensión 1: "; LBound(strAlumno$, 1)
Print "Fin intervalo, dimensión 1: "; UBound(strAlumno$, 1)

Print "Inicio intervalo, dimensión 2: "; LBound(strAlumno$, 2)
Print "Fin intervalo, dimensión 2: "; UBound(strAlumno$, 2)

MsgBox "Fin del programa"
End
2. Ejecute el programa.

Option Explicit
Visual Basic reconoce las variables que son utilizadas en el código aun cuando no las haya
declarado de manera explícita. Para los principiantes esto resulta muy práctico, ya que si olvidan
declarar una variable, su programa no marcará error. Si no declaramos una variable. Visual Basic lo
hace por nosotros.
Como podrá imaginar, tanta belleza no es posible. ¿Alguien le dijo a Visual Basic de qué tipo de
datos debe ser una variable que olvidamos declarar? La respuesta a esa pregunta es no, y por lo
tanto declara la variable de tipo variant, que es la que más memoria consume. En Visual Basic
los errores más temibles son de semántica y no de sintaxis. Probablemente Visual Basic trate de
solucionarle un problema de sintaxis cambiando el resultado de sus programas; en procesos grandes
y complejos, puede perder horas tratando de buscar un error de semántica cuando el error es de
sintaxis.
Para evitar esto. Visual Basic cuenta con una instrucción, llamada Option Explicit, que
determina que todas las variables utilizadas en los programas deberán ser declaradas de manera
explícita antes de ser utilizadas.
>> Declaración automática de variables en Visual Basic. [06.06]
A continuación conocerá la manera en que Visual Basic declara variables por usted y los problemas
que eso le puede ocasionar.


















156 Parte 2: Elementos de programación
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
2. A través del menú Herramientas - Opciones... - Editor, revise que la opción Requerir
declaración de variables esté desactivada.
• Editar código: Form, Evento: Activate.
intUnidadesVendidas% = 5
intPrecioUnitaric% = 100
3. Ejecute el programa. Vea que el programa no genera error.
• Continuar editando código: Form, Evento: Activate.

intTotal% = intUnidadesVendidas% * inttPrecioUnitario%
print intTotal%

4. Vea cómo en el punto 3 se le indicó que tecleara el nombre de la variable
intPrecioUnitario con doble "T", siendo que en el punto 2 se había especificado
un valor de 100 a una variable que no contiene doble "T". El clásico error del "dedo
veloz". Ejecute el programa.
5. Si hubiera cometido este error en la realidad, en un programa de 100 o más líneas, se
preguntaría, ¿por qué me dio O si debió haber arrojado 500? Buscar la solución sería
muy cansado e improductivo.
>> Uso de Option Explicit (requerir la declaración de variables de manera explícita).
[06.07]
A continuación utilizará Option Explicit para evitar el uso de variables no decla-
radas.
1. Hasta el momento, su código en el procedimiento Form_Activate() luce como
sigue:
intUnidadesVendidas% = 5
intPrecioUnitario% = 100
intTotal% = intUnidadesVendidas%, * inttPrecioUnitario%
print intTotal%





Capítulo 6: Variables y tipos de datos 157
• Modificar código: Form, Evento: Actívate.
Private Sub Form_Activate( )
Dim intUnidadesVendidas As Integer
Dim intPrecioUnitario As Integer
Dim intTotal As Integer
intUnidadesVendidas% = 5
intPrecioUnitario^ = 100

. . .
2. En el cuadro Objeto, seleccione (General). Observe cómo en el cuadro Proce-
dimiento/Evento se coloca automáticamente la palabra (Declarations). Está usted nada más
y nada menos que en la sección de declaraciones generales. Lo que ponga aquí se aplicará a
todo el módulo, es decir, a todo el formulario.
3. Escriba Option Explicit
4. Ejecute el programa. Vea cómo Visual Basic marcará error; haga clic en el botón Aceptar del
mensaje de error. Se abrirá la ventana Código, señalando precisamente dónde se encuentra la
variable mal declarada, en otras palabras, hemos encontrado el error.
5. Elimine la "T" que sobra. Detenga la ejecución del programa y vuelva a ejecutar. Ahora el
programa enviará el resultado correcto.
Option Explicit es de uso obligatorio para el programador profesional de Visual Basic,
así como la declaración precisa de las variables y el tipo de datos al que pertenecen. Puesto que
sería un poco incómodo tener que estar codificando Option Explicit en cada formulario
que generemos, podemos decirle a Visual Basic que de manera predeterminada le coloque
Option Explicit a todos los formularios que generemos.
>> Cómo establecer Option Explicit de manera automática para todos los formularios
nuevos. [06.08]
A continuación establecerá Option Explicit como condición predeterminada de sus
proyectos en Visual Basic.












158 Parte 2: Elementos de programación
1. A través del menú Herramientas - Opciones... - Editor, active la opción Requerir
declaración de variables.
1. Haga clic en Aceptar.

Conversión de datos
Visual Basic es un lenguaje muy práctico, pues procura no generar errores por cues-
tiones de incompatibilidad de tipos de datos, tan comunes en otros lenguajes. Esto
puede llevarle a preocuparse poco por los tipos de datos, pero recuerde, cada tipo de
datos tiene sus límites y particularidades.
Casi todo lo que se captura en una interfaz creada en Visual Basic es texto y si estamos
trabajando en aplicaciones profesionales, deberá ser convertido al tipo de datos
específico que se requiera.
Las funciones de conversión de Visual Basic son las siguientes:

CBool (ExpresiónAConvertir)
CByte (ExpresiónAConvertir)
CCur (ExpresiónAConvertir)
CDate [ExpresiónAConvertir)
CDbl (ExpresiónAConvertir}
CDec {ExpresiónAConvertir)
CInt (ExpresiónAConvertir}
CLng (ExpresiónAConvertir)
CSng (ExpresiónAConvertir)
CStr (ExpresiónAConvertir)
CVar (ExpresiónAConvertir)
IsDate (ExpresiónAEvaluar)
Str (ExpresiónAEvaluar)






Capítulo 6: Variables y tipos de datos 159
El argumento ExpresiónAConvertir es obligatorio; corresponde a la expresión que será
convertida a un tipo de datos determinado.
Los tipos de datos devueltos son los siguientes (el nombre de la función determina el
tipo devuelto, como se muestra a continuación):

Si la expresión del argumento ExpresiónAConvertir que se pasa a la función está fuera
del intervalo del tipo de datos al que se va a convertir, se produce un error. Por ejemplo,
si intentara lo siguiente:
CByte(1000)







160 Parte 2: Elementos de programación
Marcaría un error, ya que no podría ser la existencia de un dato de tipo Byte mayor que
255. En general, el código se puede documentar utilizando las funciones de conversión
de tipos de datos para indicar que el resultado de alguna de las operaciones se debería
expresar como un tipo de datos en particular, no como el tipo de datos predeterminado.
Por ejemplo, utilice Ccur para forzar la ejecución de operaciones con aritmética
monetaria en los casos en los que se haría con precisión simple, doble precisión o
aritmética entera, es decir, ¿si es operación monetaria, por qué darle un tratamiento
diferente?
La función Val es práctica para convertir caracteres a números, sin embargo debe uti-
lizar funciones de conversión de tipos en lugar de Val para proporcionar conversiones
que reconozcan las Variantes internacionales. Por ejemplo, cuando utiliza CCur, se
reconocen diferentes separadores decimales, de millares y varias opciones monetarias,
dependiendo de la configuración regional establecida en su equipo.
Con respecto al redondeo de números en el proceso de conversión, tenemos que cuando
la parte fraccionaria es exactamente 0,5, Cint y CLng siempre redondean al número
par más cercano. Por ejemplo, 0.5 se redondea a O y 1.5 se redondea a 2.
Es conveniente que antes de intentar una conversión con datos de tipo Date/Time,
verifique si lo que desea convertir es una distribución válida. Utilice la función IsDate
para determinar si se puede convertir a Date/Time una fecha o una hora. CDate re-
conoce literales de fecha y literales de hora además de números comprendidos dentro del
intervalo de fechas aceptables. Al convertir un número a una fecha, la parte numérica
entera se convierte a una fecha. Cualquier parte fraccionaria del número se convierte a
la hora del día, comenzando a medianoche.
CDate reconoce formatos de fecha que se ajusten a la configuración regional de su sis-
tema. Es posible que no se determine el orden correcto del día, mes y año si lo pro-
porciona en un formato diferente del que reconoce la configuración de fecha. Si usted
coloca el formato en orden diferente. Visual Basic realizará el ajuste lógico de acuerdo a
lo que su sistema tiene definido.
>> Uso de funciones de conversión. [06.09]
A continuación comprobará el uso de algunas de las funciones de conversión de datos de
Visual Basic.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).

• Editar código: Form, Evento: Activate.
Print "Fechas ------“





Capítulo 6: Variables y tipos de datos 161
' Comprueba el ajuste de fecha y el uso de Cdate
Dim strFecha As String * 10
strFecha$ = "24/10/2000"
Print IsDate(strFecha$)
Print CDate(strFecha$)
strFecha$ = "10/24/2000"
Print IsDate(strFecha$)
Print CDate(strFecha$)
strFecha$ = "2000/10/27"
Print IsDate(strFecha$)
Print CDate(strFecha$)
Print "Números - - - -"
' Diferencia en el tratamiento de datos
Dim strNumero(1 to 2) As String * 3
strNumero$(1) = "20"
strNumero$(2) = "30"
Print strNumero$(1) + strNumero$(2)
Print CInt( strNumero$(1) ) + Cint( strNumero$(2) )
2. Ejecute el código.
La función Format
Visual Basic tiene una función que le permitirá formatear a los datos que maneje en su
programa. Dicha función se llama Format y su sintaxis es como se muestra a con-
tinuación:
Format( DatoAFonnatear, MáscaraDeFormato)
El argumento DatoAFonnatear puede ser cualquier tipo de datos alfabético, numérico o
de fecha y hora. El argumento MáscaraDeFormato puede ser predefinido por Visual
Basic, llamado formato estándar, invocado por un nombre de formato o bien definido
por usted. El resultado de Format siempre es una cadena.












162 Parte 2: Elementos de programación
En la tabla siguiente se muestran algunos de los nombres de formato más comunes:

















Capítulo 6: Variables y tipos de datos 163
>> Uso de la función Format. [06.10]
A continuación comprobará el uso de la función Format utilizando nombres de
formato.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
• Editar código: form. Evento: Activate.
Dim dtmFecha As Date
Dim sngExacto As Single
Dim strTexto As String * 20
Dim bolLogico As Boolean
Print "Texto -------"
strTexto$ = "Texto de prueba"
Print Format(strTexto$, ">")
Print Format(strTexto$, "<")
Print "Numero ------"
sngExacto! = 390922.23
Print Format(sngExacto!, "General Number")
Print Format(sngExacto!, "Currency")
Print Format(sngExacto!, "Fixed")
Print Format(sngExacto!, "Standard")
Print Format(sngExacto!, "Scientific")
sngExacto! = .24
Print Format(sngExacto!, "Percent")
Print "Fecha ------“
dtmFecha = #24/12/2000#
Print Format(dtmFecha,"Long Date")
Print Format(dtmFecha,"Medium Date")
Print Format(dtmFecha,"Short Date")
dtmFecha = #12:23:05#
Print Format(dtmFecha,"Long Time")
Print Format(dtmFecha,"Medium Time")
Print Format(dtmFecha,"Short Time")








164 Parte 2: Elementos de programación

Print "Lógicos --------"
bolLogico = (4 > 3) ' Esto es Verdadero
Print bolLogico
Print Format(bolLogico,"Yes/No")
Print Format(bolLogico,"True/False")
Print Format(bolLogico,"On/Off")
2. Ejecute su código.
En caso de que desee especificar sus propios formatos, tiene una amplia gama de
posibilidades; usted dispone de los siguientes caracteres:

Por ejemplo, vea lo que devolvería la siguiente aplicación de la función Format:

Por otro lado, las fechas tienen su particular forma de ser representadas, para ejem-
plificarlas utilizaremos la palabra reservada Now, que devuelve la fecha y hora actuales
del sistema:









Capítulo 6: Variables y tipos de datos 165


===============================================================
Lo inesperado: Dependiendo de las bibliotecas que tenga instaladas y de su con-
figuración regional, es posible que las especificaciones de año (por ejemplo, "yyyy" o "yy"
de algunos formatos no funcionen adecuadamente. Ese problema se corrige si especifica la
nomenclatura en el idioma que maneja, por ejemplo, si su idioma es el español, podrá
requerir la especificación "aaaa" y "aa", respectivamente.
===============================================================
>> Uso de la función Format, en formatos definidos por el usuario. [06.11]
A continuación comprobará el uso de la función Format utilizando caracteres de formato.
:

1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
• Editar código; Form, Evento: Activate.
Print Format(3515.4, "00000.00")
Print Format(8315.4, "#####.##")
Print Format(8315.4, "##,##0.00")
Print Format(215.4, "$##0.00")
Print Format(Now, "m/d/aa")
Print Format(Now, "dddd, mmmm dd, yyyy")
Print Format(Now, "d-mmm")
Print Format(Now, "mmmm-yy")
Print Format(Now, "hh:mm AM/PM")
Print Format(Now, "h:mm:ss a/p")
Print Format(Now, "d-mmmm h:mm")


2. Ejecute su código.




166 Parte 2: Elementos de programación
___________________________________________________________________________
Resumen
En este capítulo:
• Vimos cómo se maneja la función MsgBox, para desplegar mensajes y hacer con-
firmaciones al estilo de Windows.
• Vimos cómo se maneja la función inputBox.
• Vimos las reglas de nombrado de variables, los tipos de datos, los límites de datos,
los caracteres de declaración de tipo, etcétera.
• Vimos cómo definir matrices de una y dos dimensiones.
• Vimos las funciones de conversión de datos.
• Vimos cómo darles formato a los datos en Visual Basic.
Algunas respuestas a los ejercicios
[06.02] Uso de constantes de Visual Basic.
1.
MsgBox "Operación exitosa", vbExclamation, "Mensaje del sistema"
2.
MsgBox "Dato inválido", vbOKOnly + vbCritical, "Error!"
3.
MsgBox "La unidad de disco no está lista", vbRetryCancel + _
vbCritical, "Mensaje del sistema"
4.
MsgBox "¿Desea continuar?", vbOKCancel + vbQuestion, _
"Mensaje del sistema"
5.
MsgBox "Si acepta:" & chr(13) & chr(10) & _
"- Los registros se actualizan" & chr(l3) & chr(10) & _
"- Se inicia una nueva operación", vbOKCancel + _
vbQuestion, "Confirmación"














Capítulo 6: Variables y tipos de datos 167
[06.04] Determinación del nombre, tipo de datos y alcance indicado para las variables
de memoria.
Los nombres de variables son sugeridos. Usted puede tener su propia idea de nombre de
variable descriptiva.
1. gsngTipoDeCambio!
2. bytCodigocolor
3. mblnprocedeInforme
4. gstrUsuario$



















168































Capítulo
7
Operadores
y estructuras de control


Objetivos
Conocer las diferentes estructuras de control que pueden utilizarse en Visual Basic, a
efecto de programar iteraciones y árboles de toma de decisiones. También se pretende
que sepa elaborar expresiones lógicas y aritméticas, determinando la precedencia de la
solución de las expresiones.
Al finalizar este capítulo deberá:
• Conocer y saber utilizar los operadores aritméticos
• Conocer y saber utilizar los operadores comparativos
• Conocer y saber utilizar los operadores lógicos
• Dominar el uso de la instrucción If
• Dominar el uso de la instrucción Select Case
• Dominar el uso de la instrucción For Next
• Dominar el uso de la instrucción Do Loop
Este capítulo seguirá la pauta marcada por el capítulo anterior: la codificación lo es
todo. No se desespere: conociendo los elementos de la codificación, la creación de la
interfaz es más sencilla y divertida.
169




170 Parte 2: Elementos de programación
Operadores aritméticos
¿Quién no conoce los operadores aritméticos? Por formar parte de la educación bási-. ca
de cualquier profesional en sistemas, difícilmente podríamos agregar algo que no sepa
con respecto a ellos; quizá la novedad puede ser que expliquemos cómo utiliza los
operadores aritméticos el Visual Basic.
El lenguaje dispone de los siguientes operadores aritméticos:

===============================================================
Nota: En el caso de los datos de tipo String, la suma se encarga de concatenar o unir
las expresiones. Para evitar la ambigüedad del operador "+", Visual Basic soporta el uso
del símbolo "&" para concatenación de expresiones String.
===============================================================





Capítulo 7: Operadores y estructuras de control 171
>> Uso de los operadores aritméticos. [07.01]
A continuación aprenderá a utilizar los operadores aritméticos.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
• Editar código: Form, Evento: Activate.
Dim sngNumero1 As Single
Dim sngNumero2 As Single
Dim strTexto1 As String * 10
Dim strTexto2 As String * 10
SngNumero1!=5
sngNumero2! =2
Print "Número 1: " & sngNumero1!
Print "Número 2: " & sngNumero2!
Print "Suma (+):" & sngNumero1! + sngNumero2!
Print "Resta (-):" & sngNumero1! - sngNumero2!
Print "Multiplicación (*):" & sngNumero1! * sngNumero2!
Print "División (/):" & sngNumero1! / sngNumero2!
Print "División a enteros (\):" & sngNumero1! \ sngNumero2!
Print "Residuo (mod):" & sngNumero1! Mod sngNumero2!
Print "Exponenciación (^):" & sngNumero1! ^ sngNumero2!
strTexto1$ = "Visual "
strTexto2$ = "Basic "
Print "Concatenación (+):" & strTexto1$ + strTexto2$
Print "Concatenación (&):" & strTexto1$ & strTexto2$
Print "Concatenación (&):" & Trim(strTexto1$) & _
Trim(strTexto2$)
Print "Concatenación (&):" & Trim(strTexto1$) & " " & _
Trim(strTexto2$)





172 Parte 2: Elementos de programación
Operadores comparativos
Estos operadores permiten analizar la relación que guardan dos elementos entre sí,
regresando a través de un valor de False (Falso) o True (Verdadero) o Null (Nulo).
Hasta el momento no hemos tratado los valores nulos; éstos son la ausencia de valor alguno
y su utilidad es para aplicaciones específicas.
La siguiente tabla describe los operadores comparativos que Visual Basic maneja:

En el caso del operador "=", también se utiliza para la asignación simple de valores a
variables y constantes; será tomada en ese sentido dependiendo de la sintaxis del programa.
Algunos ejemplos del uso de estos operadores son:



"A" = "B" Falso
1 > 0.5 Verdadero
2 >= 2 Verdadero
"S" < "s" Verdadero


En lo que se refiere a la comparación, las letras mayúsculas tienen un valor en código
ASCII menor a las minúsculas, y por tanto, son menores. Adicionalmente, la "A" es menor
que la "Z".




Capítulo 7: Operadores y estructuras de control 173
Código ASCII
El juego de caracteres de 7 bits denominado Código Estándar Estadounidense para el
Intercambio de Información (ASCII) es ampliamente utilizado para representar letras y
símbolos de en un teclado estándar de EE.UU. El juego de caracteres ASCII es igual que
los primeros 128 caracteres (0-127) del juego de caracteres ANSI, utilizado por las
máquinas antiguas.
Es importante que conozca algunas referencias del código ASCII que pueden serle de
utilidad.
Código Representa
_________________________________________________________________________
8 BackSpace (retroceso)
9 Enter (Intro)
10 SpaceBar (Barra espadadora)
11 "@"
92 "\"
48 al 57 "0" al "9"
65 al 90 "A" a la "Z"
97 al 122 "a"ala"z"
255, 233, 237, 243, 250, 241 "á", "é", "í", "ó", "ú", "ñ"
Algunas personas, sobre todo aquellas que no tienen su teclado configurado ade-
cuadamente, saben que si mantienen oprimida la tecla Alt y teclean en el teclado numérico
un código ASCII, éste aparecerá. Para ello es necesario que el teclado numérico esté
activado (teniendo el Bloq Num / NumLock activado).
De tal forma que:
Alt + <64> = @
Visual Basic, por otro lado, tiene funciones que permiten obtener la representación gráfica
de un código ASCII, así como de obtener el código ASCII a partir de una representación
gráfica. Las funciones que lo permiten son Chr( ) y Asc( ), respectivamente.








174 Parte' 2: Elementos de programación
Sintaxis:
Chr( CódigoASCII)
Asc( Carácter )
Ejemplos:
Chr( 64 ) "@"
ASC( "@" ) 64
>> Cómo se resuelven las condiciones que incluyen operadores de comparación. [07.02]
A continuación aprenderá cómo se resuelven los operadores de comparación. Escriba en
la línea si el valor obtenido es True o False.
1. "Casa" > "casa" ____________
2. vbOKCancel = 1 ____________
3. 3000 <> 3000.00 ____________
4. 2000 >= -2000 ____________
Operadores lógicos
Los operadores lógicos sirven para unir o negar condiciones. Los operadores lógicos
básicos son:
• NOT. Niega el resultado de una condición. Revierte el valor; si la condición que
afecta es True, producirá False y viceversa.
• AND. Cuando de entre dos condiciones, ambas deben ser True para que en su
conjunto la expresión sea True. (Todas las condiciones True True.)
• OR. Cuando de entre dos condiciones, al menos una debe ser True para que en su
conjunto la expresión sea True. (Al menos una condición True True.)
• XOR. Cuando de entre dos condiciones, al menos una cumple por True, pero no las
dos.







Capítulo 7: Operadores y estructuras de control 175
================================================================
Nota: También existen Eqv e Imp como operadores lógicos, mismos que no son
detallados en este libro. También se excluyeron los resultados de aquellas expresiones que
involucran valores nulos (Null). ..
Evitamos su referencia para no complicar la explicación del presente tema; revise la
documentación en línea de Visual Basic para profundizar sobre dichos temas.
================================================================
Ejemplos:
NOT "A" = "B"
True, porque "A" = "B" es False, pero la negación es True.
"A" = "B" AND 1 > 0.6
False, porque no todas las condiciones son True.
"A" = "B" OR 1 > 0.5
True, porque al menos una condición es True.
En caso de que tenga más de dos condiciones conjuntas, entra en operación la preferencia.
Consiste en determinar el orden en que las condiciones se deben resolver.
Ejemplos:
"A" = "B" OR 1 > 0.5 AND 2 >=2 AND "S" < "S"
True; las condiciones se resuelven de izquierda a derecha. Vea la explicación
basada en la figura 7.1.




176 Parte 2: Elementos de programación

Siguiendo el orden de izquierda a derecha, la primera y segunda condiciones se
resuelven ("A" = "B" OR 1 > 0.5) y generan un valor True.
Ese resultado se resuelve en conjunto con la tercera condición (True AND 2 >= 2) y
generan un valor de True.
Ese resultado se resuelve con la cuarta condición (True AND "S" < "s") y generan el
valor final, que es True.
Sería como tener paréntesis imaginarios:
( ( ("A" = "B" OR 1 > 0.5) AND 2 >= 2) AND "S" < "s")
En donde las condiciones encerradas en los paréntesis de mayor profundidad se
resuelven primero.
Si usted agrega de manera explícita paréntesis en las condiciones, les asignará pre-
ferencia. Por ejemplo, cambiemos un poco el orden del ejercicio anterior y veamos qué
sucede.
"S" < "s" OR 2 >= 2 AND 1 > 0.5 AND "A" = "B"
De acuerdo a lo que vimos, se resolvería la primera condición con la segunda (True OR
True True), el resultado se resolvería con la tercera (True AND True True) y el
resultado se resolvería con la cuarta (True AND False False).
El resultado de lo último que se resolvió fue False.











Capítulo 7: Operadores y estructuras de control 177
¿Cómo cambiaría la condición, mediante el uso de paréntesis, para que el resultado
fuera verdadero? Soluciones:
("S" < "s" OR ( 2 >= 2 AND 1 > 0.5 AND "A" = "B"))
De esta forma, forzamos a qué en primera instancia se resuelva el paréntesis de mayor
profundidad, que contiene la segunda, tercera y cuarta condiciones (True AND True
AND False False); el resultado se resuelve con la primera condición, por ser el
siguiente paréntesis de mayor profundidad (True OR False True). Considere como
regla que siempre tiene que cerrar los paréntesis que abra.
Una colocación inadecuada de condiciones puede arrojar resultados erróneos; le
recomendamos que aunque de forma predefinida existe una preferencia, usted deter-
mine claramente qué preferencia desea, utilizando paréntesis cuando tenga más de una
condición por resolver.
>> Cómo especificar la preferencia al resolver condiciones, mediante el uso de
paréntesis. [07.03]
A continuación aprenderá a manipular la preferencia de resolución de condiciones
utilizando paréntesis. Considere que la variable Sueldo tiene un valor de 1200.
1. Coloque los paréntesis para que el resultado siempre sea Verdadero :
30 > 10 OR "Robles" > "Zaragoza" AND Sueldo = 10000
2. Coloque los paréntesis para que el resultado siempre sea Falso :
30 > 10 OR "Robles" > "Zaragoza" AND Sueldo = 10000


Prioridad entre operadores
Cuando hay varias operaciones en una misma expresión, cada parte de la misma se
evalúa y se resuelve en un orden predeterminado, según la prioridad de los operadores.
Cuando hay expresiones que contienen operadores de más de una categoría (arit-
méticos, de comparación y lógicos), se resuelven antes las que tienen operadores
aritméticos, a continuación las que tienen operadores de comparación y por último las
de operadores lógicos. Esto tiene sentido si toma en cuenta que la materia prima para
los operadores aritméticos son valores numéricos o cadenas, para generar un nuevo












178 Parte 2: Elementos de programación
valor numérico o de cadena; los operadores de comparación, por su parte, tienen como
materia prima dos valores numéricos o de cadena para determinar un valor lógico; por
último, los operadores lógicos permiten generar un valor lógico de dos valores lógicos.
Todos los operadores de comparación tienen la misma prioridad; es decir, se evalúan de
izquierda a derecha, en el orden en que aparecen. Los operadores lógicos y aritméticos
se evalúan en el siguiente orden de prioridad:


Cuando hay multiplicación y división en la misma expresión, cada operación se evalúa a
medida que aparece, de izquierda a derecha. Del mismo modo, cuando se presentan
adiciones y sustracciones en una misma expresión, cada operación se evalúa tal como
aparecen de izquierda a derecha. Es posible usar paréntesis para saltar el orden de prefe-
rencia y forzar que algunas partes de una expresión se evalúen antes que otras. Las
operaciones entre paréntesis se realizan antes que las que no están entre paréntesis. Sin
embargo, dentro de los paréntesis, la precedencia de los operadores se mantiene.
El operador de concatenación de cadenas (&) no es realmente un operador aritmético,
pero en orden de prioridad se encuentra a continuación de todos los operadores
aritméticos y antes que todos los operadores de comparación.
No olvide que por más larga que parezca una expresión, todos los operadores actúan
sobre dos expresiones y de dos en dos, hasta dejar un solo valor final.

Instrucción If (condicional)
Todo lenguaje de programación requiere de una instrucción que le permita manejar
condiciones que le permitan elaborar un árbol de toma de decisiones, ya que es la única
manera de especificar la secuencia lógica de un proceso; en el caso de Visual Basic, la
instrucción que se utiliza es If, que ejecutará instrucciones dependiendo de un valor
True o False, correspondiente a una expresión lógica.










Capítulo 7: Operadores y estructuras de control 179
La sintaxis de la instrucción es la siguiente (sintaxis 1):
If Condición Then
Instrucciones
End If
Donde If es el inicio de la estructura de control, End If es el fin de la estructura de
control. Instrucciones es el bloque de código que se controla y Condición es la expresión
lógica que determina si Instrucciones se ejecutará o no. Sólo en caso de que Condición
sea True, Instrucciones se ejecutará..
Ejemplo:

La expresión lógica que determina la ejecución del código controlado por If, puede
existir ya sea por el manejo de comparación o a través de una expresión de tipo lógico,
como podría ser una variable de tipo lógico con un valor True o False; el valor Null se
considera False.
If es una instrucción con principio y fin, por lo que si inicia un bloque, tendrá que
concluirlo. If, al igual que otras instrucciones que tienen un inicio y un fin, son llamadas
estructuras de control, ya que basados en una condición dada, determinan la forma en que
se ejecutará un bloque de código (Instrucciones), una o más veces.








180 Parte 2: Elementos de programación
=====================================================
Lo inesperado: Cuando trabaja con la instrucción If, los errores más comunes son:
• Bloque if sin end if (error de compilación}. Sucede cuando se abre un bloque If pero
nunca se concluye con un End if. Soluciones: verifique que el número de If y End If
sea el mismo. Es recomendable que sangre el código para guardar la proporción del
programa.
• End If sin bloque If (error de compilación). Sucede cuando se cierra (End If) un
bloque If que nunca fue abierto. Soluciones: verifique que el número de If y End If
sea el mismo. Es recomendable que sangre el código para guardar la proporción del
programa.
=====================================================

En nuestro caso, si (if) Sueldo es mayor que 4500 (condición), entonces (then)
procederá a ejecutar las Instrucciones que se encuentren entre el inicio y el final del
bloque If, que asignan el valor 3000 a la variable Limite_Credito.
En caso de que sólo se vaya a ejecutar una y sólo una instrucción entre el inicio y el final
del bloque If, la instrucción puede escribirse en una sola línea:

If Sueldo > 4500 Then Limite_Credito = 3000
If ejecutará las Instrucciones que sigan después del componente Then en caso de que
la Condición sea Verdadera, hasta encontrar el final del bloque (End If). If también
tiene la capacidad de ejecutar instrucciones si la condición es Falsa, a través del com-
ponente Else.
La sintaxis de la instrucción es la siguiente (sintaxis 2):

If Condición Then
Instrucciones_Verdadero
[Else
Instrucciones _Falso ]
End if










Capítulo 7: Operadores y estructuras de control 181
Donde Condición es la expresión lógica a evaluarse. Instrucciones_Verdadero será el
código que se ejecutará en caso de que Condición sea True. Instrucciones_Falso será el
código que se ejecutará en caso de que Condición no sea True.
Ejemplo:

Lo que indicaría que si (if) el Sueldo es mayor que 4000, entonces (then)
Limite_Credito tendrá un valor de 3000, de lo contrario (Else),
Limite_Credito tendrá el valor 1000.
En ocasiones es necesario enlazar varias condiciones para seleccionar una opción de entre
varias posibles; para ello se utiliza el elemento Elself, que actúa como Else pero
habilita un nuevo bloque If. El uso de Elself obliga a la definición de una condición
nueva a evaluar; el uso de Else simple, implica solamente que la última condición
evaluada fue Falsa.
La sintaxis de la instrucción es la siguiente:
If Condición Then
Instrucciones
[Elself Condición1 Then
Instrucciones
. . .
[Else
Instrucciones] ]
Endif









182 Parte 2: Elementos de programación
Ejemplo:


If Sueldo > 4000 Then
Limite_Credito = 3000
Elself Sueldo > 3500 Then
Limite_Credito = 1500
Elself Sueldo > 1500 Then
Limite_Credito = 500
Else
Limite_Credito = 0
End If

Lo que indicaría que si (if) el Sueldo es mayor que 4000, entonces (then) Li-
mite_Credito tendrá el valor 3000, de lo contrario, si (elseif) Limite_Credito
es mayor que 3500, entonces (then) Limite_Credito tendrá el valor 1500, de lo
contrario, si (elseif) Limite_Credito es mayor que 1500, entonces (then) Li-
mite_Credito tendrá el valor 500, de lo contrario (else) Limite_Credito
tendrá el valor 0.
Los bloques If, por otro lado, pueden anidarse, es decir, estar unos dentro de otros.
Veamos el ejemplo del código anterior visto a través de condiciones anidadas.











Capítulo 7; Operadores y estructuras de control 183


If Sueldo > 4500 Then
Limite_Credito = 3000
Else
If Sueldo > 3500 Then
Limite_Credito = 1500
Else
If Sueldo > 1500 Then
Limite_Credito = 500
Else
Limite_Credito = 0
End If
End If
End If

Vea la importancia de darle la sangría adecuada al código; el hecho de que las líneas de
código tengan diferente distancia con respecto a la primera posición de la izquierda
permite visualizar de manera fácil que todos los bloques If se han cerrado de manera
adecuada con End If.





184 Parte 2: Elementos de programación
Observe cómo se vería el código sin sangría:
If Sueldo > 4500 Then
Limite_Credito = 3000
Else
If Sueldo > 3500 Then
Limite_Credito = 1500
Else
If Sueldo > 1500 Then
Limite_Credito = 500
Else
Limite_Credito = 0
End If
End If
End If
En este esquema sería muy fácil cometer un error y muy difícil detectarlo.
La sangría será aplicada en todas las estructuras de control que sean referidas en
este libro.

Select Case
En el caso de nuestro ejemplo con la instrucción If, vimos que todas las comparaciones
se realizaron basándose en la evaluación de un mismo dato, en este caso Sueldo.
Cuando se requiere realizar una cantidad de comparaciones sobre una misma expresión,
se recomienda utilizar la instrucción Select Case, cuya sintaxis es la siguinte:
Select Case ExpresiónAEvaluar
Case Condición
Instrucciones
[Case {Condición | Else}
Instrucciones ]
End Select
Se va construyendo un árbol de toma de decisiones basado en una ExpresiónAEvaluar.
Puede agregar tantas instrucciones Case como desee e incluso puede anidar las estruc-
turas Select Case.












Capítulo 7: Operadores y estructuras de control 185
Si al momento de evaluar Condición, un determinado valor de ExpresiónAEvaluar se
cumple en dos casos, se ejecutará para el primero que se encuentre. El caso Else se
aplica cuando el valor de ExpresiónAEvaluar no se cumple en ninguno de los casos
anteriores dentro de la estructura.

====================================================
Lo inesperado: Cuando trabaja con la instrucción If select case, los errores más
comunes son:
• Select Case sin End Select (error de compilación). Sucede cuando se abre un bloque
Select Case pero nunca se concluye dicho bloque con un End Select.
Soluciones: verifique que el número de Select Case y End Select sea el
mismo. Es recomendable que sangre el código para guardar la proporción del
programa.
• End Select sin Select Case (error de compilación). Sucede cuando se cierra (End
Select) un bloque Select Case que nunca fue abierto. Soluciones: verifique
que el número de Select Case y End Select sea el mismo. Es recomendable
que sangre el código para guardar la proporción del programa.
====================================================

Para ver cómo funciona esta instrucción, imagínese la siguiente situación hipotética:
una compañía tiene 35 categorías de empleados; cada categoría tiene un ingreso
determinado, en donde las categorías de número más alto son las de mayor ingreso por
salario, y existe una relación directamente proporcional entre categoría y sueldo. Se
acaba de autorizar un aumento de sueldo general en la compañía, bajo las siguientes
políticas: el personal de alto nivel (categoría superior a 19) no tendrá aumento; las
categorías 18, 17 y 14 recibirán el 15 por ciento de aumento; de la categoría 8 a la 13,
recibirán el 10 por ciento de aumento, a excepción de la categoría 10, que es la categoría
más rezagada con respecto al salario, pues recibirá el 25 por ciento. Al resto del
personal, se le dará un 5 por ciento de aumento.
¿Cómo codificaría una estructura Select Case que atendiera esta necesidad?
Veamos:
Select Case Categoria
Case Is > 19
Aumento =0
Case 18, 17, 14
Aumento =0.15
Case 10
Aumento =0.25
Case 8 To 13
Aumento =0.1
Case Else
Aumento = 0.5
End Select





186 Parte 2: Elementos de programación
Vea cómo se especificaron las condiciones y aplique la sintaxis en aquellos casos que lo
requiera.
Es importante que se dé cuenta que todas las condiciones giran en tomo a la Expre-
siónAEvaluar (en nuestro ejemplo. Categoría), ya que si no hace uso de dicha
expresión, las condiciones no se considerarán. Usted puede agregar como instrucción
una línea con una condición Case que se resuelva como True, pero que no involucre a
Categoría; en ese caso, el código dependiente de dicha condición nunca se ejecutará.
For Next
For Next es la estructura iterativa por excelencia que permite repetir la ejecución de un
conjunto de instrucciones un número conocido de veces, determinado por las ocu-
rrencias de un número que se incrementa o reduce a una determinada proporción, desde
un límite inferior hasta un límite superior.
Su sintaxis es:
For Variable = Valorinicial To ValorMáximofinal [Step Incremento]
Instrucciones
Next Variable
Donde Variable es una variable de memoria de tipo entero, que permitirá controlar las
iteraciones del proceso. Valorinicial es el valor inicial a partir del cual el incremento o
decremento se llevará a cabo. ValorMáximo es el valor al que la cuenta deberá llegar.
Incremento es la constante entera que marcará la cantidad de incremento o decremento
que sufrirá Variable en cada iteración.
Ejemplos:
' Cuenta del 1 al 10
For i = 1 To 10
Print i
Next i
' Serie del 5
For i = 0 To 50 Step 5
Print i
Next i










Capítulo 7: Operadores y estructuras de control 187

' Decremento del 10 al 1
For i = 10 To 1 Step -1
Print i
Next i
Si se omite la especificación Step, se asume un incremento positivo de uno. Si in-
cremento es negativo, hablamos de un decremento, en términos reales.
Una instrucción que puede ser útil en el caso de For Next es Exit For, que interrum-
pe la ejecución del For como si ya hubiera cumplido todas las iteraciones.
>> Uso de For Next. [07.04]
A continuación aprenderá a utilizar For Next. Este ejemplo también le ayudará a
practicar otras instrucciones vistas hasta el momento.
El ejemplo consiste en preguntar 6 números enteros, determinar cuál es la suma de todos
y cuál fue el número más grande proporcionado.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
• Editar código: Form, Evento: Activate

Dim intVentas(1 To 6) As Integer
Dim strMensaje As String * 25
Dim intContador As Integer
Dim intSuma As Integer
Dim intMaximo As Integer
' Primer proceso iterativo: preguntar datos.
For intContador% = 1 To 6
strMensaje$ = "Captura del número " & _
Format(intContador%, "##")
intVentas!%(intContador%) = _
InputBox("Dame un número entero", strMensaje$)
Next intContador%







188 Parte 2: Elementos de programación
' Segundo proceso iterativo: desplegar lo capturado-.
Print "Captura---"
For intContador% = 1 To 6
Print intVentas!%(intContador)
Next intContador%
' Tercer, proceso iterativo: sumar cantidades
' y determinar el número máximo.
intSuma% =0
IntMaximo% =0
For intContador% = 1 To 6
intSuma% = intSuma% + CInt(intVentas!%(intContador%))
If intVentas!%(intContador%) > intMaximo% Then
IntMaximo% = intVentas!%(intContador%)
End If
Next intContador%
Print "Resultados----"
Print "La suma es " & Format(intSuma%, "###,###,###.##")
Print "El número máximo fue " & _
Format(intMaximo%, "###,###,###.##")
>> Uso de Exit For. [07.05]
A continuación aprenderá a utilizar Exit For.
Esta sección requiere que ya haya realizado la práctica anterior. Si al capturar
los números teclea cero, ya no se capturarán más números.

• Modificar código: Form, Evento: Activate.
For intContador% = 1 To 6
strMensaje$ = "Captura del número " & _
Format(intContador%, "##")
intVentas!%(intContador%) = _
InputBox("Introduzca un número entero", strMensaje$)
If intVentas!%(intContador%) = 0 then
MsgBox "No más números"
Exit For
End If
Next intContador%

====================================================
Lo inesperado: Cuando trabaja con la instrucción For Next, los errores
más comunes son:
• For sin Next (error de compilación). Sucede cuando abre un bloque For pero
nunca concluye dicho bloque con un Next. Soluciones: verifique que el
número



Capítulo 7: Operadores y estructuras de control 189
de For y Next sea el mismo. Es recomendable que sangre el código para guardar la
proporción del programa.
• Next sin For (error de compilación). Sucede cuando cierra (Next) un bloque For
que nunca abrió. Soluciones: verifique que el número de For Case? y Next sea el
mismo. Es recomendable que sangre el código para guardar la proporción del
programa.
• Referencia de variable de control Next no válida (error de compilación). La variable
utilizada en una instrucción For Next, determina el control iterativo; la misma
variable que se utiliza en el For debe ser utilizada en el Next. El error se presenta
cuando el primer Next encontrado no utiliza la variable utilizada en el último For
abierto. Soluciones: verifique que los nombres de variables tanto en el For como en el
Next sean los mismos. En el caso de For Next anidados, verifique que el último
abierto sea el primero en cerrarse.
===================================================
Do Loop
Do Loop es una estructura iterativa que permite repetir la ejecución de un conjunto de
instrucciones un número desconocido de veces, determinada por el cumplimiento de una
condición.
Su sintaxis es:
Do {While | Until} Condición
Instrucciones
Loop
Donde Condición es la expresión lógica que mientras su valor sea True, mantendrá el
proceso iterativo, ejecutando Instrucciones. Do inicia la estructura de control, mientras
que Loop indica el final de dicha estructura.
Ejemplo:
Lo siguiente despliega un número mientras éste sea menor o igual a 10.
Dim intNumero As Integer
Do While intNumero% <= 10
intNumero% = intNumero% + 1
Print intNumero%
Loop






190 Parte 2: Elementos de programación
La diferencia entre utilizar While (mientras que) o Until (hasta que) resulta obvia.
Dependiendo cómo quiera estructurar su código, puede ser que desee ejecutar un
proceso mientras se cumpla una determinada situación, o bien hasta que una deter-
minada condición se cumpla.
En este tipo de estructura puede suspender la ejecución en cualquier momento a través
de la instrucción Exit Do. Es importante que sepa esto, ya que este tipo de estructura
de control se presta a crear estructuras de ejecución indefinida, que sólo podrá romper a
través de presionar la combinación de teclas Ctrl+Inter (o Ctrl+Break).
>> Uso de Do Loop. [07.06]
A continuación aprenderá a utilizar Do Loop. Comprobará que tienen un sentido
opuesto, pero son igualmente útiles.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).

• Editar código: Form, Evento: Activate.
Dim intNumero As Integer
intNumero% = 0
Print "Inicia Do While---"
Do While intNumero% <> 10
intNumero% = intNumero% + 1
Print intNumero%
Loop
Print "Fin---"
intNumero% = 0
Print "Inicia Do Until---"
Do Until intNumero% = 10
intNumero% = intNumero% + 1
Print intNumero%
Loop
Print "Fin---"

====================================================
Lo inesperado: Cuando trabaja con la instrucción Do Loop, los errores más co-
munes son:
• Do sin Loop (error de compilación). Sucede cuando abre un bloque Do pero nunca
concluye con un Loop. Soluciones: verifique que el número de Do y Loop








Capítulo 7: Operadores y estructuras de control 191
sea el mismo. Es recomendable que sangre el código para guardar la proporción del
programa.

• Loop sin Do (error de compilación). Sucede cuando cierra (Loop) un bloque Do que
nunca abrió. Soluciones: verifique que el número de Do y Loop sea el mismo. Es
recomendable que sangre el código para guardar la proporción del programa.
====================================================


_____________________________________________________________________________________
Resumen
En este capítulo:
• Vimos los principales operadores de Visual Basic (aritméticos, de comparación y
lógicos).
• Vimos la precedencia en que se resuelven las expresiones y la utilidad de los
paréntesis en dicha tarea.
• Vimos las principales estructuras de control en Visual Basic, tales como If, Fon
Next,Case Select y Do Loop.
• Vimos algunas generalidades del código ASCH que nos pueden ser de utilidad.
Es importante tener bien comprendidos todos los puntos anteriormente referidos, ya que
son muy importantes para comprender el resto del libro.

Algunas respuestas a los ejercicios
[07.02] Cómo se resuelven las condiciones que incluyen operadores de com-
paración.
1. False. Las mayúsculas tienen un valor menor que las minúsculas y la comparación se
hace letra por letra, comenzando de izquierda a derecha.
2. True.
3. False. En expresiones numéricas el valor sin decimales o con decimales es lo mismo.
4. True.










192 Parte 2: Elementos de programación
[07.03] Cómo especificar la preferencia al resolver condiciones, mediante el uso de
paréntesis.
1. 30 > 10 OR ("Robles" > "Zaragoza" AND Sueldo = 10000)
2. (30 > 10 OR "Robles" > "Zaragoza") AND Sueldo = 10000

































Capítulo
8
Funciones de
manipulación
de datos


Objetivo
Conocer las funciones más importantes que tiene Visual Basic para manejar tiempo,
números y cadenas.
Al finalizar este capítulo deberá:
• Saber qué son las funciones
• Conocer y saber utilizar las funciones de fecha y hora
• Conocer y saber utilizar las funciones de manipulación de cadenas
• Conocer y saber utilizar las funciones matemáticas
• Conocer y saber utilizar las funciones trigonométricas
• Saber calcular algunos resultados para los cuales Visual Basic no tiene funciones
implícitas
Estamos seguros de que este capítulo le servirá de referencia.
193













194 Parte 2: Elementos de programación
Qué son las funciones
Las funciones son aquellas estructuras del lenguaje que permiten obtener un dato que
necesitamos, ya sea porque el sistema lo posee o bien porque le proporcionamos un dato
de entrada (argumento, llamado en ocasiones parámetro), para que siendo sometido a
un proceso determinado, derive en un resultado.
Las funciones pueden ser implícitas, es decir, formar parte de Visual Basic o bien
Funciones Definidas por el Usuario (UDF's). Este capítulo tratará de aquellas funciones
implícitas que pueden ser de mucha ayuda para el programador en los diferentes
procesos; la ventaja de la existencia de funciones implícitas radica en que si la función
ya existe, no habrá necesidad de programarla. El poder de un lenguaje puede medirse,
ciertamente, en la cantidad de funciones que posee y en la facilidad que brinda para
crear nuevas funciones.
Algunas funciones, como ya mencionábamos, no requieren argumentos, como es el caso
de:
Now

Que devuelve la fecha de hoy.
Hay otras que sí requieren argumentos, como es el caso de MsgBox:
MsgBox Genera error
MsgBox ("Algo") Es correcto, porque posee argumentos
Si no especificamos el argumento de mensaje, marcará error. Algunas funciones per-
miten ejecutarse sin asignar el valor devuelto a una variable; sin embargo, otras no, es
decir, requieren ser el extremo derecho de una expresión de igualdad.
Los grandes grupos de funciones que analizaremos son las siguientes:
• Funciones de fecha y hora
• Punciones de manipulación de cadenas
• Funciones numéricas
• Funciones trigonométricas
• Funciones de decisión







Capítulo 8: Funciones de manipulación de datos 195

Funciones de fecha y hora
Resumen de funciones a revisar en esta clasificación:
• Date Fecha del sistema
• DateAdd Agrega un intervalo de tiempo especificado
• DateDiff Número de intervalos de tiempo entre dos fechas dadas
• DatePart Número correspondiente a una parte de una fecha dada
• Day Día de una fecha dada
• Hour Hora de una fecha/hora dada
• IsDate Indica si una expresión se puede convertir a fecha
• Minute Minutos de una fecha/hora dada
• Month Mes de una fecha dada
• MonthName Indica el nombre de un mes especificado por número
• Now Fecha del sistema
• Second Segundos de una fecha/hora dada
• Time Hora del sistema
• Timer Número de segundos transcurridos desde la media noche
• WeekDay Número correspondiente al día de la semana de la fecha dada
• WeekdayName Indica el nombre del día de la semana especificado
• Year Año de una fecha dada





















196 Parte 2: Elementos de programación
______________________________________________________________________
Date
Tipo de datos que devuelve: Variant (Date/Time).
Devuelve la fecha y hora del sistema. Si se hace una asignación, modifica la fecha del
sistema.
Sintaxis:
Date
Date = FechaAAsignar
Donde FechaAAsignar es la expresión de tipo Date/Time de la fecha que queremos que
tenga el sistema.
______________________________________________________________________
DateAdd
Tipo de datos que devuelve: Variant (Date/Time).
Devuelve una nueva fecha, resultado de agregar un intervalo determinado de tiempo a
una fecha.
Sintaxis:
DateAdd (Intervalo, Número, Fecha)
Donde Intervalo puede ser cualquiera de los que aparecen en la siguiente tabla:

Número es la cantidad de intervalo a agregar y Fecha es la expresión de tipo Date/Time
a la cual se le va a agregar el intervalo.









Capítulo 8: Funciones de manipulación de datos 197
______________________________________________________________________
DateDiff
Tipo de datos que devuelve: Variant (Long).
Devuelve la cantidad dada de un intervalo que existe de diferencia entre dos fechas.
Sintaxis:
DateDiff (Intervalo, Fecha1, Fecha2)
Donde Intervalo puede ser cualquiera de los intervalos mostrados en la función
DateAdd.
Fecha1 y Fecha2 son las fechas entre las que se determinará la diferencia.
______________________________________________________________________
DatePart
Tipo de datos que devuelve: Variant (Integer).
Devuelve el número correspondiente a una parte de la fecha, misma que es especificada
como un intervalo.
Sintaxis:
DatePart (Intervalo, Fecha)
Donde Intervalo puede ser cualquiera de los intervalos mostrados en la función
DateAdd. Fecha es la expresión de tipo Date/Time a partir de la cual se va a determi-
nar la parte de la fecha.

______________________________________________________________________
Day
Tipo de datos que devuelve: Variant (Integer).
Devuelve el número del día (1 a 31) de una fecha dada.
Sintaxis:
Day (Fecha)
Donde Fecha es la expresión de tipo Date/Time a partir de la cual se va a determinar el
número de día.










198 Parte 2: Elementos de programación
______________________________________________________________________
Hour
Tipo de datos que devuelve: Variant (Integer). Devuelve el número de la hora de una
fecha/hora dada. Sintaxis:
Hour(Fecha)
Donde Fecha es la expresión de tipo Date/Time a partir de la cual se va a determinar el
número de hora.
______________________________________________________________________
Minute
Tipo de datos que devuelve: Variant (Integer).
Devuelve el número del minuto de una fecha/hora dada.
Sintaxis:
Minute(Fecha)
Donde Fecha es la expresión de tipo Date/Time a partir de la cual se va a determinar el
minuto de la hora.
______________________________________________________________________
Month
Tipo de datos que devuelve: Variant (Integer). Devuelve el número del mes de una
fecha dada.
Sintaxis:
Month (Fecha)
Donde Fecha es la expresión de tipo Date/Time a partir de la cual se va a determinar el
mes.















Capítulo 8: Funciones de manipulación de datos 199
______________________________________________________________________
MonthName
Tipo de datos que devuelve: String.
Devuelve la cadena que especifica el mes expresado en número.
Sintaxis:
MonthName (Mes [ , Abreviar] )
Donde Mes es el número del mes que desea determinar en cadena. Si coloca Abreviar,
el valor será True y si lo omite, el valor del argumento será False.
______________________________________________________________________
Now
Tipo de datos que devuelve: Variant (Date/Time).
Devuelve la fecha y hora del sistema.
Sintaxis:
Now
______________________________________________________________________
Second
Tipo de datos que devuelve: Variant (Integer). Devuelve el número del segundo de una
fecha/hora dada.
. Sintaxis:
Second (Fecha)

Donde Fecha es la expresión de tipo Date/Time a partir de la cual se va a determinar el
segundo de la hora.



















200 Parte 2: Elementos de programación
______________________________________________________________________
Time
Tipo de datos que devuelve: Variant (Date/Time).
Devuelve la fecha y hora del sistema. Si se hace una asignación, modifica la hora del
sistema.
Sintaxis:
Time
Time = HoraAAsignar
Donde HoraAAsignar es la expresión de tipo Date/Time a partir de la cual se va a
establecer la hora del sistema.
______________________________________________________________________
Timer
Tipo de datos que devuelve: Single.
Devuelve el número de segundos transcurridos desde la media noche.
Sintaxis:
Timer
______________________________________________________________________
WeekDay
Tipo de datos que devuelve: Variant (Integer).
Devuelve el número entero que representa el día de la semana, donde el Domingo es 1 y
el Sábado es 7.
Sintaxis:
WeekdayName( Día [ , Abreviar ] )
Donde Día es el número del día de la semana que se desea determinar en cadena. Si
coloca Abreviar, el valor será True y si lo omite, el valor del argumento será False.



Capítulo 8: Funciones de manipulación de datos 201
__________________________________________________________
Year
Tipo de datos que devuelve: Variant (Integer).
Devuelve el número del año de una fecha dada.
Sintaxis;
Year (Fecha}
Donde Fecha es la expresión de tipo Date/Time a partir de la cual se va a determinar el
año.
>> Uso de funciones de fecha y hora. [08.01]
A continuación aprenderá a utilizar las funciones de fecha y hora.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
• Editar código: Form, Evento: Activate.
Print Date
Print Time
Print "------------------------------"
Print "La fecha de hoy es: " & Now
Print "Año: " & Year(Now)
Print "Mes: " & Month(Now)
Print "Dia: " & Day(Now)
Print "-- Usando DatePart ---"
Print "Año: " & DatePart("yyyy", Now)
Print "Mes: " & DatePart("m", Now)
Print "Día: " & DatePart ("d", Now)
Print "Ubicación en el año"
Print "Trimestre: " & DatePart("q", Now)
Print "Semana: " & DatePart("ww", Now)
Print "Dia de la semana: " & DatePart("w", Now)
Print "Dia del año: " & DatePart("y", Now)
Print "------------------------------"
‘cambiar a 200x las siguientes 2 líneas para tener año actual
Print "Falta para el fin de año del 2002"
Print (DateSerial(2001, 12, 31) - Now) & " días"






202 Parte 2: Elementos de programación

Funciones de manipulación de cadenas
(string)
Resumen de funciones a revisa: en esta clasificación:
• Asc Proporciona el código ASCII de una representación carácter.
• Chr Proporciona la representación carácter de un código ASCII.
• InStr Especifica la posición de la aparición de una cadena en otra.
• InStrRev Especifica la posición de la aparición de una cadena en otra,
iniciando desde el final de la cadena.
• IsEmpty Indica si una variable ha sido declarada.
• IsNull Indica Si una variable tiene valor nulo (Null),
• LCase Cambia a minúsculas una cadena.
• Len Devuelve el número de caracteres de una expresión.
• Ltrim Elimina los espacios a la izquierda.
• Mid Extrae un número determinado de caracteres de una cadena.
• Replace Reemplaza una subcadena especificada con otra subcadena.
• Rtrim Elimina los espacios a la derecha.
• Space Repite un número determinado de espacios.
• Str Convierte un número a cadena.
• StrConv Convierte una cadena en base a código de conversión.
• String Repite una cadena un número de veces especificado.
• StrReverse Escribe al revés una cadena.
• Trim Elimina los espacios a la derecha y a la izquierda.
• UCase Cambia a mayúsculas una cadena.












Capítulo 8: Funciones de manipulación de datos 203
__________________________________________________________
ASC
Tipo de datos que devuelve: Integer.
Devuelve el código ASCII de la primera letra de una cadena.
Sintaxis:
Asc(Cadena)
Donde Cadena es una cadena a la cual se le va a determinar el código ASCII de la
primera posición.

__________________________________________________________
Chr
Tipo de datos que devuelve: String.
Devuelve un carácter a partir de su código ASCII.
Sintaxis:
Chr(CódigoASCII)
Donde CódigoASCII es un número de código ASCII válido (0 - 255).
__________________________________________________________
InStr
Tipo de datos que devuelve: Variant (Long).
Devuelve la posición en que se encuentra una cadena dentro de otra, a partir de una
posición opcional.
Sintaxis:
InStr([Inicio, ] Cadena1, Cadena2)
Donde Cadena1 es la cadena en donde se busca la existencia de Cadena2; Inicio es
opcional e indica la posición a partir de la cual se pretende buscar. Si no se encuentra
ninguna ocurrencia de Cadena2, en Cadena1, la función devolverá 0; de manera
predeterminada, Inicio tiene el valor 1.





204 Parte 2: Elementos de programación
__________________________________________________________
InStrRev
Tipo de datos que devuelve: Variant (Long).
Devuelve la posición en la que se encuentra una cadena dentro de otra, a partir de una
posición opcional, en un orden invertido (de atrás para adelante).
Sintaxis:
InStrRev(Cadena1, Cadena2 [, Inicio] )
Donde Cadenal es la cadena en donde se busca la existencia de Cadena2; Inicio es
opcional e indica la posición a partir de la cual se pretende buscar. Si no se encuentra
ninguna ocurrencia de Cadena2 en Cadenal, la función devolverá 0.

__________________________________________________________
IsEmpty
Tipo de datos que devuelve: Boolean.
Indica si una expresión ha sido inicializada.
Sintaxis:
IsEmpty(Expresión)
Donde Expresión es cualquier variable que se busca determinar si ya fue o no declarada
(que ha obtenido valor alguna vez, aunque éste sea 0 o nulo, o esté vacío).

__________________________________________________________
IsNull
Tipo de datos que devuelve: Boolean.
Indica si una expresión contiene datos no válidos o nulos (Null).
Sintaxis:
IsNull (Expresión)
Donde Expresión es cualquier variable que se busca determinar si representa datos no
válidos o nulos.






Capítulo 8: Funciones de manipulación de datos 205
__________________________________________________________
LCase
Tipo de datos que devuelve: String.
Transforma una cadena a minúsculas.
Sintaxis:
LCase (Cadena)
Donde Cadena es la cadena a transformar.
__________________________________________________________
Len
Tipo de datos que devuelve: Long.
Devuelve el número de caracteres de una expresión.
Sintaxis:
Len (Cadena)
Donde Cadena es la cadena a evaluar.
__________________________________________________________
Ltrim
Tipo de datos que devuelve: Variant (String).
Elimina los espacios en blanco que se encuentran a la izquierda de una cadena.
Sintaxis:
Ltrim (Cadena)
Donde Cadena es la cadena tomada como base.




206 Parte 2: Elementos de programación
__________________________________________________________
Mid
Tipo de datos que devuelve: Variant (String).
Devuelve una subcadena extraída de una cadena.
Sintaxis:
Mid(Cadena, Inicio [, Longitud] )
Donde Cadena es la cadena tomada como base, Inicio es la posición inicial de la sub-
cadena y Longitud es el número de caracteres de la subcadena.
__________________________________________________________
Replace
Tipo de datos que devuelve: String.
Reemplaza una subcadena por otra, en una cadena.
Sintaxis:
Replace (Cadena, Cadena1, Cadena2[,Inicio])
Donde Cadena es la cadena tomada como base, Cadena1 es la cadena a buscar,
misma que será remplazada por Cadena1. Inicio es la posición inicial de la cadena, a
partir de donde se procederá a buscar; es opcional y si se omite es igual a 1.
__________________________________________________________
Rtrim
Tipo de datos que devuelve: String.
Elimina los espacios en blanco que se encuentran a la derecha en una cadena.
Sintaxis:
Rtrim(Cadena)
Donde Cadena es la cadena tomada como base.





Capítulo 8: Funciones de manipulación de datos 207
__________________________________________________________
Space
Tipo de datos que devuelve: Variant (String).
Devuelve un número determinado de espacios.
Sintaxis:
Space (Número)
Donde Número es la cantidad de espacios a devolver.
__________________________________________________________
Str
Tipo de datos que devuelve: Variant (String).
Convierte una expresión numérica a cadena.
Sintaxis:
Str (Número)
Donde Número es la expresión numérica tomada como base.
__________________________________________________________
StrConv
Tipo de datos que devuelve: Variant (String).
Convierte una cadena de acuerdo a un código de conversión.
Sintaxis:
StrConv(Cadena, CódigoDeConversión)
Donde Cadena es la cadena tomada como base y CódigoDeConversión puede ser
cualquiera de los siguientes: vbUpperCase (MAYÚSCULAS), vbLowerCase (minúscu-
las) y vbPropecCase (Mayúsculas Las Primeras Letras).




208 Parte 2; Elementos de programación
__________________________________________________________
String
Tipo de datos que devuelve: Variant (String).
Repite una cadena un determinado número de veces.
Sintaxis:
String (Número, Cadena)
Donde Cadena es la cadena a repetir. Número es la cantidad de veces a repetirla.
__________________________________________________________
StrReverse
Tipo de datos que devuelve: String.
Escribe al revés una cadena.
Sintaxis:
StrReverse(Cadena)
Donde Cadena es la cadena a revertir.
__________________________________________________________
Trim
Tipo de datos que devuelve: String.
Elimina los espacios en blanco que se encuentran a la izquierda y a la derecha de una
cadena.
Sintaxis:
Trim(Cadena)
Donde Cadena es la cadena tomada como base.



Capítulo 8: Funciones de manipulación de datos 209
__________________________________________________________
UCase
Tipo de datos que devuelve: String.
Convierte una cadena a su equivalente en mayúsculas.
Sintaxis:
Ucase(Cadena)
Donde Cadena es la cadena a transformar.
>> Uso de funciones de manipulación de cadenas. [08.02]
A continuación aprenderá a utilizar las funciones de fecha y hora.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
• Editar código: Form, Evento: Activate.

Dim strMensaje As String
Dim intCuentaVocales As Integer
Dim intContador As Integer
Dim strLetra As String * 1
strMensaje$ = "Éste es un mensaje de prueba"
Print LCase(strMensaje$)
Print UCase(strMensaje$)
Print StrConv(strMensaje$, vbProperCase)
Print "El primer espacio en la posición:" & _
InStr(strMensaje$, " ")
Print "De atrás para adelante:" &
InStrRev(strMensaje$, _
" ")
Print "Texto al revés:" & StrReverse(strMensaje$)
Print "Longitud del texto:" & Len(strMensaje$)
Print "A partir de la posición 9, 4 letras:" & _
Mid(strMensaje$, 9, 4)


210 Parte 2: Elementos de programación
intCuentaVocales% = 0
For intContador% = 1 To Len(strMensaje$)
strLetra$ = Mid(strMensaje$, intContador%, 1)
If InStr("aeiouAEIOU", strLetra$) > 0 Then
intCuentaVocales% = intCuentaVocales% +
1
End If
Next intContador%
Print "Cantidad de vocales:" & intCuentavocales%
Print "Remplazando espacios:" & _
Replace(strMensaje$, " ", "_")
Funciones numéricas
Resumen de funciones a revisar en esta clasificación:
• Abs Valor absoluto
• Hex Valor hexadecimal de un número
• Int, Fix Devuelve la parte entera de un número
• IsNumeric Indica si una expresión puede convertirse en número
• Oct Valor octal de un número
• Rnd Devuelve un número aleatorio
• Round Redondea un número, cierto número de posiciones
decimales
• Sgn Indica el signo de un número
• Sqr Raíz cuadrada de un número

__________________________________________________________
Abs
Tipo de datos que devuelve: según los argumentos. Devuelve el valor absoluto de un
número.
Sintaxis:
Abs (Número)
Donde Número es el valor base del cálculo.


Capítulo 8: Fundones de manipulación de datos 211
__________________________________________________________
Hex
Tipo de datos que devuelve: String.
Devuelve el valor hexadecimal de un número.
Sintaxis:
Hex(Número)
Donde Número es el valor base del cálculo.
__________________________________________________________
Int, Fix
Tipo de datos que devuelve: Double.
Devuelve la parte entera de un número.
Sintaxis:
Int(Número)
Fix(Número)
Donde Número es el valor base del cálculo. La diferencia entre Int y Fix consiste en
que Si Número es negativo, Int devuelve el primer entero negativo menor o igual a
Número, mientras que Fix devuelve el primer entero negativo mayor o igual a Número.

__________________________________________________________
IsNumeric
Tipo de datos que devuelve: Boolean.
Especifica si una expresión puede o no ser convertida a número.
Sintaxis:
IsNumeric (Expresión)
Donde Expresión es el dato a evaluar.







212 Parte 2: Elementos de programación
__________________________________________________________
Rnd
Tipo de datos que devuelve: Single.
Devuelve un número aleatorio.
Sintaxis:
Rnd
__________________________________________________________
Round
Tipo de datos que devuelve: según los argumentos.
Devuelve un número redondeado, tomando como base un número determinado de
posiciones.
Sintaxis:
Round (Número [, Decimales] )
Donde Número es el valor base del cálculo. Decimales es el número de posiciones
decimales hacia la derecha que se desean considerar para el redondeo.
__________________________________________________________
Sgn
Tipo de datos que devuelve: Variant (Integer).
Devuelve el signo del número.
Sintaxis:
Sgn (Número).
Donde Número es el valor base del cálculo. Si devuelve 1, Número es mayor que cero, si
es O, Número es cero y si devuelve -1, Número es menor que cero.













Capítulo 8: Funciones de manipulación de datos 213
__________________________________________________________
Sqr
Tipo de datos que devuelve: Double.
Devuelve la raíz cuadrada de un número.
Sintaxis:
Sqr (Número)
Donde Número es el valor base del cálculo.


Funciones de decisión
Resumen de funciones a revisar en esta clasificación:
• Choose Devuelve un valor de una lista de argumentos
• iif Devuelve uno de entre dos valores, dependiendo de una condición
__________________________________________________________
Choose
Tipo de datos que devuelve: según los argumentos.
Selecciona o devuelve un valor de entre una lista de argumentos.
Sintaxis:
Choose (Índice, Opción1 [, Opción2,... [OpciónN] ] )
Donde Índice es el elemento a devolver y Opciónl a OpciónN, la lista de elementos.









214 Parte 2: Elementos de programación
__________________________________________________________
IIf
Tipo de datos que devuelve: según los argumentos.
Devuelve uno de entre dos valores, dependiendo de una condición.
Sintaxis:
IIf (Condición, PorVerdadero, PorFalso)
Donde Condición es una condición o expresión lógica que implique valor falso o ver-
dadero; si es verdadero, se devolverá PorVerdadero y si es falso, se devolverá PorFalso.
>>Uso de funciones numéricas y de decisión. [08.03]
A continuación aprenderá a utilizar las funciones de fecha y hora.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
• Editar código: Form, Evento: Activate.

Dim strCaptura As String
Dim sngNumero As Single
Dim blnBandera As Boolean
Dim intOpcion As Integer
blnBandera = True
Do While blnBandera
strCaptura$ = InputBox("Número (con o sin
decimales):")
If IsNumeric(strCaptura) Then
Print "Lo capturado puede traducirse a numero"
sngNumero! = CSng(strCaptura$)
Print "Valor absoluto:" & Abs(sngNumero!)
Print "Número " & IIf(Int(sngNumero!) =
sngNumero!, _
"entero", "con decimales")









Capítulo 8: Funciones de manipulación de datos 215
If Int(sngNumero!) = sngNumero! Then
Print "Redondeado a 2 posiciones:" & _
Round(sngNumero!, 2)
End If
Select Case Sgn(sngNumero!)
Case Is = -1
intOpcion% =1
Case Is = 0
intOpcion% = 2
Case Is = 1
intOpcion% = 3
End Select
Print "El número es " & _
Choose(intOpcion%, "negativo", "cero", "positivo")
Print "Hexadecimal:" & Hex(sngNumero!)
Print "Octal:" & Oct(sngNumero!)
If sngNumero! > 0 Then
Print "Raíz cuadrada:" & Sqr(sngNumero!)
End If
Else
Print "Nada que hacer; no es expresión numérica"
End If
Print “------------------------“
If MsgBox("Desea otro ejemplo?", vbOKCancel + vbQuestion, _
"Números") = vbCancel Then
blnBandera = False
End If
Loop
End






216 Parte 2: Elementos de programación

Funciones de uso específico
Las funciones que hemos visto pueden ser aplicadas en ámbitos muy amplios,
es decir, son funciones de propósito general; es indispensable conocerlas para
desarrollar sin complicaciones cualquier proceso dentro de Visual Basic.
Sin embargo, este lenguaje posee muchas otras funciones, pero sería muy
complicado explicarlas sin perder el objetivo de este libro. Lo que no
queremos hacer es dejar de mencionar algunas funciones de las que llamamos
de proceso específico, mismas que dividimos en dos categorías: financieras y
trigonométricas.
Hasta el momento ha podido comprobar cómo se comportan las funciones
con su simple ejecución. En el caso de las funciones financieras y
trigonométricas, requiere algo más que la simple ejecución, requiere saber la
mecánica de los cálculos, principios matemáticos, manejo de tablas de
logaritmos, etcétera. No nos meteremos con esas complicaciones;
simplemente describiremos qué funciones de propósito específico existen.

Funciones financieras










Capítulo 8; Funciones de manipulación de datos 217



Funciones trigonométricas

Si los cálculos que requiere hacer son más complicados y necesita otras funciones más
elaboradas, tal vez le sea útil ver algunas funciones derivadas:
"X" es el número base para el cálculo.









218 Parte 2: Elementos de programación


Se ilustraron muchas funciones de Visual Basic; aún faltan muchas más, pero se revi-
sarán en el desarrollo de otros capítulos de este libro.
__________________________________________________________________________________
Resumen
En este capítulo:
• Vimos las funciones para el manejo de fecha y hora
• Vimos las funciones para la manipulación de cadenas
• Vimos las funciones de decisión
• Se resumieron las funciones trigonométricas y financieras
• Se resumieron funciones derivadas equivalentes
Este capítulo es de referencia, consúltelo conforme lo necesite.








Capítulo
9
Procedimientos
y funciones definidas
por el usuario
Objetivo
Conocer las diferentes formas de procedimientos que se pueden utilizar en Visual Basic,
lo que permitirá la reutilización de código, la modularización de las tareas y la creación
de funciones definidas por el usuario.
Al finalizar este capítulo deberá:
• Conocer qué son los procedimientos y cómo los puede agregar a las aplicaciones en
Visual Basic
• Conocer el uso de las instrucciones Sub y Function
• Conocer el proceso de elaboración de procedimientos en Visual Basic
• Saber como elaborar procedimientos que reciban argumentos y que devuelvan valores
• Saber definir funciones que reciban argumentos opcionales y argumentos opcionales
con valor predeterminado
• Saber definir funciones que manejen un número incierto de argumentos
219


















220 Parte 2: Elementos de programación

Procedimientos
Un procedimiento es una secuencia de instrucciones que se ejecuta como una unidad, a
petición, bajo un nombre que identifica dicha secuencia. Por sí mismos, los proce-
dimientos no constituyen un programa formal, sino que operan a manera de soporte con
respecto a un programa que los llama.
Los procedimientos pueden tener los siguientes comportamientos:
• No utilizan argumentos, no devuelven valores
• No utilizan argumentos, devuelven valores
• Utilizan argumentos, no devuelven valores
• Utilizan argumentos, no devuelven valores
Los argumentos, también llamados parámetros, son aquellas expresiones que se le
proporcionan a un procedimiento o instrucción para que realicen una determinada tarea
con base en ellos. En otras palabras, el resultado de la ejecución de un procedimiento
depende de los argumentos que se le proporcionen.
A los procedimientos que devuelven valores, utilicen o no argumentos, por lo general se
les llaman funciones.
==============================================================
Nota: Debido a que los procedimientos y funciones que usted codifique no existen de
manera implícita en Visual Basic, son conocidos como definidos por el usuario. La
expresión Función Definida por el Usuario (UDF) es muy común en la mayoría de los
lenguajes.
Usted puede incluso crear, a través de un módulo BAS, su propia biblioteca de pro-
cedimientos y funciones, aplicando lo que se llama reutilización de código; si conoce la
funcionalidad de su aplicación y los estándares en los que quiere basarse, es una buena
idea programar primero los procedimientos y luego el programa que los utiliza.
==============================================================
Todos los procedimientos que usted agregue en un módulo (formulario) se colocarán en
el área de declaraciones generales de dicho módulo. Si desea editar y definir un
procedimiento definido por usted, tendrá que buscar en la ventana Código, en el cuadro
Objeto, la especificación (General) y en el cuadro Procedimiento/Evento, el nombre
de procedimiento o función con el que haya identificado su código.
==============================================================
Nota: Al compilarse, un procedimiento o función no debe exceder los 64 Kbytes de
tamaño. Si se presenta ese caso, deberá dividir el procedimiento.
==============================================================








Capítulo 9: Procedimientos y funciones definidas por el usuario 221
Ejecución de procedimientos
Una vez definido un procedimiento, éste puede ser ejecutado desde cualquier otro
procedimiento. La forma de invocar a los procedimientos es a través del nombre que lo
identifica, por ejemplo, si tiene un procedimiento que no utiliza argumentos y no
devuelve valores, que se llama CalcTot, la forma de ejecutarlo es la siguiente:
CalcTot
Visual Basic revisa que la palabra no sea una palabra reservada del lenguaje (instruc-
ción o constante), en caso de no reconocer la palabra, revisa si en el módulo que se está
ejecutando existe un procedimiento con ese nombre; si no lo encuentra, buscará en otros
módulos dentro del proyecto y después en módulos o bibliotecas específicas, asociadas
al proyecto. Es posible que para un programador que no conozca mucho el lenguaje
Visual Basic, CalcTot pueda pasar por una instrucción implícita del lenguaje. Usted
puede hacer que su programa sea más claro si agrega la instrucción Call y ejecuta el
procedimiento de ejemplo de la siguiente forma:
Call CalcTot
De esta forma, es fácil saber que se trata de un procedimiento y no de una instrucción
implícita del lenguaje.
También es posible que su procedimiento, al igual que algunas instrucciones de Visual
Basic, utilice argumentos; en ese caso deberá saber si devolverá algún valor o no, a fin
de saber cómo ejecutarlo. Si no devuelve algún valor, puede invocarlo como
procedimiento normal, con los argumentos separados por comas.
MsgBox "¡ Bienvenido !", vbinformation
Por otro lado, si el procedimiento o instrucción, devuelve un valor, es necesario que los
argumentos estén encerrados entre paréntesis después del nombre de dicho pro-
cedimiento y éste debe ser utilizado en su carácter de expresión, ya sea como asig-
nación de valor a una variable...
intVariable% = MsgBox("¿Desea continuar?", vbOKCancel)










222 Parte 2: Elementos de programación
... o bien, como expresión utilizada por otra instrucción:

if MsgBox("¿Desea continuar?", vbOKCancel) = vbOK Then
End
End If
==============================================================
Nota: Si el valor devuelto por un procedimiento o función es asignado a una variable de
memoria, asegúrese de que el tipo de datos del valor devuelto corresponda al tipo de
datos de la variable a la que se asigna. De otra forma, puede haber inexactitudes y
pérdida de información, o bien, puede sobrevenir un error.
==============================================================

Cómo agregar procedimientos en Visual Basic
Para agregar un procedimiento en Visual Basic debe seguir los pasos que se describen a
continuación:
1. Determine de manera precisa qué quiere hacer con el procedimiento.
2. Determine si el resultado del procedimiento depende de un valor desconocido en
tiempo de diseño.
3. En caso de que en tiempo de diseño dependa de valores desconocidos, determine
cuántos valores se ocuparán y de qué tipo de datos se trata.
4. Determine si el resultado esperado es determinar un valor o realizar una tarea. Si es
una tarea, es muy probable que no requiera devolver valores. Si es un valor, es muy
probable que requiera devolver un tipo de datos específico.
5. Determine si el procedimiento es útil para uno o varios módulos, dentro del proyecto
(un proyecto en Visual Basic puede contener varios módulos o formularios).
6. Determine un nombre descriptivo para su procedimiento; debe ser un nombre válido
y que no cause conflicto con palabras reservadas y funciones ya existentes en Visual
Basic. El nombre debe comenzar con una letra, no debe contener espacios ni
caracteres reservados y no debe exceder los 255 caracteres.
7. Abra la ventana Código.
8. Vaya al menú Herramientas - Agregar procedimiento. Llene el cuadro de diálogo
Agregar procedimiento (vea la figura 9.1) ...









Capítulo 9: Procedimientos y fundones definidas por el usuario 223


.. .de acuerdo a la información que se muestra en la siguiente tabla:



1. Defina, en caso de que aplique, el número y tipo de datos de los argumentos que se
requieren, así como el tipo de datos del valor de devolución.
2. Codifique la tarea a realizar.







224 Parte 2: Elementos de programación
Procedimientos que no utilizan argumentos
y no devuelven valores
Son la categoría más simple de los procedimientos; históricamente eran llamados
"subrutinas" y tenían por objeto separar el código en porciones identificadas, con el fin
de no congestionar los programas, dándoles mayor modularidad. Este tipo de pro-
cedimientos es muy útil, sobre todo para la reutilización de código cuando una misma
cosa se hace repetidas veces; en esencia se utilizan para desarrollar una tarea específica
y no proporcionan información que sea requerida en procesos futuros.
>> Creación de un procedimiento. [09.01]
A continuación aprenderá a definir procedimientos que realizan una tarea y no
devuelven valores.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
2. Abra la ventana Código (F7).
3. Vaya al menú Herramientas - Agregar procedimiento. En el cuadro Nombre
coloque NoRecibeNoDevuelve. En Tipo especifique Procedimiento y en Alcance,
Privado. Cuando haga clic en Aceptar, en el área de declaraciones generales, se
agregará el inicio y fin del procedimiento (equivalente al paso 4 de esta práctica).
• Editar código: (General), Evento: NoRecibeNoDevuelve
==============================================================
Nota: Para una mejor comprensión de este capítulo, se incluirán las líneas de inicio y
fin del procedimiento.
==============================================================
Private Sub NoRecibeNoDevuelve()
MsgBox "Función NoRecibeNoDevuelve", vbOKOnly, _
"NoRecibeNoDevuelve"
End Sub

• Editar código: Form, Evento: Activate

Private Sub Form_Activate()
Call NoRecibeNoDevuelve
End Sub







Capítulo 9: Procedimientos y funciones definidas por el usuario 225

Procedimientos que no utilizan argumentos
y sí devuelven valores
Es el tipo de procedimientos que, como parte de la tarea que realizan, generan un valor
de interés para los procesos que han de ser desarrollados posteriormente por la
aplicación. Por el hecho de devolver valores, comúnmente se les conoce como función.
En Visual Basic, para especificar que un procedimiento devuelve valores, se requieren
dos condiciones:
• Que en la línea de inicio del procedimiento se establezca qué tipo de datos es el que se
devolverá (As <TipoDeDatos>).
• Que se asigne el valor a devolver a una variable homónima al procedimiento.
Citemos un ejemplo hipotético: una tienda de venta a crédito vende con cargos diferi-
dos, es decir, usted compra hoy y la tienda no le comienza a cobrar sino transcurridos 90
días. Como en Visual Basic no existe una función implícita cuyo objeto sea devolver
qué fecha será cuando transcurran 90 días a partir de hoy, hay que programar una
función que lo haga. El resultado de dicha función no depende de un valor desconocido,
ya que siempre podemos saber qué fecha es hoy, a partir de la instrucción Now de
Visual Basic, y conocemos el número de días que debemos agregarle para obtener la
fecha que deseamos.
Suponga que sólo utilizará esta función para el módulo en el que se agrega, es decir,
tiene un alcance privado (Private). En virtud de que devolverá un valor, se trata de
una función (Function). Un nombre descriptivo para la función podría ser Ini-
cioCobro. El valor a devolver es de tipo Date/Time y por tal motivo hay que espe-
cificarlo así (As Date). La tarea a realizar es que la función InicioCobro sea igual a
agregar (dateadd) en días ("d") la cantidad de noventa (90) a la fecha de hoy (Now).
La codificación sería la siguiente:
Private Function InicioCobro() As Date
InicioCobro = DateAdd("d", 90, Now)
End Function
Usted podría comprobar de la siguiente forma cómo opera esta función:
Print InicioCobro()

226 Parte 2: Elementos de programación
>> Creación de un procedimiento que no utilice argumentos y devuelva valores.
[09.02]
A continuación aprenderá a definir procedimientos que realizan una tarea, no utilizan
argumentos pero sí devuelven valores. Esta función...
• Desplegará un cuadro de diálogo con el mensaje "Mensaje estático".
• Tiene un botón Aceptar y otro Cancelar.
• En la barra de título dirá "Función SoloDevuelve".
• Esta función devolverá un valor de tipo Integer, correspondiente al botón en el que
se haya hecho clic; es de vital importancia para la práctica que especifique, en la
línea de inicio de definición de la función, que el valor devuelto es de tipo
Integer.
• EÍ ejemplo desplegará en pantalla el valor devuelto.
1. Utilice el mismo proyecto que utilizó para la práctica 09.01.
2. Abra la ventana Código (F7).
3. Vaya al menú Herramientas - Agregar procedimiento. En el cuadro Nombre
coloque SoloDevuelve. En Tipo especifique Función; y en Alcance, Privado.
• Editar código: (General), Evento: SoloDevuelve.
Private Function SoloDevuelve() As Integer
SoloDevuelve = MsgBox("Mensaje estático", vbOKCancel,
"Función SoloDevuelve")
End Function
• Modificar código: Form, Evento: Activate.
Private Sub Form_Activate()
Call NoRecibeNoDevuelve()
Dim intRespuesta as Integer
intRespuesta%= SoloDevuelve()
Print IntRespuesta%
End Sub








Capítulo 9: Procedimientos y funciones definidas por el usuario 227

Procedimientos que utilizan argumentos
Es el tipo de procedimientos que, como parte de la tarea que realizan, generan o no un
valor de interés para los procesos que han de ser desarrollados posteriormente por la
aplicación , pero que la tarea que desempeñan depende de un valor desconocido,
cambiante, que varía según se requiera y que es proporcionado en forma de argumento.
En Visual Basic, para especificar que un procedimiento acepta argumentos, se requieren
cinco condiciones:
• Saber cuántos argumentos se necesitan.
• Saber el tipo de datos de cada argumento.
• Saber si los argumentos son opcionales.
• Saber si los argumentos tienen un valor predeterminado.
• Que en la línea de inicio del procedimiento se establezcan, entre paréntesis, separados
por comas, después del nombre de la función y antes de la especificación del tipo de
datos del valor de devolución, los argumentos que utilizará la función.
Volvamos con el ejemplo de la fecha después de 90 días. ¿Qué pasaría si el cálculo no
fuera a partir del día de hoy, sino de cualquier fecha dada? Al momento de desarrollar
la aplicación, obviamente no sabemos qué fechas serán proporcionadas para el cálculo.
Tendríamos que especificarle a Visual Basic que se requiere un argumento para pro-
porcionarle a la función una fecha dada (FechaDada), que será un dato de tipo
Date/Time y que usaremos en lugar de Now, que anteriormente veníamos utilizando.
La codificación seria la siguiente:
Private Function InicioCobro(FechaDada as Date) As Date
InicioCobro = DateAdd("d", 90, FechaDada)
End Function
Usted podría comprobar de la siguiente forma cómo opera esta función:
Print InicioCobro(#0l/01/2000#)
Para cada argumento definido, deberá especificar el nombre de dicho argumento y el
tipo de datos que le corresponde.










228 Parte 2: Elementos de programación
====================================================
Lo inesperado: Cuando trabaja con funciones, los errores más comunes son:
• Se esperaba ")", "(" (error de compilación). Sucede cuando se deja inconcluso el
llamado a una función, por ejemplo, no colocar paréntesis para encerrar los
argumentos, abrir paréntesis y no cerrarlos, cerrar paréntesis que no se abrieron o
colocar más argumentos de los que acepta la función. Soluciones: verifique que
todos los argumentos se encuentren entre paréntesis, que los paréntesis estén
debidamente abiertos y cerrados y que sólo se coloquen como máximo el número de
argumentos que la función acepta.
• Se esperaba fin de la función (error de compilación). Se presenta cuando no separa
los argumentos con comas y la función desconoce el último de los argumentos como
tal, exigiendo que se elimine. Soluciones: que todos los argumentos estén
debidamente separados por comas.
• No coinciden los tipos (error 13 en tiempo de ejecución). Por lo general, cada
argumento en una función espera un determinado tipo de datos. En el caso de que
proporcione como argumento un tipo de datos diferente al que la función espera (por
ejemplo, proporcionar "hola" a la función chr( ), que espera un dato de tipo
Byte), ésta marcará error. Soluciones: revise la sintaxis de la función y conozca a
qué tipo de datos pertenecen los argumentos, de tal manera que le proporcione a la
función la materia prima adecuada para trabajar.
====================================================

>> Creación de un procedimiento que utilice argumentos y devuelva valores.
[09.03]
A continuación aprenderá a definir procedimientos que realizan una tarea, utilizan
argumentos y devuelven valores. Esta función...
• Desplegará un cuadro de diálogo con un mensaje que usted le proporcione a través de
un argumento llamado Mensaje, que es de tipo String.
• Tendrá un botón Aceptar y otro Cancelar.
• La barra de título deberá decir "Función RecibeDevuelve".
• Esta función devolverá un valor de tipo Integer, correspondiente al botón en el que
se haya hecho clic; es de vital importancia para la práctica que especifique, en la línea
de inicio de definición de la función, que el valor devuelto es de tipo Integer.
También es importante especificar el nombre del argumento y el tipo de k datos que
le corresponde.
• El ejemplo desplegará en pantalla el valor devuelto.








Capítulo 9: Procedimientos y funciones definidas por el usuario 229
1. Utilice el mismo proyecto que utilizó para la práctica 09.01.
2. Abra la ventana Código (F7).
3. Vaya al menú Herramientas - Agregar procedimiento. En el cuadro Nombre
coloque RecibeDevuelve. En Tipo especifique Función; y en Alcance, Privado.
• Editar código: (General), Evento: RecilbeDevuelve.
Private Function RecibeDevuelve(Mensaje As String) As Integer
RecibeDevuelve = MsgBox(Mensaje, vbOKCancel + _
vbQuestion, "Función RecibeDevuelve")
End Function
• Modificar código: Form, Evento: Activate.
Private Sub Form_Activate()
Call NoRecibeNoDevuelve
Dim intRespuesta as Integer
intRespuesta% = SoloDevuelve()
Print intRespuesta%
IntRespuesta% = RecibeDevuelve("Función con argumentos")
Print intRespuesta%
End Sub

Especificación de argumentos opcionales
En ocasiones los argumentos que se les proporcionan una función son opcionales. Para
indicarle a Visual Basic que un argumento es opcional, es necesario colocar la palabra
Optional antes del nombre del argumento, al momento de declararlo. Aunque quizá
sobre decirlo, los argumentos opcionales deberán ser preferentemente los que se
encuentren más a la derecha o bien, todos.
Al momento de darle opcionalidad a un argumento, es necesario controlar lo que
sucederá cuando dicho argumento no se proporcione, ya que puede sobrevenir un error
por la falta del valor.
Volviendo al ejemplo de la fecha después de 90 días, ¿qué pasaría si el cálculo no fuera
necesariamente a partir del día de hoy? En otras palabras, el cálculo puede hacerse a
partir de cualquier fecha dada, pero en el caso de que no se proporcione una





230 Parte 2: Elementos de programación
fecha determinada, se desea que la función tome para el cálculo la fecha correspon-
diente al día de hoy (Now).
El primer problema que se presenta es saber si se proporcionó valor o no al argumento.
Para ello Visual Basic cuenta con una función, denominada IsMissing.
Sintaxis:
IsMissing {NombreArgumento)
NombreArgumento es el argumento que desea evaluar. Si no se proporcionó valor al
argumento NombreArgumento, la función devolverá True; de lo contrario, devolverá
False.
El segundo problema radica en que la función IsMissing trabaja sobre el bit
marcador de omisión, que los tipos de datos estándar, no poseen como Integer o
Double; si su argumento es de un tipo de datos que no posee bit de falta, IsMissing
no funciona. La ventaja es que los datos de tipo Variant sí poseen dicho bit, y a
través de conversiones de datos, puede darse la funcionalidad que se requiere.
La codificación, considerando todos los problemas posibles, sería la siguiente:
Private Function InicioCobro(Optional FechaDada As Variant) As Date
Dim dtmFecha As Date
If IsMissing(FechaDada) Then
dtmFecha = Now
Else
dtmFecha = CDate(FechaDada)
End If
InicioCobro = DateAdd("d", 90, dtmFecha)
End Function
Observe que el argumento FechaDada como opcional (Optional), pero ya no de
tipo Date/Time, sino de tipo Variant. Se declara una variable de tipo
Date/Time, llamada dtmFecha, que tomará el papel del argumento,
Como FechaDada es de tipo Variant, puede evaluarse a través de la función
IsMissing; si no se proporcionó FechaDada, dtmFecha valdrá la fecha del día de
hoy. Por el contrario, si se proporcionó FechaDada, dtmFecha valdrá la conversión
a Date/Time de lo que se haya proporcionado en el argumento.
Sea cual sea el caso, en este momento ya tendríamos una fecha sobre la cual realizar el
cálculo (dtmFecha). Se devolverá la fecha que posea dtmFecha, más 90 días.
Usted podría comprobar de la siguiente forma cómo opera esta función:










Capítulo 9: Procedimientos y fundones definidas por el usuario 231
Print InicioCobro(#01/01/2000#)
Print InicioCobro()
Este ejemplo funcionará, independientemente de si proporciona el argumento o no.
>> Creación de un procedimiento que utilice argumentos opcionales y devuelva va-
lores. [09.04]
A continuación aprenderá a definir procedimientos que realizan una tarea, utilizan
argumentos opcionales y devuelven valores. Esta función ...
• Desplegará un cuadro de diálogo con un mensaje que usted le proporcione a través de
un argumento llamado Mensaje, que es de tipo Variant (para poder utilizar
isMissing) y que es opcional.
• Tendrá un botón Aceptar y otro Cancelar.
• La barra de título dirá "Función DatoOpcional".
• En caso de que usted omita el argumento Mensaje, se tomará de manera prede-
terminada el mensaje "Proceso realizado".
• Esta función devolverá un valor de tipo Integer, correspondiente al botón en el que
se haya hecho clic.
• El ejemplo desplegará en pantalla el valor devuelto.
1. Utilice el mismo proyecto que utilizó para la práctica 09.01.
2. Abra la ventana Código (F7).
3. Vaya al menú Herramientas - Agregar procedimiento. En el cuadro Nombre coloque
DatoOpcional. En Tipo especifique Función; y en Alcance, Privado.
• Editar código: (General), Evento: DatoOpcional
Private Function DatoOpcional(Optional Mensaje As Variant) As Integer
Dim strMensaje As String
If IsMissing(Mensaje) Then
strMensaje$ = "Proceso realizado"
Else
strMensaje$ = Mensaje
End If







232 Parte 2: Elementos de programación
DatoOpcional = MsgBox(strMensaje$, vbOKCancel,
"Función DatoOpcional")
End Function
• Modificar código: Form, Evento: Activate.
Private Sub Form_Activate()
Call NoRecibeNoDevuelve
Dim intRespuesta as Integer
IntRespuesta% = SoloDevuelve()
Print intRespuesta%
intRespuesta% = RecibeDevuelve("Función con argumentos")
Print intRespuesta%
IntRespuesta% = Dato0pcional("Mensaje opcional proporcionado")
Print intRespuesta%
IntRespuesta% = Dato0pcional()
Print intRespuesta%
End Sub

Valores predeterminados para argumentos opcionales
Como vio, puede resultar un poco laborioso manejar la validez de los argumentos
opcionales, garantizándoles un valor. Visual Basic proporciona una posibilidad que
puede ahorrarle el manejo de datos tipo Variant y la evaluación de datos en las fun-
ciones a través de IsMissing. Si desea que al momento en que se omita un argumen-
to, éste asuma un valor predeterminado, sólo necesita igualar, después del tipo de datos
del argumento, al valor deseado.
Simplificando el ejemplo de los 90 días con esta característica, quedaría de la siguiente
manera:
Private Function lnicioCobro(Optional FechaDada As Date = Now) As Date
InicioCobro = DateAdd("d", 90, FechaDada)
End Function
Con esto se elimina el uso de IsMissing. De paso también se elimina el uso de datos
tipo Variant, que entre otras bellezas, consumen más memoria que ningún otro tipo
de datos.







Capítulo 9: Procedimientos y funciones definidas por el usuario 233
>> Creación de un procedimiento que utilice argumentos opcionales con valor pre-
determinado y devuelva valores. [09.05]
A continuación aprenderá a definir procedimientos que realizan una tarea, utilizan
argumentos opcionales con valor predeterminado y devuelven valores. Esta función ...
• Desplegará un cuadro de diálogo con un mensaje que usted le proporcione a través de
un argumento llamado Mensaje, que es de tipo String y es opcional.
• Tendrá un botón Aceptar y otro Cancelar.
• La barra de título dirá "Función DatoOpcional".
• En caso de que usted omita el argumento Mensaje, se tomará de manera prede-
terminada el mensaje "Proceso realizado".
• Esta función devolverá un valor de tipo Integer, correspondiente al botón en el que
se haya hecho clic.
• El ejemplo desplegará en pantalla el valor devuelto.
1. Utilice el mismo proyecto que utilizó para la práctica 09.01.
2. Abra la ventana Código (F7).
• Modificar código: (General), Evento: DatoQpcional.
Private Function Dato0pcional(0ptional Mensaje _
As String = "Proceso realizado") As Integer
DatoOpcional = MsgBox(Mensaje, vbOKCancel, _
"Función DatoOpcional")
End Function

Funciones con número incierto de argumentos
Hasta el momento hemos trabajado con procedimientos y funciones que reciben un
número determinado y conocido de argumentos. Esto no siempre sucede. ¿Qué pasaría
si necesitáramos una función que indicara cuál es el número mayor de una serie?
Como puede ver, la redacción no nos revela cuántos números componen la serie, ¿es
una serie de tres números, de diez, de cien? Tal vez alguien piense que una función con
un número elevado de argumentos opcionales, que en caso de no ser utilizados no
figuren en el cálculo, pudiera ser la solución, sin embargo no es lo óptimo, ya que









234 Parte 2: Elementos de programación
tarde o temprano podríamos llegar a sobrepasar el número de argumentos definidos, y
por otro lado, en caso de no hacerlo, malgastaríamos recursos.
Visual Basic permite manipular esa situación a través de una especificación de argu-
mento de tipo ParamArray .
ParamArray permite definir un arreglo de argumentos de número no específico. Al
utilizar esta especificación, se genera una colección de valores de tipo Variant, iden-
tificados por un nombre determinado.
Si conociéramos el número de elementos de la matriz, sería fácil examinar los
elementos a través de un For Next; sin embargo, debido a que no conocemos el
número de los elementos que integran la colección, podemos recurrir a la instrucción
For Each, que permite revisar los elementos de una colección determinada.
Sintaxis:
For Each NombreDadoAlElemento in Colección
' Proceso que usa la ocurrencia de NombreDadoAlElemento
Next NombreDadoAlElemento
Por ejemplo, si tiene una colección llamada SerieDeLetras y desea examinar la
colección utilizando For Each con una variable de trabajo llamada Letra, Tendría
lo siguiente:
Suponga que SerieDeLetras es igual a "A", "B", "C", "F", "X".
For Each Letra In SerieDeLetras
Print "Elemento actual:" &Letra
Next Letra
Produciría el siguiente resultado:

Elemento actual: A
Elemento actual: B
Elemento actual: C
Elemento actual: F
Elemento actual: X
====================================================
Nota: ParamArray es una forma simplificada de decir Parameters Array, o Array
of parameters. Recuerde que parámetros y argumentos son sinónimos, de tal forma que
ParamArray hace referencia a una matriz, de argumentos.
====================================================




Capítulo 9: Procedimientos y fundones definidas por el usuario 235
Por ejemplo, para determinar cuál es el número mayor de una serie proporcionada a una
función con un número de argumentos desconocido, podríamos utilizar la siguiente
función, llamada NumeroMayor.
Private Function NumeroMayor(ParamArray SerieNumeros()) As Integer
Dim intResultado As Integer
Dim Numero As Variant
For Each Numero In SerieNumeros
If Numero > intResultado% Then
IntResultado% = Numero
End If
Next Numero
NumeroMayor = intResultado%
End Function
La especificación ParamArray SerieNumeros() le dice a Visual Basic que habrá
una matriz de argumentos llamada SerieNumeros, que constituye una colección.
Se declaran variables de trabajo, una para almacenar el resultado del proceso
(intResultado) y otra para poder manejar cada uno de los elementos de la
colección (Numero).
La instrucción For Each podría leerse de la siguiente forma: explora, uno por uno
(For Each), los elementos contenidos en la colección SerieNumeros (In
SerieNumeros) y asígnalos a la variable Numero. Si Numero es mayor a lo que con-
tiene intResultado, entonces intResultado toma el valor de Numero. Sigue
con el próximo elemento de la colección (Next Numero).
Usted podría comprobar de la siguiente forma cómo opera esta función:
Print NumeroMayor(1, 34, 29, 343, 74, 540)
Print NumeroMayor(1000, 300, 892)
La función opera tanto para 6 como para 3 argumentes.







236 Parte 2: Elementos de programación
>> Creación de un procedimiento que utilice un número de argumentos incierto.
[09.06]
A continuación aprenderá a definir procedimientos que realizan una tarea, utilizan Una
cantidad de argumentos incierta y devuelven valores. Esta función ...
• Desplegará un cuadro de diálogo con un mensaje de varias líneas; deberá especificar
cada una de las líneas del mensaje como un dato String, separado por comas.
• Los valores proporcionados como argumento pasarán a formar parte de una colección
llamada Lineas; se utilizará una variable de trabajo llamada Argumento, que
auxiliará la exploración de cada elemento de la colección.
• A medida que se exploren los elementos de la colección, se irá construyendo, en una
variable llamada Mensaje (de tipo String), un texto con los valores de los
argumentos, más los caracteres 10 y 13, que permitirán el salto entre líneas al utilizar
finalmente la instrucción MsgBox.
• Tendrá un botón Aceptar y otro Cancelar,
• La barra de título dirá "Multilínea".
• Esta función devolverá un valor de tipo Integer, correspondiente al botón en el que
se haya hecho clic.
• El ejemplo desplegará en pantalla el valor devuelto.
1. Utilice el mismo proyecto que utilizó para la práctica 09.01,
2. Abra la ventana Código (F7).
3. Vaya al menú Herramientas - Agregar procedimiento. En el cuadro Nombre
coloque Multilinea. En Tipo especifique Función; y en Alcance, Privado.
• Editar código: (General), Evento: Multilinea.
Private Function MultiLinea(ParamArray Lineas()) As Integer
Dim Mensaje As String
Dim Argumento As Variant
For Each Argumento In Lineas
Mensaje$ = Mensaje$ & Argumento & Chr(10) & Chr(13)
Next Argumento









Capítulo 9: Procedimientos y fundones definidas por el usuario 237
MultiLinea = MsgBox(Mensaje$, vbOKCancel, "Multilinea")
End Function
• Modificar código: Form, Evento: Activate.
Private Sub Form_Activate()
Call NoRecibeNoDevuelve
Dim intRespuesta as Integer
intRespuesta% = SoloDevuelve()
Print intRespuesta%
intRespuesta% = RecibeDevuelve("Función con argumentos")
Print intRespuesta%
IntRespuesta% = Dato0pcional("Mensaje opcional proporcionado")
Print intRespuesta%
IntRespuesta% = DatoOpcional()
Print intRespuesta%
Print MultiLinea("No olvide", "- Guardar su trabajo", "- Salir")
Print MultiLinea("A", "B", "C", "D", "E", "F")
End Sub

______________________________________________________________________
Resumen
En este capítulo:
• Vimos qué son los procedimientos y funciones, y cuáles son sus comportamientos más
básicos.
• Vimos qué son los argumentos.
• Vimos cómo ejecutar los procedimientos y funciones, con y sin argumentos.
• Vimos cómo definir procedimientos y funciones en un módulo de Visual Basic, que
tienen o no argumentos y que devuelven o no valores.
• Vimos cómo especificar la existencia de procedimientos que tienen argumentos
opcionales.
• Vimos cómo establecer valores predeterminados para argumentos opcionales.






238 Parte 2: Elementos de programación
• Vimos la forma de manejar procedimientos que tienen un número incierto de
argumentos .
• Vimos la utilidad de la función IsMissing y For Each.

Es crucial que haya comprendido todos los puntos anteriormente referidos, ya que son
muy importantes para comprender el resto del libro.


































Parte 3


Controles gráficos
y programación orientada
a eventos
En la parte 1 aprendió que Visual Basic pone a su disposición
muchas herramientas gráficas de desarrollo. En la parte 2 aprendió
los elementos de la codificación en Visual Basic;
ahora, le corresponde adquirir maestría en el uso de las carac-
terísticas visuales que le ofrece la plataforma de desarrollo.
Aprenderá a desarrollar en un enfoque orientado a eventos, trabajará
con propiedades, métodos y objetos, y comenzará a explorar las
enormes posibilidades de Visual Basic. Prácticamente podrá
desarrollar cualquier interfaz que se le ocurra, preparándose para la
parte 4, en donde manejará con eficiencia archivos y bases de datos.
Verá cómo recibir datos a través de una interfaz y cómo validar que
esos datos sean correctos, podrá manipular gráficos, listas
desplegables, botones de opción y botones de comando, leer
directorios y unidades de disco, manejar el Portapapeles, crear
menús estilo Windows, manipular eventos clásicos del entorno como
el de arrastrar y colocar, en fin, en esta parte se divertirá "dibujando"
el trabajo y obteniendo resultados visibles, más que visuales. I
Desarrollar aplicaciones basadas en Windows en toda la extensión
de la palabra nunca fue tan sencillo. Por supuesto: practicará mucho,
Capítulos:
10,11, 12, 13, 14,15
16,17, 18, 19, 20, 21
Número de prácticas: 51





239


240










































Capítulo
10

Controles básicos
para la introducción
de datos

Objetivo
Conocer el uso de los controles básicos de Visual Basic para la introducción de
datos, analizando sus particularidades y capacidades.
Al finalizar este capítulo deberá:
• Dominar el uso del control CommandButton
• Dominar el uso del control TextBox
• Dominar el uso del control Label
• Saber qué es el enfoque en el entorno de Visual Basic
En la parte 1 conoció los elementos de Visual Basic como entorno de desarrollo. En
la parte 2 aprendió los elementos básicos de la codificación en Visual Basic, es decir,
la parte BASIC de Visual Basic. Ahora le toca descubrir la parte Visual. Aquí es
donde muchos otros libros comienzan: usted comenzará con mucho más camino
recorrido.
241







242 Parte 3: Controles gráficos y programación orientada a eventos
En este capítulo verá los controles básicos de Visual Basic para el desarrollo de
interfaces de introducción de datos. Son tres: Label, TextBox y
CommandButton.

Controles básicos para el acceso de datos
Label
Etiqueta. Sirve para insertar etiquetas en la interfaz. Se utiliza para colocar en la
interfaz el texto que no va a cambiar, aunque también se utiliza para enviar mensajes
contextuales y de apoyo a la captura.
La propiedad esencial de los objetos basados en este control es Caption, ya que re-
presenta lo que se desplegará en la etiqueta; dicha propiedad tiene un límite de 1024
bytes.
Lo más relevante de este control es:

==================================================
==
Nota: Como ya sabe, cuando hace doble clic en un objeto. Visual Basic abre la ven-
tana Código en un procedimiento de evento que considera el más común para dicho
objeto. En la columna Eventos de la tabla de Propiedades - Métodos - Eventos, se
colocará en negritas-itálicas el evento que sea considerado como más frecuente.
==================================================











Capítulo 10: Controles básicos para la introducción de datos 243
TextBox
Cuadro de texto. Se utiliza para obtener información del usuario o para desplegar
información proporcionada por la aplicación.
Este tipo de control es el típico fill in the blank (llenar los espacios); puede utilizarlo
para introducir cualquier tipo de información y posteriormente manipularla.
La propiedad esencial de los objetos basados en este control es Text, ya que re-
presenta lo que contiene el cuadro de texto; dicha propiedad tiene un límite de 64
Kbytes.

==================================================
Nota: Los objetos basados en el control TextBox son los utilizados por excelencia
para la introducción de datos; lo que se captura en ellos es un dato de tipo String, de
ahí que existan funciones para convertir de String a prácticamente cualquier tipo de
datos. Esto sugiere una cosa: casi todo se captura siendo String y se convierte al tipo
de datos que realmente se requiere.

Lo más relevante de este control es:










244 Parte 3: Controles gráficos y programación orientada a eventos
CommandButton
Botón de comando. Se utiliza para procesar una tarea cuando se hace clic en un
botón, llamado por tal motivo, de comando.
El evento más importante para los objetos basados en este control es Click. La pro-
piedad más significativa quizá sea Caption, que contiene el valor del mensaje que
aparecerá en el botón de comando; la propiedad Caption de los botones de
comando tiene un límite de 255 caracteres.
Por convención de Windows, los botones de comando deben estar ubicados en la
parte inferior del formulario, en orientación horizontal; deben estar al centro o a la
derecha del cuerpo principal de la interfaz. En caso de que desee colocarlos con
orientación vertical, deberá procurar su colocación a la derecha.
Lo más relevante de este control es:

Los objetos basados en el control CommandButton son especiales en el sentido de
que les puede proporcionar características inherentes a las aplicaciones de Windows.
Por ejemplo, puede especificar que un botón tenga una respuesta determinada cuando
se presione Intro (Default) o bien cuando se presione la tecla Escape (Cancel).
En tiempo de ejecución, puede seleccionar un botón de comando mediante el ratón o
el teclado, como se indica a continuación:
• Utilice el ratón para hacer che en el botón.
• Mediante el uso de la tecla TAB, ubiqúese en el botón y después elija el botón con
la tecla Barra espadadora o la tecla Intro.
• Presione la tecla de método abreviado (Alt+<letra subrayada>) del botón de
comando.
• Si éste es el botón de comando predeterminado del formulario, el botón se elige
con Intro, incluso si usted está ubicado en otro objeto.







Capítulo 10: Controles básicos para la introducción de datos 245
• Si el botón de comando Cancelar es el botón predeterminado del formulario, se
puede elegir con la tecla Escape, incluso si usted está ubicado en otro objeto.
>> Uso de objetos basados en los controles Label, TextBox y CommandButton.
[10.01]
frmInfoGen.frm
A continuación aprenderá a agregar objetos en un formulario y modificar
propiedades en modo de ejecución.
Implementación visual


==================================================
Tip: En la práctica se requieren 12 objetos: 1 Form, 4 Label, 4 TextBox y 3
CommandButton. Recuerde que Windows puede controlar el cursor a través del
uso de la tecla Tab (más adelante le daremos una explicación desde otro enfoque). Le
recomendamos que primero agregue los objetos estáticos (Label) y que agregue los
objetos en el orden en que desee que el control del programa transcurra (TextBox,
CommandButton).
==================================================




246 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmInfoGen















Capítulo 10: Controles básicos para la introducción de datos 247
Propiedades nuevas en frmInfoGen

Codificación de frmInfoGen
• Editar código: cmdLimpiar, Evento: Click.
txtNombre.Text = ""
txtDireccion.Text = ""
txtTelefono.Text = ""
txtOcupacion.Text = ""
• Editar código: cmdAceptar, Evento: Click.
MsgBox "¡Datos aceptados!", vbOKOnly, "Mensaje del sistema"
• Editar código: cmdSalir, Evento: Click.
End

==================================================
Lo inesperado: Cuando trabaja con funciones, los errores más comunes son:
• Se requiere un objeto (error 424 en tiempo de ejecución). Sucede cuando hace
referencia a un objeto que no existe. Generalmente se debe a que no ha creado el
objeto al que está haciendo referencia, a que cometió un error al teclear el nombre
de un objeto ya definido, o bien a que asume que ya le asignó un nombre a un
objeto, cuando realmente mantiene un nombre diferente (por lo general, el asig-
nado de manera predeterminada por Visual Basic). Soluciones: verifique los
nombres que tienen asignados los objetos; si utiliza un nombre de objeto, ase-
gúrese de que éste existe. Los problemas se pueden evitar de manera sencilla: si al
estar editando el código, el editor no muestra el cuadro de lista combinado de su-
gerencias (vea la figura 4.8), el objeto no está siendo reconocido.








248 Parte 3: Controles gráficos y programación orientada a eventos
• No se encontró el método o el dato miembro (error de compilación). Se presenta
cuando se invoca un método o un dato miembro que no está disponible para un
determinado control. Por ejemplo, los objetos basados en Label no tienen
disponible el método GotFocus, por lo cual si se invoca, marcará error. Solu-
ciones: verifique qué tipo de objetos se agregaron a la interfaz, es decir, en qué
controles están basados. Dependiendo del tipo de control tomado como base, se
tendrán disponibles ciertos métodos y propiedades reconocidos por la clase.
Revise que el método o propiedad que esté utilizando esté disponible para su
objeto. Los problemas se pueden evitar de manera sencilla: si al estar editando el
código el editor no muestra en el cuadro combinado de sugerencias (vea la figura
4.8) la propiedad o método, es que no está disponible para el objeto.
• Uso no válido de una propiedad (error de compilación). Las propiedades son
especificaciones de un objeto, no tareas. En el código, una propiedad puede ser
invocada como una expresión, es decir, tiene que formar parte de una sentencia
de asignación, ya sea como valor asignado o como receptora de un valor. Solu-
ciones: una propiedad siempre debe ser igual a algo o bien algo debe ser igual a
la propiedad o expresión que la utilice. Label1.Caption como línea de
código es incorrecto, Label1.Caption="Algo" es correcto (asignación de
propiedad), strVariable$=Label1.Caption también es correcto (uso de
propiedad como valor).
==================================================

Ejecución
• Introduzca sus datos en el formulario.
• Haga clic en el botón de comando Limpiar.
• El procedimiento cmdLimpiar_Click asignará a la propiedad Text de todos
los cuadros de texto el valor de nada ("") representado con la apertura y el cierre de
comillas sin nada en medio. Dará la apariencia de que se borra lo que ya tenía
escrito, cuando realmente lo que sucede es que lo que usted tenga en los cuadros
de texto se sustituye por una ausencia de valor "". Como dicen, para borrar una
hoja escrita puede eliminar el contenido o bien pintarla de blanco con corrector.
Esto último es lo que más se asemeja a lo que hicimos.
• Haga clic en el botón de comando Aceptar.
• El procedimiento cmdAceptar_Click enviará un mensaje de notificación que dirá
que los datos han sido aceptados.
• Haga clic en el botón de comando Salir.








Capítulo 10: Controles básicos para la introducción de datos 249
• El procedimiento cmdSallr_Cllck sólo contiene la instrucción End, que da
por terminada la sesión de trabajo.


Enfoque

Usted ha utilizado el entorno de Windows y seguramente sabe que la tecla Tab sirve
para pasar el control de un objeto a otro dentro de un cuadro de diálogo. Sabrá que
un objeto determinado posee el control porque seguramente sobre él estará un indi-
cador de cursor, una pequeña variante que lo distingue: en el caso de algunos objetos
como los cuadros de texto, sabrá que poseen el control cuando tenga una línea
delgada y vertical parpadeando en la zona de edición del mismo; en el caso de los
botones, se encontrarán bordeados por una línea obscura que los demás objetos no
tendrán.

==================================================
Nota: En la explicación del enfoque, decimos que el "control" se traslada de un
objeto a otro. No caiga en contradicción de términos. Aquí nos referimos a control
como la facultad que tiene usted de utilizar un determinado objeto; usted controla lo
que sucede. Al decir control, al menos en esta parte, no nos referimos al control
como sustantivo (representaciones gráficas que se encuentran en el Cuadro de
herramientas), sino a la facultad de disponer.
==================================================
A ese control que se traslada de un objeto a otro, en Visual Basic se le llama
enfoque. El enfoque puede definirse como el estado en el que un objeto dentro de la
interfaz puede responder de manera directa al teclado. Por supuesto, los objetos
pueden responder a otros dispositivos de entrada, tales como el ratón, lectores de
código de barras, etcétera, pero la característica definitiva que indica si un objeto
posee o no el enfoque es que pueda responder al teclado.
Si usted escribe algo o presiona alguna tecla, lo que haga se manifestará en el objeto
que tenga el enfoque. Hay ciertos objetos, como los basados en el control Label o
en el control PictureBox, que no responden de ninguna manera al teclado. Esto
es importante porque determina que existen objetos que pueden obtener el enfoque y
otros que no.
En caso de que en un formulario exista al menos un objeto que sea capaz de obtener
el enfoque (es decir, que pueda responder al teclado), existirá un objeto que tenga el
enfoque; al presionar la tecla Tab, el enfoque se trasladará al siguiente objeto capaz
de obtenerlo, siguiendo un orden o secuencia predeterminada. Al hecho de trasladar
el enfoque entre los objetos mediante el uso continuo de la tecla Tab se le llama
tabulación y al orden predefinido en el que los objetos obtendrán el enfoque se le
llama






250 Parte 3: Controles gráficos y programación orientada a eventos
secuencia de tabulación. Cuando en la secuencia de tabulación se llega al último
objeto que pueda obtener el enfoque, el enfoque se trasladará al primer objeto que lo
pueda tener, formando un ciclo ininterrumpido.
Todos los objetos que puedan tener el enfoque, también tendrán una propiedad lla-
mada Tabindex, que determina su posición dentro de la secuencia de tabulación;
la propiedad Tabindex siempre comienza su valor de cero y la poseen todos los
objetos, sin importar si pueden o no adquirir el enfoque. Si desea que algún objeto
no sea considerado en la secuencia de tabulación, puede utilizar la propiedad
TabStop: si dicha propiedad tiene el valor False, el objeto no será considerado en
la secuencia de tabulación. No obstante, el objeto sí puede obtener el enfoque, ya sea
haciendo clic en él o mediante programación.
Nota: En caso de que no desee que el objeto obtenga el enfoque dentro de la
secuencia de tabulación, puede utilizar la propiedad Enabled con un valor False.
Esta solución es un poco extrema si lo que desea es simplemente que no sea
considerada en la secuencia de tabulación, ya que no podrá obtener el enfoque en el
uso de la interfaz.
Cuando un objeto no tiene el enfoque y luego lo obtiene, se dice que adquiere el
enfoque;
si un objeto tiene el enfoque y luego deja de tenerlo, se dice que pierde el enfoque.
En Visual Basic, todos los objetos que pueden tener el enfoque, por esa simple
capacidad, tendrán dos procedimientos de evento, llamados GotFocus para cuando
obtienen el enfoque y LostFocus para cuando lo pierden. Adicionalmente,
tendrán un método llamado SetFocus, que le proporciona el enfoque al objeto
determinado.






Capítulo 10: Controles básicos para la introducción de datos 251
El orden de la propiedad TabIndex se asigna al momento de la creación de los obje-
tos, por lo cual es una buena idea que una vez que conoce los objetos que necesita su
interfaz, los agregue en el orden en que desea que se establezca la secuencia de
tabulación. Si usted es de las personas que agrega los objetos de manera sistemática
de acuerdo con el control en que están basados (primero todos los Label, luego
todos los TextBox, luego los CommandButton, etcétera) reconsidere si ello le es
útil.
===================================================
Nota: En este libro, los ejemplos tienen su tabla de objetos; el orden en que se
refieren corresponde a la secuencia de tabulación, que casualmente corresponde a un
esquema en donde todos los objetos basados en el mismo tipo de control se agregan
juntos. No es la intención sugerir que así lo haga siempre; de hecho, en ejemplos
futuros esa aparente secuencia por tipo de control no se presentará.
===================================================
>> Uso de botones predefinidos de aceptación y cancelación y cuadros de texto mul-
tilíneas, de capacidad limitada. [10.02]
frmNota.frm
A continuación aprenderá a especificar botones de comando que se activen al presio-
nar Intro o la tecla Escape, a preparar un cuadro de texto para que soporte múltiples
líneas y un máximo de contenido determinado y manejar la selección del contenido de
los cuadros de texto.
===================================================
Nota: En la ejecución de los ejercicios de este libro se seguirá un proceso paulatino
de identificación con respecto a los objetos. De inicio se sugerirá "haga clic en el
botón de comando Aceptar", posteriormente se pondrá "haga clic en el botón de
comando cmdAceptar" y finalmente se indicará "haga clic en cmdAceptar".
Como puede darse cuenta, el primer enfoque es más apropiado para un usuario de la
aplicación que para un desarrollador, el segundo enfoque ya es un poco más identifi-
cado con el desarrollo, pero su orientación sigue siendo de uso. El tercer enfoque se
adaptará de manera definitiva en el texto, en el momento en el que hablar de objetos
ya sea una práctica común para usted, cuando la función de depuración sea más pre-
ponderante.
===================================================









252 Parte 3: Controles gráficos y programación orientada a eventos
Implementación visual


Tabla de objetos y propiedades de frmNota




Capítulo 10: Controles básicos para la introducción de datos 253


Propiedades nuevas en frmNota









254 Parte 3: Controles gráficos y programación orientada a eventos

Eventos nuevos en frmNota


Codificación de frmNota
• Editar código: cmdAceptar, Evento: Click.
MsgBox "¡Datos aceptados!"
• Editar código: txtAutor, Evento: GotFocus
txtAutor.SelStart = 0
txtAutor.SelLength = 50
• Editar código: txtComentario, Evento: GotFocus.
txtComentario.SelStart = 0
txtComentario.SelLength = 256
• Editar código: txtTitulo, Evento: GotFocus.
txtTitulo.SelStart = 0
txtTitulo. SelLength =100
• Editar código: cmdSalir, Evento: Click.
End




Capítulo 10: Controles básicos para la introducción de datos 255
Ejecución
• Haga clic en el botón de comando Aceptar.
El procedimiento de evento cmdAceptar_Click se ejecutará y aparecerá una
ventana de mensaje producida por la función MsgBox que se colocó en dicho
procedimiento. Haga clic en el botón Aceptar que aparece en dicha ventana. Con
eso usted ya vio lo que debe suceder cuando haga clic en el botón de comando
cmdAceptar.
• Vaya al cuadro de texto donde se debe capturar el Autor; intente escribir más de 50
caracteres.
Al introducir información en el objeto txtAutor nunca podrá exceder el límite
de 50 caracteres, ya que dicho cuadro de texto tiene establecida como longitud
máxima 50 caracteres. Escriba el nombre del autor de un libro que haya leído.
• Vaya al cuadro de texto donde se debe capturar la Reseña (txtComentario);
capture una cantidad considerable de texto, de tal forma que se compruebe que
dicho cuadro de texto permite varias líneas. De preferencia describa el contenido o
tema del libro que está tomando como ejemplo.
• Presione la tecla Tab hasta que el cuadro de texto donde debe capturar el título del
libro (txtTitulo) adquiera el enfoque.
Vea la forma en que se traslada el enfoque entre los objetos.
• Una vez estando en el cuadro de texto donde se debe capturar el Título, intente
escribir más de 100 caracteres.
Al introducir información en el objeto txtTitulo nunca podrá exceder el límite de
100 caracteres, ya que dicho cuadro de texto tiene establecida como longitud
máxima 100 caracteres. Escriba el nombre del título del libro que está tomando
como ejemplo.
• Presione una vez más la tecla Tab, lo que provocará que el enfoque se traslade al
cuadro de texto en donde debe capturar el Autor (txtAutor).
Al trasladar el enfoque al objeto txtAutor, se dice que adquiere el enfoque.
Cuando un objeto adquiere el enfoque, se ejecuta el procedimiento GotFocus que le
pertenece. En este caso, el procedimiento txtAutor_GotFocus especifica que
dentro del contenido del cuadro de texto donde se capturó el nombre del autor
(txtAutor.Text), el Character cero (primer Character) es el determinado como
posición inicial de una selección de caracteres; asimismo, se determina que a partir de
dicha posición inicial, se deben marcar 50 caracteres (que en este caso es la cantidad
máxima de caracteres que se pueden tener).
¿Para qué seleccionar texto?, muy probablemente ya lo ha hecho en muchas
ocasiones, ya que cuando copia (Copy) o corta (Cut) en el entorno de Windows









256 Parte 3: Controles gráficos y programación orientada a eventos
requiere seleccionar antes lo que quiere copiar o cortar. En un cuadro de texto, las
propiedades SelStart y SelLenght permiten hacerlo.
Todos los cuadros de texto del formulario tienen un procedimiento de evento
GotFocus que hace lo mismo que aquí se explica.
• Presione la tecla Intro.
Sucederá lo mismo que cuando hizo clic en el botón de comando Aceptar
(cmdAceptar). Esto se debe a que dicho botón está definido como Default.
• Presione la tecla Escape.
Se ejecutará el procedimiento de evento cmdSalir_Click, ya que dicho botón
está definido como Cancel; presionar Escape equivale a hacer clic en el botón de
comando Salir (cmdSalir).
>>Uso de caracteres para escritura oculta y validación inmediata de caracteres,
asegurando la captura de caracteres en mayúscula. Habilitar e inhabilitar
botones. [10.03]
frmAcceso.frm
A continuación aprenderá a especificar un determinado Character para proteger el
acceso secreto de información, así como manipular la entrada de datos de tal manera
que siempre se introduzcan mayúsculas, independientemente de que tenga activa o no
la tecla Bloq Mayús. Se verá también cómo habilitar e inhabilitar un botón con base
en lo que se tenga capturado en el formulario.
Implementación visual










Capítulo 10: Controles básicos para la introducción de datos 257

===================================================
Nota: Al revisar su código, probablemente detecte que Visual Basic asigna, en el
caso de los cuadros de texto con PasswordChar, una propiedad IMEMode. Esta pro-
piedad es reservada para sistemas de caracteres de Asia y Lejano Oriente; hace esto
previniendo que dentro de su código de acceso (password o contraseña) incluya car-
acteres especiales que de otra forma no sería posible resolver.
===================================================
Tabla de objetos y propiedades de frmAcceso











258 Parte 3: Controles gráficos y programación orientada a eventos




Propiedades nuevas en frmAcceso



Eventos nuevos en frmAcceso

Codificación de frmAcceso
• Editar código: txtUsuario, Evento: LostFocus.

KeyAscii = Asc(UCase(Chr(KeyAscii)))









Capítulo 10: Controles básicos para la introducción de datos 259
La tecla presionada: evento KeyPress
El evento KeyPress detecta la tecla que se presionó y determina qué número de
código ASCII le corresponde, asignándoselo a una palabra reservada llamada
KeyASClI; KeyASCII es la tecla que usted presionó, misma que está viendo
representada gráficamente en su cuadro de texto. La función Chr( ), devuelve el
Character correspondiente a un número de código ASCII, Ucase( ) transforma un
Character a su equivalente en mayúscula y Asc ( ) devuelve el número del código
ASCII correspondiente a un Character dado.
La secuencia de ejecución y valores es la siguiente:
Suponga que presiona la tecla "a":
KeyAscii 97
Chr(KeyAscii) "a"
Ucase("a") "A"
Asc ("A") 65
Entonces:
Asc(Ucase(Chr(KeyAscii))) 65
Es por ello que si teclea la letra "a", el evento KeyPress procesará la información,
transformándola en "A".
Este procedimiento es muy útil, sobre todo cuando desea que en un determinado
cuadro de texto sólo se capturen mayúsculas.
Mediante la manipulación de un dato a través de KeyPress puede restringir el
acceso de datos, por ejemplo, el código para permitir sólo números sería:
Sub txtUsuario_KeyPress(KeyAscii As Integer)
If Not (KeyAscii >= 48 And KeyAscii <= 57) Then
Beep
KeyAscii = 8
End If
End Sub










260 Parte 3: Controles gráficos y programación orientada a eventos
Equivaldría a lo siguiente: si el código ASCII de lo tecleado no está entre 48 y 57
(rango en el que se encuentran los números), emite un Beep y borra lo tecleado (a la
tecla Retroceso le corresponde el número de código ASCII 8)
• Editar código: txtUsuario, Evento: LostFocus.
If txtUsuario.Text = "" Then
MsgBox "No omita el nombre por favor"
cmdSalir.Enabled = False
txtUsuario.SetFocus
Else
cmdSalir.Enabled = True
End If
• Editar código: txtPassword, Evento: LostFocus.
If txtPassword.Text <> "" And txtCPassword.Text <> "" Then
cmdValidar.Enabled = True
cmdValidar.SetFocus
End If
• Editar código: txtCPassword, Evento: LostFocus.
TxtPassword_LostFocus
• Editar código: cmdValidar, Evento: Click.
If txtPassword.Text = txtCPassword.Text Then
MsgBox "Identificación correcta"
End
Else
MsgBox "Los password no concuerdan" s
cmdValidar.Enabled = False
txtPassword.SetFocus
End If
• Editar código: cmdSalir, Evento: Click.
End









Capítulo 10: Controles básicos para la introducción de datos 261
Ejecución
• Al ejecutar la aplicación, el cuadro de texto correspondiente al Usuario tiene el
enfoque. Observe que los botones no están habilitados. Sin introducir ningún
dato presione la tecla Tab.
El procedimiento de evento txtUsuario_LostFocus se ejecutará en virtud
de que el objeto txtUsuario pierde el enfoque. El procedimiento valida que si
el cuadro de texto (txtUsuario.Text) está vacío (es igual a ""), entonces
mediante la instrucción MsgBox desplegará un mensaje que diga "No omita el
nombre por favor". Después de eso se inhabilita el botón de comando Salir
(cmdSalir) y se le proporciona el enfoque al cuadro de texto que no cumplió la
condición (txtUsuario).
Por otro lado, si la condición no se cumple (txtUsuario no es igual a ""), en-
tonces se habilita el botón Salir (cmdSalir)
• Inhabilite la tecla Bloq Mayús; intente escribir, por todos los medios posibles, una
letra minúscula.
Cada vez que presione una tecla, se ejecutará el procedimiento de evento
txtUsuario_KeyPress, que como ya vio en la nota previa, convierte las mi-
núsculas a mayúsculas, por lo que no será posible colocarlas.
• Capture un Password en el cuadro de texto correspondiente. Cuando termine,
presione la tecla Tab para ir al siguiente cuadro de texto.
Cuando capture el password, no se verá lo que está escribiendo porque el cuadro
de texto está protegido; sólo se verá el Character que usted haya definido como
PasswordChar.
En el momento en que salga del cuadro de texto en el que capturó el Password,
dicho cuadro perderá el enfoque y, por tanto, se ejecutará el procedimiento de
evento txtPassword_LostFocus. Dicho procedimiento verifica que el
cuadro de texto Password o el cuadro Confirmar Password ya tengan contenido
(es decir, que txtPassword.Text y txtCPassword.Text sean diferentes
a ""), en cuyo caso habilita el botón de comando Validar (cmdValidar) y le
proporciona el enfoque al mismo tiempo.
• Proceda a confirmar el password.
Cuando salga del cuadro de texto Confirmar Password, se ejecutará el proce-
dimiento txtCPassword_LostFocus, en virtud de que está perdiendo el
enfoque. Aquí sucede algo: resulta que el código a colocar en este procedimiento
es exactamente igual al contenido en el procedimiento
txtPassword_LostFocus, por lo que en lugar de escribir nuevamente todo,
le decimos a Visual Basic que ejecute el procedimiento
txtPassword_LostFocus.









262 Parte 3: Controles gráficos y programación orientada a eventos
• Si capturó el Password y la Confirmación del password, se habilitará el botón de
comando Validar. Al hacer clic en dicho botón se procede a verificar si los
passwords son válidos.
Al hacer clic en el botón de comando Validar (cmdValidar) se ejecutará el pro-
cedimiento de evento cmdValidar_Click. Lo que hace este procedimiento es
que si el contenido de los cuadros de texto Password y Confirmar Password es el
mismo (txtPassword.Text = txtCPassword.Text), entonces envía el
mensaje "Identificación correcta" y cierra la aplicación. En caso de que no
concuerden, se envía el mensaje "Los passwords no concuerdan", se inhabilitará
el botón Validar (cmdValidar) y se trasladará el enfoque al cuadro de texto en
donde se debe capturar el password correctamente.
• Presione la tecla Escape.
Se ejecutará el procedimiento de evento cmdSalir_Click, ya que dicho botón está
definido como Cancel; teclear Escape equivale a hacer clic en el botón de
comando Salir (cmdSalir).

__________________________________________________________________________________
Resumen
En este capítulo:
• Vimos las particularidades del control Label.
• Vimos las particularidades del control TextBox.
• Vimos las particularidades del control CommandButton.
• Vimos en qué consiste el enfoque y cuáles son algunos de los procedimientos y
métodos relativos al manejo del enfoque.
• Vimos cómo a través del procedimiento KeyPress se pueden realizar modifica-
ciones a lo que se captura e incluso restringir la captura.
Es importante que domine el contenido del capítulo para poder continuar, ya que en
el resto del libro se manejarán, de manera intensiva, objetos basados en estos
controles.

















Capítulo
11
Programación
orientada a eventos
Objetivos
Profundizar en el manejo de los eventos en Visual Basic, a fin de poder controlarlos y
utilizarlos para el propósito que persiguen las aplicaciones.
Al finalizar este capítulo deberá:
• Conocer claramente la forma en que se manejan los eventos en Visual Basic
• Conocer algunos eventos asociados a los objetos, con los que se puede controlar el
uso de dispositivos de entrada como el teclado o el ratón
• Entender la forma en que los eventos manejan argumentos implícitos
• Conocerá las prioridades de ejecución de los eventos, para evitar conflictos entre
ellos
• Aprender a mejorar la interfaz utilizando trucos visuales realizados a través de
eventos
263


264 Parte 3: Controles gráficos y programación orientada a eventos

Eventos y su clasificación
Quizá uno de los aspectos más importantes en Visual Basic es su orientación a
eventos. Muchos sostienen que es una herramienta de programación orientada a ob-
jetos; la verdad es que Visual Basic, como herramienta de desarrollo, es orientada a
objetos: puede darse cuenta con sólo ver el entorno de desarrollo. Sin embargo, las
aplicaciones producidas en Visual Basic son otra cosa; si buscamos las especifica-
ciones de herencia, poliformismo y encapsulamiento como fundamento de las apli-
caciones que desarrollamos, nos daremos cuenta que no están presentes a menos de
que usted se dé a la tarea de codificar en ese sentido (cosa que no es fácil).
Más bien, Visual Basic propone un desarrollo orientado a eventos. Usted crea la in-
terfaz agregando objetos a un formulario, cada objeto tendrá sus características (pro-
piedades) y será receptivo a las cosas que pueden sucederle (eventos). En cada evento
puede definirse una secuencia de instrucciones, a la que llamamos procedimiento de
evento. El punto inicial es incluir un objeto en una interfaz y el punto final es agregar
el código a los procedimientos de eventos.
Los eventos que están disponibles para un determinado objeto dependerán de la na-
turaleza del control sobre el que está basado. Por ejemplo, los objetos basados en los
controles Line y Shape no poseen eventos, ya que son elementos estéticos cuya na-
turaleza no es funcionar de cierta forma, sino sólo mostrarse; los objetos basados en
el resto de los controles implícitos de Visual Basic, como lo son TextBox,
CommandButton. Label y demás, sí poseen eventos específicos acordes a su
comportamiento.
Podemos dividir los eventos en diferentes categorías:
• De tipo Clic: relacionados con la interacción del usuario y los objetos a través de
los botones del ratón.
• De tipo Cambios: relacionado con las formas para modificar el valor que posee un
objeto.
• De tipo Enfoque: relacionado con la adquisición o pérdida del enfoque.
• De tipo Drag & Drop: relacionados con la facilidad del entorno gráfico de arras-
trar y colocar (Drag & Drop).
• De tipo Teclado: relacionados con la pulsación de teclas mediante el teclado.
• De tipo Ratón: relacionados con el uso del ratón como dispositivo apuntador.
• De tipo Elementos: relacionado con objetos basados en el control ComboBox y los
estados de sus elementos.
• De tipo Archivos: relacionados con la ubicación de archivos para los objetos
basados en el control FileListBox.








Capítulo 11: Programación orientada a eventos 265
• De tipo Datos: relacionados con el control Data.
• De tipo Dibujo: relacionados con el control PictureBox.
• De tipo Tiempo: relacionado con el objeto temporizador o Timer.
La figura 11.1 muestra un cuadro en donde se relaciona qué tipos de eventos son
viables con qué controles implícitos de Visual Basic. No se incluyen todos los even-
tos posibles para los objetos basados en los controles mencionados, pero sí se rela-
cionan los más importantes.


===================================================
Nota: No se incluyó el control OLE ni los eventos relacionados con OLE; como
supondrá, OLE depende mucho de la aplicación con la que se establezca la liga, lo
que complica abarcar adecuadamente su comportamiento.
===================================================










266 Parte 3: Controles gráficos y programación orientada a eventos
Argumentos implícitos
Al igual que existen algunas funciones que reciben argumentos, hay algunos eventos
que los reciben también. Quizá se pregunte ¿quién le proporciona los argumentos a los
eventos? Es el mismo sistema quien lo hace.
La secuencia que sigue Visual Basic para la ejecución de eventos es la siguiente:
• El usuario realiza algo sobre un objeto que es reconocido como un evento (el evento
ocurre).
• Visual Basic revisa si para ese objeto hay algo codificado para el evento que le
sucedió (procedimiento de evento).
• Si no hay nada codificado, no pasa nada; en caso de que sí existan instrucciones,
Visual Basic revisa si existen argumentos implícitos, para el evento en cuyo caso,
toma los valores que el sistema le proporciona.
• Procede a la ejecución de las instrucciones del procedimiento de evento, en caso de
que aplique.


Resumen de las categorías de eventos, consideradas
de uso general
No todos los eventos se aplican para todos los objetos, sin embargo, de las categorías
que mencionamos, 5 de ellas son prácticamente utilizables para la mayoría de los
objetos, sin importar en qué control estén basados.
Por tal motivo, les llamamos a dichas categorías de uso general. Se trata de las si-
guientes:
• De tipo Clic
• De tipo Cambios
• De tipo Enfoque
• De tipo Teclado
• De tipo Ratón
Las categorías de eventos que no son consideradas de uso general frecuentemente
están orientadas a los objetos basados en un control específico; la totalidad de ellas se
verán en los capítulos que traten de manera particular los controles a los que se
aplican.











Capitulo 11: Programación orientada a eventos 267
Tipo Clic


Ocurre cuando el usuario presiona y suelta un botón del ratón en un objeto. También
puede ocurrir cuando se cambia el valor de un objeto.
Para un objeto Form, este evento ocurre cuando el usuario hace clic en un área en
blanco o en un control desactivado. Para otros objetos, este evento ocurre:
• Cuando hace clic en un objeto con el botón primario o secundario del ratón. Con un
objeto basado en el control CheckBox, CommandButton. ListBox u
OptionButton, el evento Click sólo ocurre cuando el usuario hace clic con el
botón primario del ratón.
• Cuando selecciona un elemento de un objeto basado en el control ComboBox o
ListBox, ya sea presionando las teclas de dirección o haciendo clic con el botón
del ratón.
• Cuando un objeto basado en el control CommandButton, OptionButton o
CheckBox tiene el enfoque y presiona la barra espaciadora.
• Cuando un formulario tiene un objeto basado en el control CommandButton con
su propiedad Default establecida a True y presiona Intro.
• Cuando un formulario tiene un objeto basado en el control CommandButton con
su propiedad Cancel establecida a True y presiona la tecla Escape.
• Cuando presiona una tecla de método abreviado para un objeto. Por ejemplo, si el
título de un objeto basado en el control CommandButton es "&Ir", al presionar
Alt+I se desencadena este evento.
También puede desencadenar el evento Click en tiempo de ejecución:
• Si establece la propiedad Value de un objeto basado en el control
CommandButton a True.
• Si establece la propiedad Value de un objeto basado en el control
OptionButton a True.
• Si cambia el valor de la propiedad Value de un objeto basado en el control
CheckBox.














268 Parte 3: Controles gráficos y programación orientada a eventos

Se produce cuando un usuario presiona y suelta un botón del ratón dos veces sobre un
objeto.
En un formulario, el evento DblClick se produce cuando el usuario hace doble che
en un control deshabilitado o en un área en blanco del mismo. En un objeto, se
produce:
• Cuando se hace doble clic en éste con el botón primario del ratón.
• Cuando se hace doble clic en un elemento de un objeto basado en un control
ComboBox cuya propiedad Style es 1 (Simple) o en un control
FileListBox, ListBox. DataCombo o DataList.
Tipo Cambios

Indica que el contenido de un control ha cambiado. Cómo y cuándo ha ocurrido este
evento varía según el control:
• ComboBox: cambia el contenido del cuadro de texto del control. Ocurre sólo si la
propiedad Style está establecida a 0 (Dropdown Combo) o 1 (Simple
Combo) y el usuario cambia el texto o se cambia el valor de la propiedad Text en
tiempo de ejecución.
• DirListBox: cambia el directorio seleccionado. Ocurre cuando el usuario hace
doble clic en un nuevo directorio o cuando usted cambia el valor de la propiedad
Path en tiempo de ejecución.
• DriveListBox: cambia la unidad seleccionada. Ocurre cuando el usuario selec-
ciona una nueva unidad o cuando usted cambia el valor de la propiedad Drive en
tiempo de ejecución.
• HScrollBar y VScrollBar (barras de desplazamiento horizontal y vertical):
mueven el cuadro de desplazamiento de la barra de desplazamiento. Ocurre
cuando el usuario se desplaza o cuando usted cambia el valor de la propiedad
Value en tiempo de ejecución.
• Label: cambia el contenido del control Label. Ocurre cuando cambia el valor de
la propiedad Caption en tiempo de ejecución.








Capítulo 11: Programación orientada a eventos 269
• PictureBox: cambia el contenido del control PictureBox. Ocurre cuando
cambia el valor de la propiedad Picture en tiempo de ejecución.
• TextBox: cambia el contenido del cuadro de texto. Ocurre cuando un usuario
cambia el texto o cuando usted cambia el valor de la propiedad Text en tiempo de
ejecución.

Ocurre cuando un objeto se muestra primero (de no existir, pasa a existir con un
tamaño) o cuando cambia el estado de una ventana. (Por ejemplo, cuando se maxi-
miza, minimiza o restaura un formulario.)



Ocurre cuando el cuadro de desplazamiento de un ScrollBar o un objeto que con-
tenga una barra de desplazamiento, cambia de posición o se desplaza horizontal o
verticalmente.


Ocurre cuando el enfoque pretende cambiar a otro objeto, siempre y cuando el objeto
tenga su propiedad CausesValidation establecida a True.

El argumento implícito Cancel puede especificarse como True para evitar que el
objeto pierda el enfoque si no ha cumplido con una condición.
Suponga que hay un TextBox llamado txtNombre, que tiene su propiedad
CausesValidation establecida a True. Por ejemplo, si requiere que el usuario no
omita escribir su nombre en un cuadro de texto llamado txtNombre, es decir, que no
pase a otro objeto mientras no escriba algo; el código sería como sigue:











270 Parte 3: Controles gráficos y programación orientada a eventos
Private Sub txtNombre_Validate(Cancel As Boolean)
If txtNombre.Text = "" then
MsgBox "No debe omitir el nombre"
Cancel = True
Else
Cancel = False
End If -
End Sub
Este mismo manejo puede realizarse a través del evento LostFocus, en conjunto
con el método SetFocus. Utilizar Validate es más práctico y puede evitar que
cause un ciclo indefinido en su programa.

===================================================
Nota: Dependiendo de la versión de Visual Basic que disponga, así como el len-
guaje (español, francés, inglés, etcétera), el nombre de los argumentos implícitos
puede variar. Por ejemplo, el argumento Cancel en ocasiones puede llamarse
KeepFocus. Independientemente del caso que se presente, haga referencia al argu-
mento bajo el nombre predeterminado que Visual Basic le asigne automáticamente.
===================================================

Tipo Enfoque

Ocurre cuando un objeto recibe el enfoque, ya sea mediante una acción del usuario,
como utilizar la tecla Tab o hacer clic en el objeto o cambiando el enfoque en tiempo
de ejecución mediante el método SetFocus. Un formulario recibe el enfoque sólo
cuando todos los controles visibles están desactivados.

Ocurre cuando un objeto pierde el enfoque, ya sea por una acción del usuario, como
utilizar la tecla Tab o hacer clic en otro objeto, o bien mediante un cambio del
enfoque en tiempo de ejecución con el método SetFocus.










Capítulo 11: Programación orientada a eventos 271
>> Demostración de algunos de los eventos de tipo Clic, Cambios y Enfoque.
[11.01]
frmEventos1.frm
A continuación aprenderá programación orientada a eventos, utilizando diferentes
eventos implícitos de los objetos basados en los controles Label, TextBox y
CommandButton.
Implementación visual

Tabla de objetos y propiedades de frmEventos1







272 Parte 3; Controles gráficos y programación orientada a eventos

Propiedades nuevas en frmEventos1

Eventos nuevos en frmEventos1











Capítulo 11: Programación orientada a eventos 273
Codificación de frmEventos1
• Editar código: txtCampo1, Evento: Validate
Private Sub txtCampo1_Validate(Cancel As Boolean)
If txtCampol.Text = "" Then
lblAccion.Caption = "No debe omitir el campo 1"
Cancel = True
Else
Cancel = False
End If
End Sub
• Editar código: txtCampo2, Evento: GotFocus
lblAccion.Caption = "El campo 2 adquirió el enfoque"
• Editar código: txtCampo2, Evento: Change.
lblAccion.Caption = "El campo 2 cambió a " & txtCampo2.Text
• Editar código: txtCampo2, Evento: LostFocus.
lblAccion.Caption = "El campo 2 perdió el enfoque"
• Editar código: txtCampo2, Evento: DblClick.
lblAccion.Caption = "Hizo doble clic en la instrucción"

• Editar código: lbllnstruccíones. Evento: Click.
lblAccion.Caption = "Hizo clic en la instrucción"
• Editar código: cmdSalir, Evento: Click.
End






274 Parte 3: Controles gráficos y programación orientada a eventos
Ejecución
• El programa inicia asignándole el enfoque a txtCampol.
• Presione la tecla Tab para trasladar el enfoque a txtCampo2.
Debido a que txtCampo1 tiene establecido el valor True en su propiedad
CausesValidation, Visual Basic buscará si existe un procedimiento de evento
Validate para dicho objeto. En nuestro ejemplo, ese objeto sí posee un proce-
dimiento de evento para validar (txtCampo1_Validate), mismo que ocurre al
intentar que txtCampo1 pierda el enfoque.
El argumento implícito, llamado Cancel, permitirá que el objeto txtCampo1 pierda o
no el enfoque (valores False o True, respectivamente). Si el objeto txtCampo1 no
contiene texto, es decir, si el cuadro de texto está vacío, se enviará el mensaje
correspondiente en el objeto Label agregado para tal efecto (lblAccion) y
establecerá a True el argumento implícito Cancel, para que impida la pérdida del
enfoque. Por el contrario, si ya se capturó algo en el objeto, el argumento tomará el
valor False, con lo que la validación se da por cumplida. Como el programa no le
dejará salir del cuadro de texto hasta que teclee algo en txtCampo1, escriba
"Prueba".
• Presione la tecla Tab para trasladar el enfoque a txtCampo2.
Al hacerse efectivo el traslado del enfoque, txtCampo1 pierde el enfoque, pero
txtCampo2 lo adquiere. Puesto que txtCampo2 adquiere el enfoque, se ejecuta el
procedimiento de evento txtCampo2_GotFocus, desplegando en lblAccion el
mensaje correspondiente.
• En txtCampo2 escriba la palabra "Piensa".
Cada vez que introduce una de las letras de la palabra "Piensa", el texto del objeto
txtCampo2 sufre un cambio, por lo que se ejecuta el procedimiento de evento
txtCampo2_Change en cada modificación. Observe que lblAccion se actualiza
con cada letra que introduce.
















Capítulo 11: Programación orientada a eventos 275
• Presione la tecla Tab para trasladar el enfoque a cmdSalir.
Al hacerse efectivo el traslado del enfoque, txtCampo2 lo pierde y cmdSalir lo
adquiere. Al momento que txtCampo2 pierde el enfoque, se ejecuta el procedimiento
de evento txtCampo2_LostFocus, desplegando en IblAccion el mensaje
correspondiente.
• Haga clic en lblinstrucciones ("Haga clic o doble clic aquí") y luego haga
doble clic.
Cuando hace clic y doble clic se actualiza el mensaje de lblAccion. Esto se deriva
de las instrucciones que se especificaron en los procedimientos de evento
lblInstrucciones_Click y lblInstrucciones_DblClick, que se
ejecutan cuando usted causa en el objeto lblinstrucciones los eventos de clic y
doble clic.
• Haga clic en el botón Salir (cmdSalir).
El procedimiento cmdSalir_Click sólo contiene la instrucción End, que da por
terminada la sesión de trabajo.

Ocurren cuando el usuario presiona (KeyDown) o suelta (KeyUp) una tecla mientras
un objeto tiene el enfoque. Estos eventos son muy útiles para cuando desea capturar
combinaciones de teclas con la finalidad de provocar la ejecución de una determinada
tarea, como pudiera ser presionar Fl para ayuda, F2 para modificar un dato, etcétera.
Estos eventos tienen dos argumentos implícitos: KeyCode, que devuelve el código
ANSÍ de la tecla que se pulsa y Shift, que devuelve un código que Visual Basic iden-
tifica con las teclas especiales Alt, Mayús (Shift) y Ctrl.
Tanto con KeyDown como con KeyUp, el objeto que tiene el enfoque recibe todas las
pulsaciones de tecla. Un formulario sólo puede tener el enfoque si no tiene controles
visibles y activados, por lo que si desea una pantalla de captura sensible a cierta com-
binación de teclas sin importar el objeto que tenga el enfoque, tendría que definir el
mismo código en los procedimientos KeyDown y KeyUp en todos los objetos.

276 Parte 3: Controles gráficos y programación orientada a eventos

==================================================
Nota: Si la propiedad KeyPreview está establecida a True en un formulario,
éste recibe la petición de ejecución de KeyDown, KeyUp y KeyPress antes que
los objetos contenidos en él. Utilice la propiedad KeyPreview para crear rutinas
globales de control del teclado, sin necesidad de especificar lo mismo en KeyDown,
KeyUp y KeyPress para cada objeto.
==================================================
Aunque los eventos KeyDown y KeyUp pueden aplicarse a la mayoría de las teclas,
suelen usarse comúnmente para:
• Teclas de caracteres extendidos como las teclas de función (Fl, F2, F3, etcétera.)
• Teclas de desplazamiento
• Combinaciones de teclas con modificadores de teclado estándares
• Distinguir entre el teclado numérico y las teclas de número normales
Utilice los procedimientos de evento KeyDown y KeyUp si necesita responder a
presionar y soltar una tecla.
Los eventos KeyDown y KeyUp no se invocan para las siguientes teclas, en virtud
de que tienen significado preferencial en el entorno de Windows:
• La tecla Intro, si el formulario tiene un control CommandButton con la
propiedad Default establecida a True.
• La tecla Escape, si el formulario tiene un control CommandButton con la pro-
piedad Cancel establecida a True.
• La tecla Tab.
KeyDown y KeyUp, no son sensibles a mayúsculas y minúsculas, es decir todas las
letras tienen el mismo código de identificación (KeyCode).
El argumento implícito Shift, por su parte, corresponde a un valor numérico que
puede ser combinado. Para su mejor manejo. Visual Basic posee las siguientes cons-
tantes utilizables para Shift:

:

Por ejemplo, si usted presiona la combinación Alt+Mayús+A, KeyCode valdrá 65
(código ANSI de la letra "A") y Shift valdrá vbAltMask + vbShiftMask, es
decir 5.





Capítulo 11: Programación orientada a eventos 277

Ocurre cuando el usuario presiona una tecla correspondiente a un carácter ANSI (que
tiene código ASCII). El argumento implícito KeyASCII devuelve el código ASCII
de la tecla que se presionó.
KeyPress interpreta las pulsaciones con sensibilidad a mayúsculas y minúsculas, es
decir, las mayúsculas y minúsculas de cada carácter devolverán códigos de tecla
distintos.

==================================================
Nota: El número ANSI para la combinación de teclado Ctrl+@ es 0. Visual Basic
reconoce un valor KeyASCII de 0 como una cadena de longitud cero (""); evite usar
Ctrl+@ en sus aplicaciones, ya que puede obtener resultados impredecibles.
==================================================
El argumento implícito KeyASCII no solamente es informativo, ya que usted puede
manipular el texto a través de él. El texto que permanece en su captura no es el re-
cibido a través del teclado, sino el correspondiente al carácter ASCII del valor que
permanezca en KeyASCII después de que KeyPress se ejecute. Si no modifica el
argumento KeyASCII, lo que haya tecleado se mantiene.
El siguiente es un ejemplo del uso de KeyPress. Suponga que tiene un cuadro de
texto llamado txtClave, en donde debe capturar solamente caracteres numéricos.
Usted sabe que los caracteres numéricos tienen los códigos del 48 ("0") al 57 ("9") y
que el código ASCII de la tecla BackSpace es 8. Utilizando KeyPress usted puede
validar que sólo se capturen números.

Private Sub txtClave_KeyPress(KeyAscii As Integer)
If (KeyAscii >= 48 And KeyAscii <= 57) Or KeyAscii = 8 Then
KeyAscii = KeyAscii
Else
Beep
KeyAscii =0
End If
End Sub
Si teclea algo cuyo código esté entre 48 y 57 (número) o que sea 8 (BackSpace),
KeyASCII sigue valiendo KeyASCII, de lo contrario, se emite un sonido (Beep) y
KeyASCII vale 0, lo que actúa como si no hubiera tecleado nada.



278 Parte 3: Controles gráficos y programación orientada a eventos
Si tiene dudas de qué es lo que hace KeyASCII en KeyPress, quizá modificando
el código anterior de la siguiente forma comprenda mejor:
Priv txtClave_KeyPress(KeyAscii As Integer) ate Sub
KeyAscii = 64
End Sub
El código 64 es el correspondiente a la arroba (@). En este caso, no importa lo que
teclee en el objeto txtClave, todo se traducirá a código 64.
Algunas teclas especiales, tales como Alt, Ctrl, Mayús, las flechas de dirección y
Supr entre otras, no causan la ejecución de KeyPress, por lo que siguen teniendo
la misma función que tengan predefinida.
Una de las aplicaciones más útiles de KeyPress es para la captura secuencial de
datos de tipo numérico. Hay muchas aplicaciones cuya captura consiste en dos o más
números; por ejemplo, en el caso de transacciones con tarjeta de crédito, podría pre-
guntarse lo siguiente: número de cuenta, mes de expiración, año de expiración,
monto de la transacción.
Pensando en la facilidad que podemos brindarle al usuario, lo ideal es que la tecla
Intro (código 13 o bien la constante vbCr) asuma que se da por aceptado un dato y
transfiera el enfoque al siguiente dato, de tal forma que toda la captura pueda rea-
lizarse de manera rápida a través del bloque de teclas numéricas que por lo general se
encuentra en la parte derecha de los teclados. Una cajera experimentada le agradecerá
esa consideración, en lugar de que la obligue a alternar en cada campo con la tecla
Tab o bien con el uso del ratón. Suponga que los datos son capturados en los siguien-
tes objetos: txtCuenta, txtMesExp, txtAnioExp y txtMonto, en ese
orden.
Puede codificar txtCuenta_KeyPress de la siguiente forma:
Private Sub txtCuenta_KeyPress(KeyAscii As Integer)
KeyAscii = 4 KeyAscii <= 57) Or KeyAscii = 8 Then If ( > 8 And
KeyAscii = KeyAscii
Else
If KeyAscii = vbCr Then
txtMesExp.SetFocus
Else
Beep
KeyAscii = 0
End If
End If
End Sub







Capítulo 11: Programación orientada a eventos 279
De esta forma, validaría que todo lo escrito es número y en el caso de presionar
Intro, pasará al siguiente dato. Para el caso del evento KeyPress de txtMesExp,
txtAnioExp y txtMonto, solamente es necesario modificar el nombre del objeto
al que transferirá el enfoque.
==================================================
Nota: El sentido común nos diría que vbEnter es la constante correspondiente al
carácter 13, sin embargo. Visual Basic utiliza vbEnter en contraposición a
vbLeave, para determinar la entrada y salida de objetos en operaciones de tipo Drag
& Drop.
==================================================
>> Demostración de algunos de los eventos de tipo Teclado. [11.02]
frmTeclas.frm
A continuación aprenderá programación utilizando la captura de pulsaciones de
teclas normales, teclas especiales y combinaciones de teclas. También aprenderá a
establecer tareas "manteniendo presionada la tecla...".
Implementación visual








280 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmTeclas

Propiedades nuevas en frmTeclas



Capítulo 11: Programación orientada a eventos 281
Eventos nuevos en frmTeclas

Codificación de frmTeclas
• Editar código: txtCaptura, Evento: KeyDown.
Private Sub txtCaptura_KeyDown(KeyCode As Integer, Shift As Integer)
lblKeyCode.Caption = Str(KeyCode)
lblShift.Caption = Str(Shift)
intEstadoAlt% = Shift
End Sub
• Editar código: txtCaptura, Evento: KeyPress.
Private Sub txtCaptura_KeyPress(KeyASCII As Integer)
lblKeyASCII.Caption = Str(KeyAscii) & " ( " & Chr(KeyAscii) & " )"
End Sub

• Editar código: txtCaptura, Evento: KeyUp
Private Sub txtCaptura_KeyUp(KeyCode As Integer, Shift As Integer)
lblKeyCode.Caption = Str(KeyCode)
lblShift.Caption = Str(Shift)
intEstadoAlt% = Shift
End Sub




282 Parte 3: Controles gráficos y programación orientada a eventos
• Editar código: (General), Evento: (Declarations).
Dim intEstadoAlt As Integer

• Editar código: lbl1, Evento: Click.
lbl1.Font.Bold = (intEstadoAlt% = vbAltMask)

• Editar código: lbl2, Evento: Click.
lbl2.Font.Bold = (intEstadoAlt% = vbAltMask)
• Editar código: lbl3, Evento: Click.
lbl3.Font.Bold = (intEstadoAlt% = vbAltMask)
Ejecución
• Antes de ejecutar la aplicación, asegúrese de que la tecla Bloq Mayús
(CapsLock) no está activada. Presione la tecla "a".
Aunque usted no se dé cuenta, ya se ejecutaron tres eventos: txtCaptura_
KeyDown, cuando presionó la tecla "a", txtCaptura_KeyPress porque
presionó una tecla reconocida por ANSI y txtCaptura_KeyUp,, cuando dejó
de presionar la tecla "a". El proceso provoca que se actualicen los argumentos
implícitos de los eventos, mismos que se despliegan en los objetos Label
incluidos en la interfaz para tal efecto. KeyCode es igual a 65, correspondiente a
la letra "a", Shift es igual a cero, porque no está utilizando ninguna tecla especial y
KeyASCII es igual a 97, código ASCII correspondiente a la letra "a" en minúscula.
• Active la tecla Bloq Mayús (CapsLock).
Observe que KeyCode cambia a 20, correspondiente a la tecla Bloq Mayús, pero
KeyASCII no cambia. Esto se debe a que KeyASCII realmente no se ha
actualizado, porque después de la primera letra "a" que tecleó, no ha presionado
ninguna tecla con valor ANSI.







Capítulo 11: Programación orientada a eventos 283
• Una vez que la tecla Bloq Mayús esté activada, presione la tecla "a".
Observe que KeyCode cambia a 65; dicho código fue igual, tanto para la "a"
como para la "A". El valor de KeyASCII, que es case sensitivo, muestra el
código 65, correspondiente a la letra "A" mayúscula, diferente al 97 presentado
cuando tecleó la letra "a" minúscula".
• Presione la tecla Ctrl y no la suelte, vea el valor que asume Shift y posterior-
mente suelte la tecla Ctrl.
Cuando presiona la tecla Ctrl, el procedimiento txtCaptura_KeyDown
actualiza Shift con el valor 2 (correspondiente a vbCtrlMask). Mientras no
libere la tecla, Shift seguirá siendo 2. Cuando libera la tecla,
txtCaptura_KeyUp actualiza Shift con el valor 0. Conocer el último
estado de Shift le permitirá realizar tareas de "mantener presionada la tecla...".
• Almacenamiento permanente del valor de Shift, para controlar tareas del tipo
"mantenga presionada la tecla...".
En nuestra aplicación queremos que al mantener presionada la tecla Alt y hacer
clic en cualquiera de los objetos de tipo Label con valor estático (lbl1, lbl2
y lbl3), éstos se pongan en negritas. Para lograrlo, es necesario que sepamos
en todo momento si se está manteniendo presionada la tecla Alt o no; para ello
definimos una variable a nivel de declaraciones generales llamada intEsta-
doAlt%, que almacena el último valor conocido de Shift, mismo que se modifi-
ca en los eventos txtCaptura_KeyDown y en txtCaptura_KeyUp,
cuando se presiona o se deja de presionar una tecla.
Si el último valor asumido por intEstadoAlt% es igual a vbAltMask (es
decir 4), sucederá lo siguiente cuando haga clic en lbl1, lbl2 o lbl3: la
propiedad Font, en su especificación Boíd para el objeto sobre el que se haga
clic, será igual al valor lógico resultante entre intEstadoAlt%, y
vbAltMask (4); como 4 es igual a 4, el valor resultante será True y por tanto el
texto cambiará.
• Presione la tecla Alt y no la suelte. Haga clic en los objetos lbl1 y lbl2.
Suelte la tecla Alt. Haga clic en lbl2.
Se pone en práctica lo explicado en el punto anterior. Ahora, usted puede desa-
rrollar aplicaciones que reconocen las teclas especiales.






284 Parte 3: Controles gráficos y programación orientada a eventos
Tipo Ratón

Ocurren cuando el usuario presiona (MouseDown) o suelta (MouseUp) un botón del
ratón. Tienen una utilidad adicional a los eventos Click y DblClick. en el sentido
de que reconocen los botones que se están presionando, además de que reconocen si
el trabajo con el ratón está acompañado del uso de teclas especiales (Alt, Ctrl y
Mayús).
Sus argumentos implícitos son Button, que especifica qué botón del ratón se
presiona, State, que indica si se están presionando teclas especiales en conjunto con
el ratón y X,Y que en conjunto hacen referencia las coordenadas de la ubicación del
puntero del ratón.
Visual Basic posee constantes para simplificar la identificación de los valores que
puede asumir Button...

... y los que puede asumir State:










Capítulo 11: Programación orientada a eventos 285

Ocurre cuando el usuario mueve el ratón. Los argumentos implícitos son los mismos
y actúan igual que en los eventos MouseDown y MouseUp: la diferencia entre
MouseMove y aquellos, es que MouseMove es de ejecución continua, mientras que
MouseDown y MouseUp sólo ocurrirán al presionar los botones del ratón.
MouseMove se ejecuta en todo cambio de posición X,Y del puntero sobre el objeto
que tiene definido el evento.
>>Demostración de algunos de los eventos de tipo Ratón. [11.03]
frmRaton.frm
A continuación aprenderá programación utilizando la captura de pulsaciones de los
botones del ratón, así como el movimiento del puntero del mismo.
Implementación visual





286 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmRaton

Eventos nuevos en frmRaton

Codificación de frmRaton
• Editar código: Form, Evento: MouseMove.
Private Sub Form_MouseMove(Button As Integer,
Shift As Integer, X As Single, Y As Single)

lblAccion.Caption = "Button:" & Button & " Shift;" &
Shift & " X:" & X & " Y:" & Y
End Sub









Capítulo 11: Programación orientada a eventos 287
Ejecución
• Mueva el puntero del ratón sobre el formulario.
Se actualizará el objeto Label (lblAccion) con los datos que se están utilizando
en los argumentos implícitos. Observe que Button y Shift no tienen valor, ya
que no ha presionado ningún botón, ni tiene presionada ninguna tecla especial.
• Presione el botón derecho del ratón y no lo suelte; siga moviendo el puntero del
ratón.
Observe que ahora Button equivale a vbRightButton (2).
• Ahora presione la tecla Ctrl y siga moviendo el puntero del ratón. Observe
que ahora Shift equivale a vbCtrlMask (2).
>> Cómo darle riqueza visual a un programa, mediante el evento MouseMove.
[11.04]
frmDestinos.frm
A continuación aprenderá a agregar elementos gráficos a sus aplicaciones, como fondo al
formulario o gráficos a los botones de comando. Utilizará MouseMove para alterar visualmente la
interfaz y darle un poco más de vida.
La aplicación muestra los destinos turísticos que una agencia de viajes especializada ofrece; la
empresa tiene organizados los destinos en las siguientes categorías: en todo el mundo, México,
Estados Unidos y Canadá.











288 Parte 3: Controles gráficos y programación orientada a eventos
Implementación visual

Tabla de objetos y propiedades de frmDestinos





Capítulo 11; Programación orientada a eventos 289









290 Parte 3: Controles gráficos y programación orientada a eventos
Propiedades nuevas en frmDestinos

Eventos nuevos en frmDestinos
Métodos nuevos en frmDestinos



Codificación de frmDestinos

• Editar código: cmdMundo, Evento: MouseMove,

cmdMundo.Font.Bold = True
cmdMexico.Font.Bold = False
cmdEU.Font.Bold = False
cmdCanada.Font.Bold = False
cmdMundo.SetFocus


Capítulo 11: Programación orientada a eventos 291

• Editar código: cmdMundo, Evento: Click,
txtDestinos.Text = "Chicago" & vbNewLine & _
"Denver" & vbNewLine & _
"N.Y." & vbNewLine & _
"México D.F." & vbNewLine & _
"Monterrey" & vbNewLine & _
"Guadalajara" & vbNewLine & _
"Cancún" & vbNewLine & _
"Ontario" & vbNewLine & _
"Montreal" & vbNewLine & _
"Vancouver"
• Editar código: cmdMexico, Evento: MouseMove,
cmdMundo.Font.Bold = False
cmdMexico.Font.Bold = True
cmdEU.Font.Bold = False
cmdCanada.Font.Bold = False
cmdMexico.SetFocus

• Editar código:cmdMexico, Evento: Click.
txtDestinos.Text = "México D.F." & vbNewLine & _
"Monterrey" & vbNewLine & _
"Guadalajara" & vbNewLine & _
"Cancún"






292 Parte 3: Controles gráficos y programación orientada a eventos
• Editar código: cmdEU, Evento: MouseMove.
cmdMundo.Font.Bold = False
cmdMexico.Font.Bold = False
cmdEU.Font.Bold = True
cmdCanada.Font.Bold = False
cmdEU.SetFocus
• Editar código: cmdEU, Evento: Click.
txtDestinos.Text = "Chicago" & vbNewLine & _
"Denver" & vbNewLine & _
"N.Y." & vbNewLine
• Editar código: cmdCanada, Evento: MouseMove.
cmdMundo.Font.Bold = False
cmdMexico.Font.Bold = False
cmdEU.Font.Bold = False
cmdCanada.Font.Bold = True
cmdCanada.SetFocus
• Editar código: cmdCanada, Evento: Click.
txtDestinos.Text = "Ontario" & vbNewLine & _
"Montreal" & vbNewLine & _
"Vancouver"
• Editar código: txtDestino, Evento: Change.
Beep
• Editar código: cmdSalir, Evento: Click.
End




Capítulo 11: Programación orientada a eventos 293

Ejecución
• Mueva el puntero del ratón sobre el botón de comando El Mundo (cmdMundo).
Se ejecutará el procedimiento de evento cmdMundo_MouseMove. que provoca el
comportamiento que se repite en los objetos cmdMexico, cmdEU y cmdCanada:
(1) Se asigna el enfoque al objeto (SetFocus); como es CommandButton, se
percibe por el borde negro que se le coloca al objeto. (2) Se despliega el mensaje de
Información sobre herramientas, que dice "Destinos en el mundo". (3) Mediante
la manipulación de la propiedad Font se establece en negritas el contenido del
botón; este efecto, en conjunto con el borde negro que da el enfoque, distingue
claramente al botón apuntado con el ratón, del resto de los demás. (4) Para hacer
más patente la diferencia, se modifica la propiedad Font del resto de los botones,
para que se encuentren con letra normal, es decir, que no estén negritas.
Este comportamiento se repite para cmdMexico, cmdEU y cmdCanada; sólo
cambiará la propiedad ToolTipText correspondiente a cada objeto.
• Arrastre el puntero del ratón sobre los botones y vea el efecto que causa.
• Presione el botón de comando México (cmdMexico).
Se ejecuta el procedimiento cmdMexico_Click, que desplegará, en múltiples
líneas, los destinos turísticos de México. Este mensaje no es otra cosa que una
expresión String que contiene chr(10) & chr(13),en su forma constante
Visual Basic vbNewLine. Como el contenido de txtDestino cambió, se
ejecuta el procedimiento txtDestino_Change, que produce una emisión
sonora por el altavoz de la computadora.
Este comportamiento se repite, y el contenido de la expresión String cambia para
cmdMexico, cmdEU y cmdCanada.
• Sin importar qué objeto tenga el enfoque en este momento, presione la tecla Intro.
Como el botón de comando Salir (cmdSalir) tiene establecida la propiedad
Default a True, actúa como botón predeterminado, que ejecuta el procedimiento
cmdSalir_Click.







294 Parte 3: Controles gráficos y programación orientada a eventos

Prioridad de los eventos
Cuando trabaja con eventos, debe ser muy cuidadoso de que éstos no produzcan
comportamientos contrapuestos con otros. Es posible que usted provoque un ciclo
indefinido con eventos que actúan uno contra otro.
El ejemplo clásico es el de la validación contra vacíos. Suponga que tiene en su inter-
faz dos cuadros de texto, uno llamado txtNombre y otro llamado txtDireccion,
los cuales se encuentran uno después del otro. Suponga que tanto el Nombre
(capturado en txtNombre) como la Dirección (txtDireccion) son datos
imprescindibles, por lo cual el usuario no debe omitirlos.
Usted codifica de tal forma que al salir de cada uno de los dos objetos, se valide si se
omitieron los datos, en cuyo caso regresará el enfoque al cuadro de texto que debe ser
complementado.
Private Sub txtNombre_LostFocus()
If txtNombre.Text = "" Then
MsgBox "El nombre no se puede omitir"
txtNombre.SetFocus
End If
End Sub
Private Sub txtDireccion_LostFocus()
If txtDireccion.Text = "" Then
MsgBox "La dirección no se puede omitir"
txtDireccion.SetFocus
End If
End Sub
Usted omite el nombre (presiona Tab estando en el objeto txtNombre) y genera un
ciclo infinito que sólo podrá romper con Ctrl+Inter.
¿Dónde está el problema? Resulta que cuando se ejecuta txtNombre_LostFocus,
el objeto txtNombre ya no tiene el enfoque, es decir, el enfoque ya lo tiene otro
objeto, en este caso txtDireccion. El procedimiento txtNombre_LostFocus,
al detectar que se omitió la captura del nombre, envía un mensaje de error y utiliza la
instrucción txtNombre.SetFocus, para asignar el enfoque al objeto
txtNombre; esto provoca que txtDireccion, después de tener el enfoque, lo
pierde estando vacío, lo cual también causa error y le asigna el enfoque a
txtDireccion, ¡pero otra vez txtNombre está vacío, marca error y cambia el
enfoque! Así sigue infinitamente.
La solución: utilizar el evento adecuado. Como vimos en nuestro ejemplo, el evento
LostFocus no nos sirve porque cuando ocurre, el objeto ya no tiene el enfoque:



Capítulo 11: Programación orientada a eventos 295
¿qué evento se ejecuta cuando un objeto pretende perder el enfoque? Respuesta:
Validate.
Nuestro ejemplo quedaría como se muestra a continuación:
Private Sub txtNombre_Validate(Cancel As Boolean)
If txtNombre.Text = "" Then
MsgBox "El nombre no se puede omitir"
Cancel = True
Else
Cancel = False
End If
End Sub

Private Sub txtDireccion_Validate(Cancel As Boolean)
If txtDireccion.Text = "" Then
MsgBox "La dirección no se puede omitir"
Cancel = True
Else
Cancel = False
End If
End Sub
Es recomendable que identifique claramente en qué momento se ejecutan los eventos
y que defina claramente en qué momento desea que las instrucciones de su aplicación
se ejecuten. Coloque sus instrucciones en el evento que con mayor precisión se
acerque al momento en que usted desea que las tareas sean realizadas y se ahorrará
muchos problemas. Explicado así se escucha fácil, pero ¿cómo saber con exactitud
qué se ejecuta primero?.
El siguiente ejemplo nos servirá para determinar la prioridad que tienen los eventos
en la ejecución.
>> Elaboración de un programa que le permita visualizar la prioridad en la
ejecución de los eventos. [11.05]
frmOrden.frm
A continuación aprenderá a actualizar un cuadro de texto multilínea con informa-
ción producida en tiempo de ejecución y al mismo tiempo comprobará la prioridad
que tienen los eventos en su ejecución.
La información derivada de la ejecución de este programa le dará mucha claridad con
respecto a la forma en que Visual Basic desencadena los eventos; eso le permitirá
evitar conflictos de ejecución en los procedimientos de evento.









296 Parte 3: Controles gráficos y programación orientada a eventos
Para este programa requerirá dos cuadros de texto para evaluar los eventos de tipo
Cambios, Enfoque y Teclado, mientras que utilizará un botón de comando para eva-
luar los eventos de tipo Ratón y Click.
Implementación visual

Tabla de objetos y propiedades de frmOrden



Capítulo 11: Programación orientada a eventos 297
Codificación de frmOrden
• Editar código: txtObjeto1, Evento: GotFocus.
txtMuestra.Text = txtMuestra.Text & "Obj-1: GotFocus" & vbNewLine
• Editar código: txtObjeto1, Evento: KeyDown.
txtMuestra.Text = txtMuestra.Text & "Obj-1; KeyDown" & vbNewLine
• Editar código: txtObjeto1, Evento: KeyPress.
txtMuestra.Text = txtMuestra.Text & "Obj-1; KeyPress" & vbNewLine
• Editar código: txtObjeto1, Evento: Change.
txtMuestra.Text = txtMuestra.Text & "Obj-1: Change" & vbNewLine
• Editar código: txtObjeto1, Evento: KeyUp.
txtMuestra.Text = txtMuestra.Text & "Obj-1: KeyUp" & vbNewLine
• Editar código: txtObjeto1, Evento: Validate.
txtMuestra.Text = txtMuestra.Text & "Obj-1: Validate" & vbNewLine
• Editar código: txtObjeto1, Evento: LostFocus.
txtMuestra.Text = txtMuestra.Text & "Obj-1: LostFocus" & vbNewLine
• Editar código: txtObjeto2, Evento: GotFocus.
txtMuestra.Text = txtMuestra.Text & "Obj-2: GotFocus" & vbNewLine





298 Parte 3: Controles gráficos y programación orientada a eventos
• Editar código: cmd0bjeto3, Evento: Click.
txtMuestra.Text = txtMuestra.Text & "Obj-3: Click" & vbNewLine
• Editar código: cmd0bjeto3, Evento: MouseMove.
txtMuestra.Text = txtMuestra.Text & "Obj-3: MouseMove" & vbNewLine
• Editar código: cmd0bjeto3, Evento: MouseDown.

txtMuestra.Text = txtMuestra.Text & "Obj-3: MouseDown" & vbNewLine
• Editar código: cmd0bjeto3. Evento: MouseUp.
txtMuestra.Text = txtMuestra.Text & "Obj-3: MouseUp" & vbNewLine
• Editar código: txtObjeto2, Evento; Click.
txtMuestra.Text = txtMuestra.Text & "Obj-2: Click" & vbNewLine
• Editar código: txtObjeto2, Evento:DblClick.
txtMuestra.Text = txtMuestra.Text & "Obj-2: DblClick" & vbNewLine
Ejecución
• Al ejecutar el programa, antes de que usted interactúe con él, el primer objeto en la
secuencia de tabulación adquiere el enfoque.
El objeto txtobjeto1 adquiere el enfoque por ser el primero en la secuencia de
tabulación que puede hacerlo. Se produce el evento txtObjeto1_GotFocus.
El cuadro de texto multilínea (txtMuestra) se actualizará, mencionando que el evento
en cuestión se ha ejecutado. Como puede ver, la propiedad Text de txtMuestra
acumula los resultados obtenidos, separándolos con chr(13) + chr(10), en su
forma de constante Visual Basic vbNewLine, lo que da la apariencia de ir listando los
resultados. Esto sucederá en todos los procedimientos de evento del programa, donde sólo
cambiará la referencia del objeto (Obj -1, 2 o 3) y el nombre del evento que se ha
desencadenado.





Capítulo 11: Programación orientada a eventos 299
• Presione la tecla "a".
Se ejecutan, para el objeto txtObjeto1, los eventos KeyDown, KeyPress,
Change y KeyUp en ese orden.
• Pulse la tecla Tab para ir al siguiente objeto (txtObjeto2).
Se ejecutan, para el objeto txtObjeto1, los eventos Validate y LostFocus en ese
orden. Sólo entonces, txtObjeto2 adquiere el enfoque (txtObjeto2_GotFocus).
• Presione la tecla Intro.
Como el botón de comando Objeto 3 (cmd0bjeto3) tiene establecida la propiedad
Default a True, actúa como botón predeterminado, que ejecuta el procedimiento
cmdSalir_Click.
• Haga clic en el Objeto 3 (cmdObjeto3).
Al momento de arrastrar el puntero del ratón sobre el botón para hacer clic en él, se
ejecuta en múltiples ocasiones el procedimiento cmdObjeto3_MouseMove; una vez
que hace clic, se ejecutará primero el procedimiento cmdObjeto3_MouseDown
(recuerde que en Windows mientras no suelte el botón del ratón, no se interpreta como
clic), después se ejecuta el procedimiento cmdObjeto3_Click y luego
cmdObjeto3_MouseUp.
• Haga doble clic en el segundo cuadro de texto (txtObjeto2).
Puesto que un clic sucede antes que uno doble, se ejecuta primero el procedimiento
txtObjeto2_Click y posteriormente txtObjeto2_DblClick.
Tomado como base el ejemplo anterior, podemos sugerir la siguiente tabla:










300 Parte 3: Controles gráficos y programación orientada a eventos








Capítulo 11: Programación orientada a eventos 301
La cantidad de combinaciones que pueden resultar en relación a las preferencias en
la ejecución de eventos, depende de manera directa de los eventos que tenga
codificados para un determinado objeto, así como las condiciones que tenga esta-
blecidas en el objeto contenedor (propiedad KeyPreview).
En cualquier procedimiento de evento puede existir alguna instrucción End que
concluya la ejecución de un ciclo o programa y por consiguiente, impide que un
evento, no obstante que se presentan las condiciones para su ejecución, ya no se
ejecute.
Esto lo puede comprobar colocando la instrucción End en un procedimiento de tipo
KeyDown: no obstante que están dadas las condiciones para que también se ejecute
KeyPress, el código de dicho evento nunca se ejecutará.
>> Demostración de la precedencia del evento MouseMove sobre el evento Click.
[11.06]
frmMueve.frm
A continuación aprenderá que algunos eventos pueden ir en contra de otros y que debe
planear en tiempo de diseño el uso de los eventos que no causen conflictos.
Implementación visual









302 Parte 3: Controles gráficos y programación orientada a eventos

Tabla de objetos y propiedades de frmMueve

Métodos nuevos en frmMueve

Codificación de frmMueve
• Editar código: cmdClic, Evento: MouseMove.
If cmdClic.Top = 2000 Then
cmdClic.Move 100, 100
Else
cmdClic.Move 2000, 2000
End If


• Editar código: cmdClic, Evento: Click.
End



Capítulo 11: Programación orientada a eventos 303
Ejecución
• El botón de comando Haga clic aquí (cmdClic), inicia con la propiedad Top
con valor de 2000 y la propiedad Left con valor de 2000, mismas que
determinan su posición en el formulario. Intente hacer clic en el botón.
En el instante en que comience a mover el puntero del ratón sobre cmdClic
pretendiendo hacer clic en él, se ejecuta cmdClic_MouseMove, que
cambia de posición al objeto, a la posición 100, 100. Si trata de hacer clic
otra vez, cambiará la posición nuevamente. Alternará la posición de 2000,
2000 a 100, 100 tantas veces como mueva el ratón sobre el botón.
Como MouseMove siempre se ejecuta antes que el evento Click, será
imposible desencadenar con el ratón el procedimiento cmdClic_Click.
• Presione la barra espadadora (otra forma de desencadenar el evento Cllck de
los
botones de comando).
El programa terminará.
__________________________________________________________________________________
Resumen
En este capítulo:
• Vimos qué son los eventos y su clasificación.
• Vimos cuáles son las categorías de eventos consideradas de uso general.
• Vimos a detalle los eventos principales de las categorías de evento de uso
general.
• Vimos cómo a través de Visual Basic se pueden realizar validaciones y
manipulación de datos utilizando dispositivos de entrada como el teclado o el
ratón.
• Vimos cómo enriquecer visualmente una aplicación a través de trucos
realizados por eventos.
• Vimos la prioridad de ejecución de los eventos, dependiendo de
determinados escenarios de ejecución.
• Vimos cómo la ejecución de algunos eventos pueden perjudicar la
ejecución de otros y la forma de cómo evitarlos.
Es importante que domine el contenido de este capítulo para poder continuar,
ya que prácticamente el desarrollo en Visual Basic se fundamenta en el estilo
de trabajo orientado a eventos. Los eventos de uso general son indispensables
en cualquier aplicación de Visual Basic.


304







Capítulo
12
Controles
contenedores
y controles de selección
Objetivo
Conocer el uso de los controles contenedores y controles de selección, analizando sus
particularidades y capacidades.
Al finalizar este capítulo deberá:
• Dominar el uso del control Frame
• Dominar el uso del control CheckBox
• Conocer la forma de definir matrices de controles y entender su utilidad
• Conocer la forma de manipular el color a través de RGB y QBColor
• Dominar el uso del control OptionButton
• Dominar el uso del control HScrollBar y VScrollBar
305




306 Parte 3: Controtes gráficos y programación orientada a eventos
Objetos contenedores
Los objetos contenedores son aquellos que a su vez pueden contener a otros objetos.
En cualquier entorno de desarrollo orientado a objetos es importante disponer de
ellos, ya que de otra forma no habría manera de aprovechar la capacidad de herencia
(inheritance), propia de la tecnología OOP. ¿En qué nos beneficia la capacidad de
herencia? La respuesta es sencilla: todos los objetos contenidos en un objeto con-
tenedor heredan las características de este último, dicho de otra forma, heredan sus
propiedades.
Como ya lo hemos mencionado en capítulos anteriores, el desarrollo en Visual Basic
no es orientado a objetos, sino orientado a eventos, y por tanto, la herencia no se da
de manera completa. Utilizaremos las capacidades del entorno de desarrollo y vere-
mos que al menos las capacidades de herencia limitadas pueden ser de gran ayuda.
Hasta el momento, ya hemos utilizado el objeto contenedor básico, es decir, el for-
mulario (Form). Además de dicho objeto, Visual Basic dispone del objeto Frame.
Frame
Marco. Sirve para contener otros objetos, siendo posible manejarlos como una uni-
dad dentro de un formulario.
La propiedad esencial de los objetos basados en este control es Caption, ya que
representa lo que se desplegará en la parte superior del objeto; dicha propiedad tiene
un límite de 255 caracteres.
Lo más relevante de este control es:















Capítulo 12: Controles contenedores y controles de selección 307
===================================================
Nota: Es curioso que el evento predeterminado sea DragDrop. Esto es comprensible
debido a que Frame realmente no desarrolla tareas de interacción con el usuario. Su
finalidad principal es contener otros objetos.
===================================================
>> Cómo utilizar un objeto contenedor para darle funcionalidad a una aplicación.
[12.01]
frmDatos.frm
A continuación aprenderá a utilizar un objeto contenedor, que será activado o desactivado
en base a una condición. Creará un formulario que altere su tamaño con base en la
utilización de un campo, que utilice constantes para modificación rápida de valores y que
manipule las diferentes acciones que el usuario realice, habilitando e inhabilitando
objetos.
Implementación visual





308 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmDatos





Capítulo 12: Controles contenedores y controles de selección 309

===================================================
Nota: Como puede ver, se sangraron los objetos que se encuentran dentro del objeto
Frame (fraComplemento); en otras palabras, lbl2, txtDireccion,
lbl3, txtEdad, lbl4 y txtFechaNac, están contenidos en el objeto
fraComplemento.
Para que los objetos queden contenidos en el Frame, es necesario que los agregue en
modo de trazo, ya que si los agrega en modo de inserción, no estarán contenidos en el
Frame. Puede comprobar que todos los objetos quedaron contenidos en el Frame si al
mover el objeto fraComplemento, todos los objetos que se encuentran dentro de él
también se mueven. Si alguno de ellos no se mueve junto con el objeto contenedor,
quiere decir que está contenido en el formulario y, por tanto, deberá eliminarlo y agre-
garlo al Frame en modo de trazo.
===================================================

Propiedades nuevas en frmDatos

Eventos nuevos en frmDatos



Codificación de frmDatos
• Editar código: (General), Evento: (Declarations).
Const intAmpliado As Integer = 4215
Const intReducido As Integer = 1770





310 Parte 3: Controles gráficos y programación orientada a eventos

• Editar código: Form, Evento: Load.
frmDatos.Height = intReducido%
• Editar código: txtNombre, Evento: Change.
If txtNombre.Text <> "" Then
cmdMas.Enabled = True
fraComplemento.Enabled = True
Else
If frmDatos.Height = intReducido% Then
cmdMas.Enabled = False
End If
fraComplemento.Enabled = False
End If


• Editar código: cmdMas, Evento: Click.
If frmDatos.Height = intReducido% Then
frmDatos.Height = intAmpliado%
cmdMas.Caption = "<< &Menos"
Else
frmDatos.Height = intReducido%
cmdMas.Caption = "&Más >>"
If txtNombre.Text = "" Then
cmdMas.Enabled = False
End If
End If
Ejecución
• Antes de que se active el formulario, se ejecuta el código que se encuentra en el área
de declaraciones generales, y que define dos constantes que serán utilizadas para
manipular la altura del formulario. El procedimiento de evento Form_Load altera el
tamaño del formulario, de tal forma que el objeto Frame (fraComplemento) quede
oculto.
• Al inicio, el botón de comando Más >> (cmdMas) está inhabilitado. Teclee su
nombre, bórrelo totalmente, vuélvalo a escribir. Vea lo que sucede cada que el cuadro
de texto deja de tener contenido.








Capítulo 12: Controles contenedores y controles de selección 311
Sólo se activará cuando en el cuadro de texto Nombre (txtNombre) se haya
introducido algo. Para ello, cada que usted teclea algo en dicho cuadro de texto, sucede
el evento Change (txtNombre_Change), mismo que evalúa si la propiedad Text
del objeto txtNombre es diferente a vacío (""). En caso de que no esté vacío, habilita
el objeto cmdMas y habilita el Frame fraComplemento (aunque de momento no se
vea).
Haga clic en el botón Más>> (cmdMas).
Se ejecutará el procedimiento cmdMas_Click. El objeto cmdMas tiene dos papeles:
actúa como botón Mas » para extender el formulario y mostrar el objeto Frame, y
como botón <<Menos para reducir el formulario de tal forma que el objeto Frame no
esté visible.
Si la altura del formulario es igual al valor de la constante intReducido%, entonces
se hizo clic en el botón cuando actuaba como Más>> y por tanto cambia la altura del
formulario al valor de la constante intAmpliado%, lo que hace que el formulario se
expanda de tal manera que el objeto Frame esté visible. Como el botón no puede
actuar como Más>> si el formulario está expandido, coloca el botón como <<Menos .
Elimine el contenido del objeto txtNombre.
Cuando el Frame está visible (la altura del formulario es intAmpliado%), puede
eliminar usted el contenido del cuadro de texto. En ese caso, al haber eliminado el
último carácter del cuadro de texto, el procedimiento txtNombre_Change detectará
que la propiedad Text del objeto txtNombre no es diferente a vacío (""), por lo tanto
inhabilita el uso del Frame.
Si no dispusiera del objeto Frame, para inhabilitar los datos relativos a la dirección
(txtDireccion), edad (txtEdad) y fecha de nacimiento (txtFechaNac), tendría
que inhabilitar a cada uno de los objetos por separado. La utilidad del Frame es que
tanto la propiedad Enabled como Visible, se aplican por herencia a los objetos
contenidos en él. Si el Frame está habilitado, todo lo que está dentro de él está
habilitado, si el Frame está visible, todo lo contenido en él está visible. No obstante,
usted puede manipular las propiedades Enabled y Visible para cada uno de los
objetos contenidos; si tiene conflictos de propiedades, por ejemplo que inhabilite el
Frame y de manera particular habilite uno de los objetos contenidos en dicho Frame,
tendrá prioridad la especificación hecha al Frame, es decir, podría disponer del objeto,
siempre y cuando pudiera disponer del Frame.
Escriba nuevamente su nombre. Haga clic en el botón Más>> y escriba los datos de
complemento. Luego haga clic en el botón <<Menos.
Si la altura del formulario no es igual al valor de la constante intReducido%,
entonces tendrá el valor de la constante intAmpliado%, y por lo tanto el formulario
estará extendido. Usted podrá introducir los datos de complemento. Mien-





312 Parte 3: Controles gráficos y programación orientada a eventos
tras el formulario está ampliado, el botón actúa en su calidad de <<Menos. Al hacer clic
en el botón, la altura del formulario tomará el valor de intReducido%, lo que deja
invisible el Frame. Como el botón no puede seguir actuando como <<Menos si el
formulario ya está reducido, coloca el botón como Más>>. El manejo del botón es
dinámico.
Al hacer clic nuevamente en Más>> verá que los datos permanecerán en los cuadros de
texto, es decir, no se perderán.
CheckBox
Casilla de verificación. Un control CheckBox muestra una "" cuando está activado;
la "" desaparece cuando el control CheckBox se desactiva. La utilidad básica de este
control es determinar si algo está activo o no lo está. 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 de entre las cuales el usuario
puede seleccionar una o más, de manera simultánea. También puede establecer el valor
de CheckBox en tiempo de ejecución estableciendo su propiedad Value a True.
Lo más relevante de este control es:

>> Uso de un control CheckBox para seleccionar varias características de manera
simultánea. [12.02]
frmEstilo.frm
Este ejemplo permite establecer uno o varios atributos a un texto, relativos a las pro-
piedades Font: negritas, itálicas y subrayadas; también se hará juego con el tamaño, a
través de botones de comando.







Capítulo 12: Controles contenedores y controles de selección 313
Implementadón visual


Tabla de objetos y propiedades de frmEstilo






314 Parte 3: Controles gráficos y programación orientada a eventos


Propiedades nuevas en frmEstilo

Codificación de frmEstilo
• Editar código: chkNegritas, Evento: Click.
If chkNegritas.Value = vbChecked Then
lblMuestra.Font.Bold = True
Else
lblMuestra.Font.Bold = False
End If
• Editar código: chkItalicas. Evento: Click.
If chkItalicas.Value = vbChecked Then
lblMuestra.Font.Italic = True
Else
lblMuestra.Font.Italic = False
End If






Capítulo 12: Controles contenedores y controles de selección 315
• Editar código: chkSubrayadas. Evento: Click.
If chkSubrayadas.Value = vbChecked Then
lblMuestra.Font.Underline = True
Else
lblMuestra.Font.Underline = False
End If
• Editar código: chkAumentar. Evento: Click.
If lblMuestra.Font.Size >= 38 Then
Beep
Else
lblMuestra.Font.Size = lblMuestra.Font.Size + 2
End If
• Editar código: cmdReducir, Evento: Click.
If lblMuestra.Font.Size <= 8 Then
Beep
Else
lblMuestra.Font.Size = lblMuestra.Font.Size - 2
End If

• Editar código: cmdSalir, Evento: Click,
End
Ejecución
• Al iniciar la ejecución, el texto de muestra (txtMuestra) no tiene ninguno de los
atributos de Font posibles en el ejemplo. Su tamaño es el que tenga de manera
predeterminada su sistema.
• Haga clic en la casilla de verificación Negritas (chkNegritas), para marcarla.
El procedimiento chkNegritas_Click se ejecutará. Al momento de que se ejecuta
el procedimiento Click, el objeto ya tiene la propiedad Value actualizada, acorde a
lo que manifiesta la interfaz.




316 Parte 3: Controles gráficos y programación orientada a eventos
Como el evento Click no proporciona información en relación a si la casilla de
verificación está activada, desactivada o parcialmente activada (vbChecked,
vbUnchecked o vbGrayed), usted tiene que hacer la evaluación para
determinarlo. Si el control tiene su propiedad Value establecida a vbChecked,
entonces la especificación Bold de la propiedad Font se establece a True, con lo que
el texto de muestra cambia su apariencia a negritas.
Haga clic en la casilla de verificación Negritas (chkNegritas) para desmarcarla.
Si por el contrario, el valor es vbUnchecked, la especificación Bold de la propiedad
Font se establece a False, con lo que el texto utilizado como muestra cambia en su
apariencia a modo normal.
Este comportamiento sucede para los procedimientos chkItalicas_Click y
chkSubrayadas_Click, con su respectiva variante de especificación.
Haga clic en el botón de comando que muestra la A más grande (botón de incremento
de tamaño).
El tamaño máximo para el texto de muestra es de 38 puntos. Si pretende incrementar el
tamaño de Font por encima de los 38 puntos, la aplicación emitirá un sonido por el
altavoz. Si desea aumentar el tamaño y aún no llega al límite máximo, la aplicación
incrementará en 2 puntos el tamaño que actualmente tenga el texto de muestra.
Haga clic en el botón de comando que muestra la A más pequeña (botón de reducción
de tamaño).
El tamaño mínimo para el texto muestra es de 8 puntos. Si pretende reducir el tamaño
de Font por abajo de los 8 puntos, la aplicación emitirá un sonido por el altavoz. Si
desea reducir el tamaño y aun no llega al límite mínimo, la aplicación reducirá en 2
puntos el tamaño que actualmente tenga el texto de muestra.
Haga clic en el botón de comando Salir.
El procedimiento cmdSalir_click sólo contiene la instrucción End, que da por
terminada la sesión de trabajo.

Matriz de controles
Como ya se vio en este libro en Visual Basic, la cantidad de nombres de elementos en
una interfaz está limitada. Es cierto que difícilmente agotará el número de nombres de
elementos, pero por simple sentido común, el hecho de que exista un límite






Capítulo 12: Controles contenedores y controles de selección 317
máximo nos habla de recursos limitados y ello nos habla a su vez de cierto consumo de
recursos por cada elemento definido (si no, ¿qué caso tendría limitarlos?).
En el caso de las variables, para hacer referencia a un conjunto de valores bajo un
mismo nombre, recurríamos a las matrices de una y dos dimensiones. Una vez definida
la matriz, los valores agrupados en ésta pueden ser referidos de manera particular a
través de un subíndice.
En el caso de los objetos en Visual Basic, es posible crear una matriz de ellos, deno-
minada matriz de controles. La forma de definirla es realmente muy sencilla: en el
momento en que intente nombrar dos objetos con el mismo nombre, Visual Basic le
dirá que ya existe un objeto con ese nombre, que si desea crear una matriz, de controles.
Suponga que ya agregó en su aplicación un cuadro de texto llamado txtNumero; al
momento de intentar agregar otro objeto con el mismo nombre. Visual Basic notificará
lo que se muestra en la figura 12.3.

Si usted contesta afirmativamente. Visual Basic creará una matriz de controles de-
nominada "txtNumero"; el primer objeto que agregó con dicho nombre, pasa a ser el
primer elemento de la matriz, es decir txtNumero con subíndice cero o txtNu-
mero(0). El segundo objeto será el segundo elemento de la matriz, es decir,
txtNumero(1). Una vez que define una matriz de controles, debe especificar un
subíndice.
El número de subíndice siempre inicia en cero y se incrementa en uno por cada objeto
que se agregue. A partir del segundo elemento. Visual Basic ya no preguntará si desea
agregar un objeto a la matriz de controles: basta con poner el mismo nombre a un objeto
que el de la matriz de controles creada, para que se agregue a dicha colección.
La existencia de subíndices simplifican el manejo de los objetos. Si tuviera 8 cuadros de
texto en su interfaz, implicaría la existencia de 8 objetos con nombre único; definirles
valor cero a todas seria como se muestra a continuación:








318 Parte 3: Controles gráficos y programación orientada a eventos

txtNumero1.Text = 0
txtNumero2.Text = 0
txtNumero3.Text = 0
txtNumero4.Text = 0
txtNumero5.Text = 0
txtNumero6.Text = 0
txtNumero7.Text = 0
txtNumero8.Text = 0
Si tiene una matriz de controles, puede hacerlo de la siguiente manera:
Dim intcontador As Integer
For intContador% = 0 to txtNumero.Ubound
txtNurnero(intContador%).Text = 0
Next intContador%
¿Qué pasaría si nos viéramos en la necesidad de agregar 20 objetos más a la interfaz?
Utilizando nombres de objetos diferentes para cada uno, necesitaríamos 20 líneas más
de código; utilizando una matriz de controles, ¡no necesitaríamos modificar nada!
La sintaxis de una matriz de controles es la siguiente:
Objeto (Subíndice) .{Propiedad | Método}
De tal forma que para conocer el texto contenido en la matriz de controles
txtNumero, en la posición 6, tendríamos que especificar lo siguiente:

txtNumero(6).Text
Y para transferir el enfoque a ese mismo elemento:
txtNumero(6).SetFocus
Para conocer el número de subíndice más pequeño de una matriz de controles, podemos
utilizar el nombre de la matriz de controles —sin subíndice, ya que no necesitamos
conocer nada de un elemento en especial, sino de la matriz entera— y la función
LBound...
Objeto.Lbound







Capítulo 12: Controles contenedores y controles de selección 319
... y para conocer el número del subíndice más alto, requerimos utilizar la función
UBound:
Objeto.UBound
Para leer una matriz de controles, también podemos hacer uso de la instrucción For
Each, que permite barrer una colección de objetos.
===================================================
Nota: La instrucción For Each siempre se apoya en una variable de trabajo; como
Visual Basic no sabe qué tipo de datos piensa manejar en una colección, sólo permite
que la variable de trabajo sea de upo Variant u Object.
Las variables de tipo Variant no ofrecen ninguna dificultad, pero las variables
Object deberán ser declaradas e inicializadas creando instancias de la clase en la cual
se basan, ya sea por asignación mediante la orden Set o a través de la instrucción New,
cuando no se desea realizar la asignación. El beneficio es que las variables Object
disponen de propiedades y métodos, determinados por la clase que las origina.
===================================================
>> Uso de una matriz de controles y su uso a través de For Next y For Each.
[12.03]
frmMatrizC.frm
A continuación aprenderá a definir una matriz de controles y a utilizarla a través de
estructuras de control.
Para ello definirá un formulario con 8 cuadros de texto, que tendrán el mismo nombre
(txtNumero) y que formarán una matriz de controles. Tendrá un botón que inicialice
los valores a cero, otro que valide que todos los valores capturados sean números y un
último evento que permite sumar todos los números capturados.










320 Parte 3: Controles gráficos y programación orientada a eventos
Implementación visual

Tabla de objetos y propiedades de frmMatrizC




Capítulo 12: Controles contenedores y controles de selección 321


Codificación de frmMatrizC
• Editar código: cmdIniciar, Evento: Click.
Dim intContador As Integer
For intContador% =0 To txtNumero.UBound
txtNumero(intContador%).Text = 0
Next intContador%
cmdValidar.Enabled = True
txtNumero(0).SetFocus
• Editar código: cmdValidar, Evento: Click.
Dim intContador As Integer
For intContador% = 0 To txtNumero.UBound
If Not IsNumeric(txtNumero(intContador%).Text) Then
MsgBox "Elemento " & intContador% + 1 & _
" equivocado", vbCritical, "Error"
txtNumero(intContador%).SetFocus
txtNumero(intContador%).SelStart = 0




322 Parte 3: Controles gráficos y programación orientada a eventos
txtNumero(intContador%).SelLength = _
Len(txtNumero(intContador%))
Exit Sub
End If
txtNumero(intContador%).Enabled = False
Next intContador%
cmdSumar.Enabled = True
cmdiniciar.Enabled = False
cmdValidar.Enabled = False
• Editar código: cmdSumar, Evento: Click
Dim Numero As Variant
Dim intSuma As Integer
For Each Numero In txtNumero
intSuma% = intSuma% + CInt(Numero)
Next Numero
lblSuma.Caption = Format(intSuma%, "Currency")
Ejecución
• Al ejecutar la aplicación, los cuadros de texto no tienen valores. Haga clic en
Inicializar (cmdiniciar).
El procedimiento cmdlniciar_click declarará una variable de tipo contador
(intContador%), para poder desarrollar una estructura For Next. Se
establecerá un ciclo, del cero al número de elementos de la matriz de controles
txtNumero (txtNumero. Ubound). El ciclo For Next incrementará en uno
el valor de intContador%, y permitirá asignar a cada elemento de
txtNumero, subíndice intContador%, el valor de cero en la propiedad Text.
Una vez que se inicializan todos los cuadros de texto, se habilita el botón Validar
(cmdValidar) y traslada el enfoque al primer elemento de la matriz de controles.
• Escriba números enteros, de preferencia menores a 1000. En uno de ellos incluya,
deliberadamente, una letra. Haga clic en el botón Validar (cmdValidar).
El procedimiento cmdValidar_Click analizará, a través de un For Next,
cada uno de los objetos de la matriz de controles en la búsqueda de valores que no
sean numéricos. Si uno de los elementos no es numérico, enviará un mensaje que







Capítulo 12: Controles contenedores y controles de selección 323
indicará el número de ese elemento, trasladará el enfoque al objeto que tiene el error, lo
marcará para su substitución y terminará el procedimiento.
En caso de que el elemento evaluado sea numérico, se inhabilitará a efecto de que ya no
pueda ser cambiado. Si todos los elementos de la colección contienen números, el ciclo
For Next no se interrumpirá (instrucción Exit Sub), habilitará el botón Sumar
(cmdSumar) e inhabilitará el resto de los botones.
Haga clic en el botón de comando Sumar (cmdSumar).
Ahora se analizará el contenido de la matriz de controles a través de For Each. El
procedimiento cmdSumar_Click declarará una variable de tipo Variant, a efecto
de almacenar los valores extraídos de la matriz de controles, y declarará una variable
llamada intSuma%, donde sumará los números que se encuentran en los objetos. Por
cada número (For Each Numero) que se encuentre en la colección txtNumero
(In txtNumero), se acumulará a intSuma% lo que valga la variable misma, más
la conversión a número de la propiedad Text del objeto que se esté evaluando en ese
momento. El ciclo continuará hasta que se hayan explorado todos los objetos de la
matriz de controles (colección).
El procedimiento también actualiza la propiedad Caption del objeto lblSuma, con
el valor que tenga intSuma% al concluir el proceso, con formato "Currency".
Colores en Visual Basic utilizando RGB y QBColor
Para los sistemas de cómputo todo es simbólico, es decir, las cosas poseen claves o
secuencias que significan algo. Los colores no son la excepción y Visual Basic los
identifica a través de un código de color, representado por un número de tipo Long.
Aprenderse los números de los colores puede ser una tarea ardua y es por ello que es
necesaria una manera sistemática de determinar dichos números. Visual Basic pro-
porciona las funciones RGB y QBColor para tal efecto.
RGB
RGB es el acrónimo de Red, Green, Blue (Rojo, Verde, Azul), que son los colores
básicos; a través de la combinación de dichos colores se pueden obtener una infinidad
de colores.
En el caso de Visual Basic, muchos objetos y funciones permiten que se les determine
un color; si usted así lo desea, puede especificar colores utilizando un código hexa-
decimal correspondiente al número de color que desea, o bien utilizar la función
RGB(), que devuelve un número de color.






324 Parte 3: Controles gráficos y programación orientada a eventos Sintaxis:
RGB (Red, Green, Blue)
Los argumentos Red, Green y Blue indican la cantidad de componente de un deter-
minado color dentro de una combinación de colores, en otras palabras, un valor de color
RGB especifica la intensidad relativa de rojo, verde y azul que hacen que se muestre un
color determinado. El intervalo de componente de color es de 0 a 255; el valor de
cualquier argumento para la función RGB que sea superior a 255 se considerará como
255. Por ejemplo, RGB(0,0,255) corresponde al color azul, ya que define el máximo
de componente azul, y nada del componente rojo ni del verde.
La siguiente tabla muestra algunos colores estándar y sus valores de rojo, verde y azul:

QBColor
QBColor es un convencionalismo heredado de Quick Basic, la antigua plataforma de
desarrollo BASIC de Microsoft. La función QBColor devuelve un número de color; es
más limitado que RGB, en virtud de que posee sólo 15 colores predefinidos (combina-
ciones básicas).
Sintaxis:
QBColor (Color)
El argumento Color es un número entero entre 0-15.







Capítulo 12: Controles contenedores y controles de selección 325
Los colores posibles para QBColor son los siguientes:

>> Uso de funciones RGB y QBColor para la manipulación de colores. [12.04]
A continuación aprenderá a utilizar las funciones de fecha y hora.
1. Genere un nuevo proyecto EXE estándar (Ctrl+N).
2. Establezca en la propiedad Name del formulario el valor "frmColor".
• Editar código: form. Evento: Activate.

MsgBox "Color base"
frmColor.BackColor = QBColor(10)
MsgBox "QBColor 10"
frmColor.BackColor = RGB(100, 200, 200)
MsgBox "RGB 100,200,200"
End


OptionButton
Botón de opción. Un control que permite seleccionar una opción; similar a las casillas
de verificación, con la diferencia de que OptionButton permite seleccionar sólo una
opción de entre varias.
OptionButton, por su misma naturaleza, debe ser manejado como matriz de controles, en
donde sólo uno de los elementos de la colección está seleccionado. Una cosa interesante es la
forma en que se manejan las propiedades y los eventos en una matriz de controles: cada uno de
los objetos, elementos que forman parte de la colec-


326 Parte 3: Controles gráficos y programación orientada a eventos
ción, tiene sus propiedades particulares, sin embargo, los eventos aplican a la matriz
de controles entera, por lo que existe la necesidad de identificar, en caso de ser nece-
sario, qué objeto de la colección provocó el evento. :
Lo más relevante de este control es:

>> Uso de objetos tipo OptionButton y Shape, y de una matriz de controles. [12.05]
frmSemaforo.frm
A continuación aprenderá a utilizar objetos de tipo OptionButton, en forma de
matriz de controles. También manejará los objetos de tipo Shape y las propiedades
de colores.
Implementación visual




Capítulo 12: Controles contenedores y controles de selección 327
Tabla de objetos y propiedades de frmSemaforo












328 Parte 3: Controles gráficos y programación orientada a eventos
Propiedades nuevas en frmSemaforo

Codificación de frmSemaforo
• Editar código: (General), Evento; (Declarations).
Dim intContador As Integer

• Editar código: Form, Evento; Load.

Call Apagar
OptOpcion(0).Value = True
ShpLuz(0).FillColor = RGB(255, 0, 0)

• Editar código: optOpcion, Evento: Click.
Call Apagar
If optOpcion(0).Value = True Then
shpLuz(0).FillColor = RGB(255, 0, 0)
Elself optOpcion(1).Value = True Then
shpLuz(1).FillColor = RGB(255, 255, 0)
Elself optOpcion(2).Value = True Then
shpLuz(2).FillColor = RGB(0, 255, 0)
End If

• Editar código: (General), Evento: Apagar.
For intContador% = 0 To 2
shpLuz(intContador%).FillColor = RGB(0, 0, 0)
Next intContador%

Capítulo 12: Controles contenedores y controles de selección 329
• Editar código: cmdSalir, Evento: Click.
End
==================================================
Nota: Los eventos del ejemplo, como Click, se ejecutan cada vez que usted los
solicita en cualquiera de los elementos de la matriz de controles. De ahí que tenga
que discriminar dentro del procedimiento, a fin de determinar qué objeto fue el que
causó el evento. En resumen, en una matriz de controles, las propiedades se aplican a
cada objeto, elemento de la colección, mientras que los eventos suceden a la matriz
de controles, sin importar en cuál de sus elementos haya sido causado.
==================================================


Ejecución
• Al cargar el formulario, se ejecuta el procedimiento Form_Load.
La aplicación posee dos matrices de controles: optOpcion, que con tres elementos
controla los OptionButton. y shpLuz. que con tres elementos controla los
objetos de tipo Shape. El procedimiento Form_Load ejecutará el procedimiento de
usuario llamado Apagar; dicho procedimiento utiliza un ciclo For Next, que se
encarga de cambiar el color de llenado para cada uno de los tres elementos de la
matriz de controles shpLuz, modificándole a cada elemento su propiedad
FillColor.
Una vez que se concluye la ejecución del procedimiento Apagar, todos los elementos
de la matriz de controles shpLuz están en color negro (RGB 0,0,0). Form_Load
se encarga de establecer el valor True al primer elemento de la matriz de controles
optOpcion y de cambiar a rojo (RGB 255,0,0) el color del primer elemento de
la matriz de controles shpLuz.

• Haga clic en el botón de radio Precaución.
Como hizo clic en alguno de los elementos de la matriz de controles, se solicita la
ejecución del procedimiento de evento ligado a dicha matriz de controles:
optOpcion_Click.
Cual sea la selección, se manda a ejecutar el procedimiento Apagar, que establece el
negro (RGB 0,0,0) como color de relleno para todos los elementos de la matriz de
controles shpLuz. Posteriormente, el procedimiento evaluará si la propiedad Value
del elemento de la matriz de controles optOpcion que posea el subíndice 0 tiene un
valor True; en ese caso, quiere decir que la señal seleccionada es la de Alto, y por
tanto asigna el color rojo (RGB 255,0,0) al elemento de la matriz de controles
shpLuz que posea el subíndice 0. Si eso no sucede, revisará la propiedad Value de
los elementos de la matriz de controles optOpcion con subíndice 1 y 2, y
dependiendo de cuál tenga el valor True, asignará el color





330 Parte 3: Controles gráficos y programación orientada a eventos
amarillo (RGB 255,255,0) o verde (RGB 0,255,0) a los elementos
correspondientes de la matriz de controles shpLuz.
Este procedimiento se ejecutará cada vez que seleccione una de las diferentes
opciones que constituyen sus botones de radio. Preste atención de que en el
momento que usted cambia el valor de un OptionButton. toda la matriz de
controles se actualiza, de tal forma que sólo uno de los elementos de la matriz de
controles tiene su propiedad Value establecida a True.
Haga clic en el botón de comando Salir.
El procedimiento cmdSalir_Click sólo contiene la instrucción End, que da
por terminada la sesión de trabajo.

HScrollBar y VScrollBar
Barras de desplazamiento horizontal y vertical. Estos dos controles guardan el
mismo funcionamiento. Consisten en un elemento que permite seleccionar de manera
gráfica un valor, a través de una barra de desplazamiento que delimita el valor míni-
mo y máximo.
Lo más relevante de este control es:

Cada objeto de tipo HScrollBar o VScrollBar se componen de lo siguiente:
• Contiene una barra de desplazamiento que indica un rango de valores de 0 a
32,767. El límite mínimo puede modificarse a través de la propiedad Min, mien-
tras que el máximo puede hacerse a través de la propiedad Max.
• La barra de desplazamiento tiene dos flechas en los extremos; dichas flechas son
de incremento/decremento. Son de incremento las que apunten a la derecha o
hacia arriba, son de decremento las que apunten a la izquierda o hacia abajo.
• Hay un indicador gráfico de valor, que es un apuntador que se encuentra en la
barra de desplazamiento, entre las flechas de incremento y decremento.
• Hacer clic en cualquiera de las flechas de incremento/decremento, provoca un
cambio en la propiedad Value del objeto y la ejecución del evento Change. El
cambio se realizará según se haya especificado en la propiedad SmallChange.





Capítulo 12: Controles contenedores y controles de selección 331
• Hacer clic en el espacio que existe entre el indicador gráfico de valor y cualquiera
de las flechas de incremento/decremento, provoca un cambio en la propiedad
Value del objeto y la ejecución del evento Change. El cambio se realizará
según se haya especificado en la propiedad LargeChange.
• Arrastrar el indicador gráfico de movimiento hace que la propiedad Value
cambie (una vez que deja de arrastrar el indicador), provocando el evento
Change. Mientras arrastra el indicador gráfico de valor, se ejecuta el evento
Scroll.

==================================================
Nota: Hacer clic en las flechas de incremento/decremento no siempre produce el
evento Change; un ejemplo sería cuando llega al límite inferior o superior del rango
de valor: no es posible que la propiedad Value vaya más allá, nunca se da un cam-
bio de valor, y por tanto el evento Change.
Al arrastrar el indicador gráfico de valor es posible que no se provoque el evento
Change, si al finalizar el arrastre, el indicador se coloca en la posición inicial que
tenía; por tanto, el valor es el mismo, no cambia. El evento Scroll, sin embargo,
sucederá sin importar que el valor final de la labor de arrastre sea el mismo que tenía
al principio.
==================================================
Gráficamente, la figura 12.6 muestra las particularidades de los objetos ScrollBar.














332 Parte 3: Controles gráficos y programación orientada a eventos
>> Uso de barras de desplazamiento y números aleatorios. [12.06]
frmColorido.frm
A continuación aprenderá a utilizar los objetos HScrollBar, así como procesos
aleatorios y funciones de manipulación de colores.
Implementación visual













Capítulo 12: Controles contenedores y controles de selección 333
Tabla de objetos y propiedades de frmColorido





334 Parte 3: Controles gráficos y programación orientada a eventos
Propiedades nuevas en frmColorido

Eventos nuevos en frmColorido

Codificación de frmColorido
• Editar código: (General), Evento: Colorear.
lblColor.BackColor = RGB(hsbRojo.Value, _
hsbVerde.Value, _
hsbAzul.Value)
lblColor.ForeColor = RGB(255 - hsbRojo.Value, _
255 - hsbVerde.Value, _
255 - hsbAzul.Value)
lblColor.Caption = "RGB(" & _
Str(hsbRojo.Value) & "," & _
Str(hsbVerde.Value) & "," & _
Str(hsbAzul.Value) & ")"




Capítulo 12: Controjes contenedores y controles de selección 335
• Editar Código; Form, Evento:Load
Call Colorear
• Editar código: hsbAzul, Evento: Change.
Call Colorear

• Editar código: hsbRojo, Evento: Change.
Call Colorear
• Editar código: hsbVerde, Evento: Change.
Call Colorear

• Editar código: cmdAleatorio, Evento: Click.
hsbRojo.Value = Int(Rnd * 255)
hsbVerde.Value = Int(Rnd * 255)
hsbAzul.Value = Int(Rnd * 255)

• Editar código: cmdSalir, Evento: Click.
End
Ejecución
• Al iniciar la ejecución, Form_Load ejecuta el procedimiento definido por el
usuario Colorear.
La aplicación tiene una etiqueta que desplegará los resultados (lblcolor).
Este objeto verá modificada su propiedad BackColor, que establecerá el
color de fondo, y su propiedad ForeColor, que modificará el color del texto
que se encuentre en el objeto. La lógica del programa nos indica que
mediante la manipulación de las barras de desplazamiento se alterará el
valor relativo de rojo, verde





336 Parte 3: Controles gráficos y programación orientada a eventos
y azul que le será asignado al fondo del objeto lblColor. Como comprenderá, el
texto contenido en el objeto no puede ser del mismo color que el fondo de éste, ya
que se perdería, no sería visible.
El procedimiento definido por el usuario Colorear es el más importante de esta
aplicación; asigna un color de fondo al objeto lblColor, (propiedad
BackColor), con base en los valores que tengan las barras de desplazamiento
hsbRojo, hsbVerde y hsbAzul. Como el contenido de dicho objeto no puede
ser igual al del fondo, determinamos que restándole el valor propuesto de cada color
a 255, obtenemos un número de color contrastante con el fondo. El procedimiento
Colorear también se encarga de determinar el número de color para la propiedad
ForeColor, que es el contraste del color del fondo, y de modificar la propiedad
Caption del objeto lblColor, de tal forma que despliegue el código RGB que ha
sido asignado al fondo.
Como actualmente los objetos de tipo HScrollBar están establecidos a cero, el
color del fondo será negro, correspondiente a RGB 0,0,0.
• Utilizando las flechas de incremento/decremento de las barras de desplazamiento,
modifique el color.
El procedimiento Colorear actualizará tanto el color del fondo de lblColor,
como del contenido y el texto desplegado.
• Arrastre el indicador gráfico de valor hasta el 255 de la gama de rojo.
Mientras arrastra el indicador gráfico de valor a la posición indicada, no sucede nada.
Mientras no deje de arrastrarlo, el evento Change no sucede. Lo ideal es que cuando
esté arrastrando el indicador gráfico de valor, el color y el mensaje informativo varíe,
a fin de darle mayor dinamismo.
Agregue el siguiente código.
• Editar código: hsbAzul, Evento: Scroll.
Call Colorear
• Editar código: hsbRojo, Evento: Scroll.
Call Colorear
• Editar código: hsbVerde, Evento: Scroll.
Call Colorear




Capítulo 12: Controles contenedores y controles de selección 337
• Arrastre el indicador gráfico de valor hasta el 0 de la gama de rojo.
Como ya se incluyó la ejecución de colorear en el evento Scroll de las barras de
desplazamiento, el funcionamiento del programa es transparente y dinámico.
• Haga clic en el botón Aleatorio.
Se ejecutará el procedimiento cmdAleatorio_Click, que asignará nuevos va-
lores para cada una de las barras de desplazamiento de color; para ello utiliza la
función Rnd, que devuelve un número decimal del 0 al 1; determinando el valor
entero del resultado de multiplicar Rnd por 255, obtenemos un número de color
válido.
• Haga clic en las flechas de incremento/decremento, y en la barra de desplazamiento
entre una de las flechas de incremento/decremento y el indicador gráfico de valor.
Podrá darse cuenta que al hacer clic en la flecha de incremento/decremento, el
cambio de valor se da sólo en la cantidad especificada en la propiedad
SmallChange, mientras que hacer clic en la barra de desplazamiento entre una de
las flechas de incremento/decremento y el indicador gráfico de valor, causará un
cambio en la cantidad especificada en la propiedad LargeChange.
• Haga clic en el botón Salir.
Se ejecutará el procedimiento cmdSalir_Clic. La instrucción End concluye con
la ejecución del programa.
________________________________________________
Resumen
En este capítulo:
• Vimos qué son los objetos contenedores
• Vimos las particularidades del control Frame
• Vimos las particularidades del control CheckBox
• Vimos la forma de manipular propiedades Font de un texto
• Vimos qué son las matrices de controles y cómo pueden ser utilizadas
• Vimos cómo manejar colores en Visual Basic a través de las funciones RGB y
QBColor















338 Parte 3: Controles gráficos y programación orientada a eventos
• Vimos las particularidades del control OptionButton
• Vimos las particularidades de los controles HScrollBar y VScrollBar
• Vimos el uso de la función Rnd para generar números aleatorios
Es importante que domine el contenido del capítulo para poder continuar, ya que en
el resto del libro se manejarán de manera intensiva objetos basados en estos
controles.






















































Capítulo
13
Controles de listas
desplegables
Objetivo
Conocer el uso de los controles que generan listas desplegables, analizando sus par-
ticularidades y capacidades.
Al finalizar este capítulo deberá:
• Entender el concepto de Colección
• Dominar el uso del control ListBox
• Conocer cómo agregar y eliminar elementos de un control de lista desplegable
• Saber manejar objetos ListBox que permitan seleccionar múltiples opciones
• Saber cómo definir objetos ListBox de estilo Check
• Dominar el uso del control ComboBox
• Saber cómo desarrollar un ComboBox sensible al teclado
339


340 Parte 3: Controles gráficos y programación orientada a eventos

Concepto de colección
En este capítulo utilizaremos un género de objetos que proporcionan mucha versati-
lidad a Visual Basic: las colecciones.
Una colección es un grupo de elementos con nombre, constituido por componentes de
una misma naturaleza que se encuentran relacionados.
Imagine un equipo de fútbol: el equipo tiene un nombre, tiene sus estadísticas de jue-
gos ganados, empatados y perdidos, tiene un desempeño general por equipo, tiene una
plaza a la que pertenece, así como colores que lo distinguen: como equipo es
claramente identificable; sin embargo, posee elementos, jugadores, identificados con
un número, cada uno con sus propias capacidades particulares, sus virtudes y defectos
que los distinguen. Así, podríamos decir que el equipo es una colección de jugadores.
El equipo sin jugadores no es nada, el jugador sin equipo no es nadie. Hacemos esta
analogía porque las colecciones son de una manera muy similar.
Algunas de las características de las colecciones son:
• La colección tiene un nombre de objeto que identifica a un grupo de elementos
(elementos de la colección).
• Los elementos que constituyen la colección siempre se identifican a través de un
número entero, único, que actúa como subíndice y al que se le llama Índice. Al-
gunas colecciones también permiten una identificación de tipo String (general-
mente llamada Tag o Key) adicional a Índice, que en ningún caso lo sustituye.
• La colección posee propiedades inherentes a la colección en sí.
• La colección tiene sus eventos y métodos que afectan a toda la colección.
• Los elementos de la colección poseen propiedades particulares.
• Los elementos de una colección tienen sus eventos, pero es necesario determinar
qué elemento de la colección causó dichos eventos; en algunos casos, el evento
proporciona el número de Índice que lo causó, a manera de argumento implícito.
• Los elementos de la colección por lo general son referenciados a través de alguna
de sus especificaciones, es decir, sólo se pueden llamar a través de alguna de sus
propiedades. .
Los objetos de lista desplegable ListBox y ComboBox son ejemplos de
colecciones.






Capitulo 13: Controles de listas desplegables 341
Suponga que tiene un objeto ListBox llamado lstOpciones. que tiene los
siguientes elementos definidos: "Primero", "Segundo" y "Tercero"; la figura 13.1
ilustra cómo sería la colección:

Si quisiera saber cuántos elementos tiene la colección e imprimir el resultado en pan-
talla, utilizaría una propiedad a nivel colección:
Print lstOpciones.ListCount
Como ve, no es necesario hacer alusión alguna a los elementos contenidos, ni a
especificación alguna; sólo basta el nombre del objeto y el de la propiedad. En cam-
bio, si quisiera saber la propiedad List de alguno de los elementos, tiene que
señalar a qué colección pertenece, qué propiedad desea conocer (especificación) y
qué número de Index tiene. Si quiere imprimir en pantalla la especificación List
del elemento que posee el Index 1, en la colección lstOpciones. requiere lo
siguiente:
Print lstOpciones.List( 1 )








342 Parte 3: Controles gráficos y programación orientada a eventos

Listas desplegables: ListBox y ComboBox
Los objetos de lista desplegable en Visual Basic son 2: ListBox y ComboBox. Son
elementos característicos en el entorno de Windows, a través de los cuales es posible
seleccionar de una lista uno o más objetos.
Se recomienda el uso de los objetos de lista desplegable para economizar espacio en
la interfaz; éstos poseen barras de desplazamiento implícitas, lo que permite visua-
lizar muchas opciones en un espacio reducido. Suponga que a través de la interfaz el
usuario debe elegir una opción de entre 30; utilizar botones de opción sería poco prác-
tico, ya que ocuparían mucho espacio, por lo que un objeto ComboBox sería lo más
recomendable. En caso de que deba escoger más de una opción de entre 30 opciones
disponibles, el uso de objetos de tipo CheckBox sería también poco práctico por
cuestiones de espacio, siendo recomendable usar uno de tipo ListBox.

En resumen, podemos decir que:
• La diferencia entre ListBox y ComboBox es que ListBox permite seleccionar
más de una opción, mientras que ComboBox sólo permite la selección de una. Otra
diferencia es que ComboBox posee un cuadro de texto, donde se puede escribir
información, mientras que ListBox no tiene cuadro de texto.
• Ambos objetos, en caso de que no dispongan de espacio en la interfaz para mostrar
las opciones que tienen definidas, dispondrán de una barra de desplazamiento que
aparece automáticamente.
• En el caso del objeto ListBox, el evento Click sucede cuando hace clic en el
objeto, seleccionando una opción. En el caso de ComboBox, el evento Click su-
cede cuando selecciona una opción de las que aparecen en la lista desplegable que
se muestra una vez que hace clic en la flecha de expansión, que aparece a la
derecha del objeto.
• En el caso de ComboBox, el evento Change sucede cuando modifica el contenido
del cuadro de texto del cuadro combinado. Puesto que ListBox no dispone de
cuadro de texto, no posee evento Change.




Capítulo 13: Controles de listas desplegables 343
La figura 13.2 muestra la forma en que lucen en una interfaz los objetos de
lista desplegable.


Cómo agregar y eliminar opciones de las listas
desplegables
Los objetos de lista desplegable permiten la selección de opciones, eso está muy
claro, pero ¿dónde se definen las opciones? En el caso de este tipo de objetos, las
opciones no pueden ser definidas en tiempo de diseño, por lo cual su adición debe
ser mediante código; debido a eso, su actualización se realiza en tiempo de
ejecución, de forma dinámica.
Método Additem
Para agregar opciones a un objeto dé lista desplegable, debe utilizar el método
AddItem.
Sintaxis:
ObjetoListaDesplegable . AddItem Elemento [ , Índice ]











344 Parte 3: Controles gráficos y programación orientada a eventos
En ObjetoListaDesplegable puede utilizar un objeto ListBox o ComboBox. El
argumento Elemento solicita una expresión de tipo String que aparecerá como
opción en el objeto; el argumento Índice, que es opcional, será el número que le
asigne a la opción dentro del conjunto de opciones. El Índice debe ser único, por lo
que dentro de un objeto no puede haber dos opciones con el mismo Índice. El Índice
comienza, de manera predeterminada, en el número cero.
Suponga que tiene definida una lista desplegable llamada lstOpciones; para
agregarle las opciones "Primera", "Segunda", "Tercera", "Cuarta" y
"Quinta", debería utilizar el método Additem de la siguiente forma:
lstOpciones.Additem "Primera"
lstOpciones.Additem "Segunda"
lstOpciones.Additem "Tercera"
lstOpciones.Additem "Cuarta"
lstOpciones.Additem "Quinta"
debido a que se omitió el argumento Índice, a "Primera" le correspondió de
manera predeterminada el Índice 0, a "Segunda" le correspondió el Índice 1, y así
sucesivamente hasta "Quinta", que le correspondió el Índice 4.

Propiedad ListCount
Para conocer cuántos elementos tiene un objeto de lista desplegable, es necesario que
utilice la propiedad ListCount, que contiene dicho valor.
Sintaxis:
ObjetoListaDesplegable. ListCount
En ObjetoListaDesplegable puede utilizar un objeto ListBox o ComboBox del
que se quiere conocer el número de elementos.
Si se utilizaron los valores Índice predeterminados, ListCount valdrá uno más que
el último Índice asignado; en nuestro ejemplo la opción "Quinta" es la última op-
ción agregada al objeto lstOpciones, y le correspondió el índice 4. Sin embargo,
ListCount, valdrá 5, ya que realmente lstOpciones posee 5 elementos.
Esto es importante porque al trabajar con objetos de lista desplegable, será muy
común explorar todas las opciones para ejecutar diversas tareas.









Capítulo 13: Controles de listas desplegables 345
Si quiere desplegar en pantalla el numero de elementos del objeto ListBox
utilizado de ejemplo, tendría lo siguiente:
Print lstObjetos.ListCount
Propiedad List
Los objetos de lista desplegable actúan como una pequeña colección, es decir, están
compuestos por un conjunto de elementos, los cuales tienen sus propiedades particu-
lares. Existen propiedades, tales como ListCount, que se aplican a la colección
entera, sin embargo, existen otras que les son particulares de los elementos con-
tenidos en el objeto; tal es el caso de la propiedad List.
La propiedad List devuelve o establece el argumento Elemento, utilizado al
agregar una opción a un objeto de lista desplegable, a través del método Additem.
Sintaxis:

ObjetoListaDesplegable.List( Índice )
En ObjetoListaDesplegable puede utilizar un objeto ListBox o ComboBox donde
está definido el elemento. Índice es el número de índice del elemento del que desea
conocer la especificación Elemento.
Por ejemplo, para conocer la especificación Elemento del elemento del objeto lstOp-
ciones que tenga el Índice 3, sería:
lstOpciones.List(3)
Por ejemplo, el siguiente código serviría para imprimir la especificación Elemento de
todos los elementos del objeto lstOpciones:
Dim intContador As Integer
For intContador% = 0 to lstOpciones.ListCount - 1
Print "Index; " & intContador% & " Item; " & _
lstOpciones.List(intContador%)
Next intContador%














346 Parte 3: Controles gráficos y programación orientada a eventos
Lo que proporcionaría el siguiente resultado:
Index: 0 Item; Primera
Index: 1 Item: Segunda
Index: 2 Item: Tercera
Index: 3 Item: Cuarta
Index: 4 Item: Quinta

Propiedades Selected y ListIndex
Otra propiedad particular de los elementos que componen un objeto de lista des-
plegable es si han sido seleccionados o no. En el caso de los objetos ListBox, nin-
guna, una o más de una de las opciones pueden estar seleccionadas, mientras que en
los objetos ComboBox. ninguna o una puede estar seleccionada.
Para determinar si un elemento está o no seleccionado, puede utilizar la propiedad
Selected.
Sintaxis:
ObjetoListaDesplegable. Selected ( Índice )
En ObjetoListaDesplegable puede utilizar un objeto ListBox o ComboBox donde
está definido el elemento, Índice es el número de índice del elemento del que desea
saber si está o no seleccionado. Selected tendrá el valor de True si el elemento
está seleccionado, y False si no lo está.
Por ejemplo, si quisiera que un programa le informara el estado de selección en que
se encuentra el elemento con Índice 3 del objeto lstOpciones, el código sería el
siguiente:
If lstOpciones.Selected(3) = True Then
MsgBox "El elemento 3 está seleccionado"
Else
MsgBox "El elemento 3 no está seleccionado"
End If
El siguiente código serviría para informar qué elementos del objeto lstOpciones
están seleccionados:






Capítulo 13: Controles de listas desplegables 347

Dim intContador As Integer
For intContador% = 0 to lstOpciones.ListCount - 1
If lstOpciones.Selected(intContador%) = True Then
Print "El elemento " & intContador% " está seleccionado"
End If
Next intContador% '
Por ejemplo, si al ejecutar el código estuvieran seleccionados los elementos 1, 2 y 4,
el resultado sería:
El elemento 1 está seleccionado
El elemento 2 está seleccionado
El elemento 4 está seleccionado
En caso de que usted sólo seleccione una opción, puede conocer cuál fue selecciona-
da sin necesidad de explorar todos los elementos para conocer cuál tiene la propiedad
Selected establecida a True. La propiedad Listindex proporciona ese valor.
En nuestro ejemplo, para conocer cuál ha sido seleccionada, puede escribir el si-
guiente código para el evento Click del objeto lstOpciones:
Private Sub lstOpciones_Click()
MsgBox "Seleccionado el elemento: " & _
lstOpciones.ListIndex
MsgBox "Su especificación Elemento:" & _
lstOpciones.List(List1.ListIndex)
End Sub
Método RemoveItem
Si desea eliminar un elemento de un objeto de lista desplegable, debe utilizar el
método Removeltem.











348 Parte 3: Controles gráficos y programación orientada a eventos
Sintaxis:
ObjetoListaDesplegable .RemoveItem Índice
En ObjetoListaDesplegable puede utilizar un objeto ListBox o ComboBox. El
argumento Índice es el número de índice del elemento a eliminar; para eliminarlo, es
necesario determinar primero qué índice tiene.
Por ejemplo, para eliminar el elemento del objeto lstOpciones que tenga el
Índice 3, sería:
lstOpciones.RemoveItem 3
Al eliminar un elemento, los valores Índice restantes se actualizan, de tal forma que
no quedan espacios intermedios.
Método Clear
Es posible eliminar todos los elementos de un objeto de lista desplegable. Puede
eliminarlos uno por uno; sin embargo, el hecho de que ajusten su Índice, hace nece-
sario que se valga de ciertos trucos para eliminarlos de atrás para adelante. Por ejem-
plo, si desea eliminar los elementos del objeto lstOpciones, el código podría ser
el siguiente:
Dim intContador As Integer
For intContador% = lstOpciones.ListCount - 1 To 0 Step –1
lstOpciones.Removeltem intContador%
Next intContador%
Una forma más fácil es utilizar el método Clear, pues hace lo mismo.
Sintaxis:
ObjetoListaDesplegable . Clear
En ObjetoListaDesplegable puede utilizar un objeto ListBox o ComboBox al que
desea eliminarle los elementos.
El método Clear tendrá aplicación práctica cuando el contenido de una lista de-
penda de otro valor en la interfaz; si por alguna razón éste es eliminado, Clear lo
apoyará en la congruencia de su interfaz, ya que si el dato que da lugar a las op-







Capítulo 13: Controles de listas desplegables 349
ciones de la lista no existe, los elementos de dicha lista no deben existir, en conse-
cuencia. Suponga que tiene dos datos: país y estados, estos últimos a través de un
ComboBox; si no conoce el país del que estamos hablando ¿qué estados mostrará en
el ComboBox?
>> Utilización de un objeto ListBox, agregándole y eliminándole elementos de
forma dinámica. [13.01]
frmVisita.frm
Aprenderá a utilizar un objeto de tipo ListBox, agregando y eliminando elementos,
mismos que serán capturados en un cuadro de texto. La aplicación no permitirá que
se repitan elementos, calculará siempre cuántos componen la colección, y a través de
doble clic, seleccionará como favonio alguno de la lista.
Implementación visual



















350 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmvisita


Capítulo 13: Controles de listas desplegables 351
Propiedades nuevas en frmvisita

Métodos nuevos en frmvisita

Codificación de frmvisita
• Editar código: cmdAgregar, Evento: Click.
If txtRespuesta.Text = "" Then
MsgBox "Nada qué agregar", vbinformation, "Visitante"
Exit Sub
End If
If lstCiudades.ListCount > 0 Then
Dim intContador As Integer
For intContador% = 0 To lstCiudades.ListCount - 1
If txtRespuesta.Text = lstCiudades.List(intContador%) Then
MsgBox "Esa ciudad ya existe", vbinformation, "Visitante"








352 Parte 3: Controles gráficos y programación orientada a eventos
Exit Sub
End If
Next intContador%
End If
lstCiudades.AddItem txtRespuesta.Text
lstCiudades.Refresh
lblElementos.Caption = Str(lstCiudades.ListCount)
txtRespuesta.Text = ""
• Editar código: lstCiudades, Evento: DblClick.
If lstCiudades.ListCount >= 0 Then
lblFavorita.Caption = lstCiudades.List(lstCiudades.Listindex)
End If
• Editar código: cmdEliminar, Evento: Click.
If lstCiudades.ListCount >= 0 Then
Dim intContador As Integer
For intContador% = 0 To lstCiudades.ListCount - 1
If lstCiudades.Selected(intContador%) = True Then
If lblFavorita.Caption = lstCiudades.List(intContador%) Then
lblFavorita.Caption = ""
End If
lstCiudades. RemoveItem intContador%
lstCiudades.Refresh
lblElementos.Caption = Str(lstCiudades.ListCount)
Exit Sub
End If
Next intContador%
End If

• Editar código: cmdSalir, Evento: Click.
End
Ejecución
• No escriba nada en el cuadro de texto. Presione Intro.








Capítulo 13: Controles de lista s desplegables 353
En vlsta de que el botón Agregar (cmdAgregar) está definido como predetermi-
nado, al presionar Intro se ejecuta el procedimiento cmdAgregar_Click. Éste
realiza una validación: si la propiedad Text del cuadro de texto (txtRespuesta)
está vacío (""), entonces reportará un mensaje de error y terminará con la ejecución
del procedimiento.
• Escriba en el cuadro de texto el nombre de una ciudad que haya visitado en su vida.
Presione Intro. Vuelva a escrlblr el mismo nombre de ciudad y presione Intro.
El procedimiento cmdAgregar_Click, después de validar que el cuadro de texto
no está vacío, procede a validar si lo que se escrlbló en el cuadro de texto es un
elemento del objeto de lista desplegable.
Ejecuta un ciclo a través de la instrucción For Next, por el numero exacto de
elementos de la lista desplegable; en caso de encontrar algún elemento cuya es-
pecificación Elemento sea igual a lo que se intenta agregar, enviará un mensaje de
error y terminará la ejecución del procedimiento.
En caso de que el cuadro de texto no esté vacío y que la ciudad que desea agregar no
se encuentre en el objeto de lista desplegable, el programa procede a agregar un
elemento (AddItem), actualiza visualmente el objeto de lista desplegable
(Refresh), actualiza la etiqueta que muestra el total de elementos que tiene el
objeto de lista desplegable (lblElementos) e inicializa el cuadro de texto para
una nueva captura.
• Agregue 10 ciudades más. Esperamos que sean suficientes para que vea la aparición
automática de la barra de desplazamiento.
• Haga doble clic en la ciudad que más le haya gustado, para seleccionarla como su
favorita.
El procedimiento lstCiudades_DblClick se ejecutará. Dicho procedimiento
sólo hará algo si el número de elementos del objeto de lista desplegable es mayor a
cero (tiene elementos). Establecerá el valor de la propiedad Caption del objeto
lblFavorita con la especificación Elemento (lstCiudades.List) del
elemento seleccionado (lstCiudades.ListIndex).
• Haga clic para seleccionar la ciudad que eligió como favorita. Haga clic en el botón
Eliminar (cmdEliminar).
El procedimiento cmdEliminar_Cllck se ejecutará. Dicho procedimiento sólo
hará algo si el número de elementos del objeto de lista desplegable es mayor a cero
(tiene elementos).
Ejecuta un ciclo a través de la instrucción For Next, el número exacto de ele-
mentos de la lista desplegable; en caso de encontrar algún elemento cuya especi-
ficación de selección (Selected) sea verdadera (True), revisará si la espe-
cificación Elemento es igual a la propiedad Caption del objeto lblFavorita;
en












354 Parte 3: Controles gráficos y programación orientada a eventos

caso de ser así, cambiará la propiedad Caption a vacío (""). Procede entonces a
eliminar el elemento (RemoveItem), actualiza visualmente el objeto de lista des-
plegable (Refresh) y actualiza la etiqueta que muestra el total de elementos que tiene
el objeto de lista desplegable (lblElementos). Estará de acuerdo en que si la ciudad
que eligió como favorita no es la que desea borrar, la propiedad Caption de
lblFavorita no se modifica; si una ciudad está definida como la favorita y usted la
borra, sería incongruente no cambiar a vacío la propiedad Caption de lblFavorita,
ya que estaría como favorita una ciudad que no aparece en la lista .
• Haga clic en el botón de comando Salir.
El procedimiento cmdSalir_Click sólo contiene la instrucción End, que da por
terminada la sesión de trabajo.
>> Uso de objetos ListBox de selección múltiple, que pasan elementos de una
lista a otra. [13.02]
frmDeporte.frm
A continuación aprenderá a utilizar los objetos ListBox para pasar opciones "de un
lado a otro". En esta aplicación se verá también la capacidad de selección múltiple de
los objetos ListBox.
Implementación visual









Capítulo 13: Controles de listas desplegables 355
Tabla de objetos y propiedades de frmDeporte

Propiedades nuevas en frmDeporte



Codificación de frmDeporte
• Editar código: Form, Evento: Activate.

lstIzquierda.AddItem "Aerobics"
lstIzquierda.Additem "Karate"
lstIzquierda.AddItem "Fútbol soccer"
lstIzquierda.AddItem "Fútbol americano"





356 Parte 3: Controles gráficos y programación orientada a eventos
lstIzquierda.AddItem "Gimnasia"
lstIzquierda.AddItem "Baloncesto"
lstIzquierda.AddItem "Golf"
• Editar código: (General), Evento: Botones.
If lstIzquierda.ListCount = 0 Then
cmdAgregar.Enabled = False
Else
cmdAgregar.Enabled = True
End If
If lstDerecha.ListCount = 0 Then
cmdEliminar.Enabled = False
Else
cmdEliminar.Enabled = True
End If
• Editar código: cmdAgregar, Evento: Click.
Dim intContador As Integer
For intContador% = lstIzquierda.ListCount - 1 To 0 Step -1
If lstIzquierda.Selected(intContador%) Then
lstDerecha.AddItem lstIzquierda.List(intContador%)
lstIzquierda.RemoveItem intContador%
End If
Next intContador%
Call Botones
• Editar código: cmdEliminar, Evento: Click.
Dim intContador As Integer
For intContador% = lstDerecha.ListCount - 1 To 0 Step -1
If lstDerecha.Selected(intContador%) Then
lstIzquierda.AddItem lstDerecha.List(intContador%)
lstDerecha.RemoveItem intContador%
End If
Next intContador%
Call Botones




Capítulo 13: Controles de lista s desplegables 357

Ejecución
• Al activarse el formulario, se ejecuta el procedimiento Form_Activate, que se
encarga de definir los elementos del objeto de lista desplegable que se encuentra
a la izquierda (lstIzquierda).
• Se definió un procedimiento de evento denominado Botones, que se encarga de
evaluar el número de elementos que tiene cada uno de los dos objetos de lista
desplegable (lstIzquierda y lstDerecha). En caso de que
lstIzquierda no tenga elementos, el botón para pasarlos a la derecha
(cmdAgregar) se inhabilita;
si lstDerecha no tiene elementos, el botón para pasarlos a la izquierda
(cmdEliminar) se inhabilita.
• Seleccione la opción "Golf”. Haga clic en el botón para pasar elementos a la
derecha (">>").
Se ejecutará el evento cmdAgregar_Click, el cual a través de la instrucción
For Next de conteo decreciente evalúa los elementos de la lista lstizquierda,
desde el elemento de mayor índice (lstIzquierda.ListCount - 1), hasta
cero. Si en la evaluación detecta que uno de los elementos se encuentra
seleccionado, agrega el elemento a la lista lstDerecha, para posteriormente
eliminarlo de lstizquierda. Al eliminar elementos, el numero de ellos
(ListCount) se recalcula lo que puede crear conflictos; si la instrucción For
Next fuera de conteo creciente (de cero hasta el elemento de mayor índice, en
nuestro ejemplo, de 0 a 6), al eliminar uno, el elemento de mayor índice sería 5 (6-
1), pero For Next no se podría dar cuenta. Al requerir alguna tarea en el
elemento de índice 6, éste ya no existirá, lo que generará error.
El procedimiento cmdEliminar_Click hace exactamente lo mismo, a reserva
de que en lugar de explorar en lstizquierda lo hace en lstDerecha, y en
lugar de agregar elementos en lstDerecha, agrega en lstizquierda.
Ambos procedimientos ejecutan, al final, el procedimiento Botones, mismo que se
encarga de habilitar o inhabilitar los botones de la aplicación.
• Seleccione la opción "Aerobios", "Gimnasia" y "Karate" al mismo tiempo. Para ello
puede hacer clic en cada uno de los elementos mientras mantiene presionada la tecla
Ctrl. Haga clic en el botón para pasar elementos a la derecha (">>").
Se ejecutará el evento cmdAgregar_Click, funciona igual para un elemento
seleccionado que para varios. Aquí comprobó la capacidad de remover la selección
múltiple del objeto ListBox.












358 Parte 3: Controles gráficos y programación orientada a eventos
>> Uso de un objeto ListBox con estilo CheckBox. [13.03]
frminstala.frm

A continuación aprenderá a utilizar un objeto ListBox con estilo CheckBox.
Calculará la cantidad de bytes consumidos en una instalación, apoyándose en una
matriz.
Implementación visual


Tabla de objetos y propiedades de frmInstala








Capítulo 13: Controles de listas desplegables 359

Eventos nuevos en frminstala

==================================================
Nota: Para guardar coherencia con la terminología manejada hasta ahora, lo ideal
es que el argumento implícito se llamara Índice y no Elemento, ya que Visual Basic
describe como Elemento a la especificación String del elemento, e Índice está aso-
ciado al número de elemento. Hacemos la anotación para evitar confusiones.
==================================================

Codificación de frmInstala
• Editar código: (General), Evento: (Declarations).

Dim dblConsumo(0 To 5) As Double
Dim dblRequerido As Double
• Editar código: Forrn, Evento: Load.

lstComponentes.Additem "Contabilidad"
lstComponentes.Additem "Cuentas por pagar
1
"
lstComponentes.Additem "Cuentas por cobrar"
lstComponentes.Additem "Chequera"
lstComponentes.Additem "Facturación"
lstComponentes.Additem "Inventarios"









360 Parte 3: Controles gráficos y programación orientada a eventos
dblConsumo#(0) = 2356382
dblConsumo#(1) = 763782
dblConsumo#(2) = 956384
dblConsumo#(3) = 529920
dblConsumo#(4) = 1353383
dblConsumo#(5) = 1500382
lblRequerido.Caption = "0 Bytes"
• Editar código: lstComponentes, Evento: ItemCheck.
Private Sub lstComponentes_ItemCheck(Item As Integer)
If lstComponentes.Selected(Item) = True Then
dblRequerido# = dblRequerido# + dblConsumo#(Item)
Else
dblRequerido# = dblRequerido# - dblConsumo#(Item)
End If
lblRequerido.Caption = Format(dblRequerido#, "##,###,##0") & " Bytes"
End Sub
• Editar código: cmdinstala. Evento: Click.
MsgBox "Procede a instalar", vbinformation, "Instala"
End :
Ejecución
• En el apartado de declaraciones generales se define una matriz (dblConsumo).
con el mismo número de elementos que el objeto de lista desplegable (lstCom-
ponentes), que por cierto es de estilo CheckBox: en cada elemento de la matriz
se almacenará el consumo en bytes del elemento de la lista desplegable con quien
comparte el subíndice, es decir, el elemento 0 de la lista tendrá almacenado su
consumo en bytes en el elemento 0 del arreglo, el elemento 1 de la lista tendrá
almacenado su consumo en bytes en el elemento 1 del arreglo, y así sucesivamente.
También se define una variable de tipo Double que se encargará de almacenar la
cantidad de bytes acumulados, derivado de las múltiples selecciones que se
realicen; de inicio, dicha variable tiene valor cero.
• Al cargarse el formulario, se ejecuta el procedimiento Form_Load.
Este procedimiento se encarga de agregar elementos al objeto de lista desplegable
(lstComponentes), y almacena en los elementos de la matriz (dblConsumo)





Capítulo 13: Controles de listas desplegables 361
el consumo en bytes de cada uno de los elementos de la lista . Finalmente asigna a la
propiedad Caption del objeto LblRequerido. el valor "0 Bytes", en virtud
de que al arrancar el programa, ninguno de los elementos de la lista desplegable está
seleccionado.
• Active cualquiera de los elementos de la lista desplegable.
Al momento en que activa o desactiva cualquier elemento de la lista , se ejecuta el
procedimiento lstComponentes_ItemCheck; dicho procedimiento de evento
posee un argumento implícito, llamado Elemento, que devuelve el número Índice del
elemento seleccionado. Como las cantidades almacenadas en la matriz guardan
correspondencia con el número de elementos de la lista desplegable, se puede hacer
lo siguiente: si está seleccionado (Selected) el elemento cuyo Índice es igual al
valor devuelto en el argumento implícito (Elemento), entonces dblRequerido será
igual al valor que ya tiene, más la cantidad de bytes correspondiente al elemento,
almacenado en el elemento de la matriz cuyo subíndice es igual al argumento
implícito Elemento. En caso contrario, en lugar de sumar la cantidad, deberá restarla.
Finalmente, asigna a la propiedad Caption del objeto lblRequerido el valor de
dblRequerido (con formato "##,###,##0 Bytes").
• Active y desactive elementos y compruebe que el cálculo se realice de manera
adecuada.
• Haga clic en el botón Instalar (cmdInstala).
La aplicación envía un mensaje de notificación y procede a dar por concluida la
ejecución del programa.
>> Uso de los objetos ComboBox y ListBox para crear un explorador de fuentes.
[13.04]
frmFuente.frm
A continuación aprenderá a utilizar un objeto ComboBox, en conjunto con uno
ListBox que será alimentado en tiempo de ejecución con las fuentes de pantalla
que tenga instalado su sistema (colección Screen, especificación Fonts).
















362 Parte 3: Controles gráficos y programación orientada a eventos
Implementación visual


Tabla de objetos y propiedades de frmFuente











Capítulo 13: Controles de lista s desplegables 363

Eventos nuevos en frmFuente

Codificación de frmFuente
• Editar código: Form, Evento: Load.
Dim intContador As Integer
For intContador% = 0 To Screen.FontCount - 1
lstFuentes.Additem Screen.Fonts(intContador%)
Next intContador%
lstFuentes.Selected(0)= True
cboTamanio.AddItem 8
cboTamanio.AddItem 10
cboTamanio.AddItem 12
cboTamanio.AddItem 18
cboTamanio.AddItem 24
cboTamanio.Text = cboTamanio.List(0)
lblMuestra.Font.Name = lstFuentes.List(0)
lblMuestra.Font.Size = cboTamanio.List(0)



364 Parte 3: Controles gráficos y programación orientada a eventos
• Editar código: lstFuentes, Evento: Click.
lblMuestra.Font.Name = lstFuentes.List(lstFuentes.ListIndex)
• Editar código: cboTamanio. Evento: Click.
lblMuestra.Font.Size = _
CInt(cboTamanio.List(cboTamanio.ListIndex))
• Editar código: cboTamanio. , Evento: Change.
Dim intTamanio As Integer
If IsNumeric(cboTamanio.Text) Then
intTamanio% = CInt(cboTamanio.Text)
Else
intTamanio% = CInt(cboTamanio.List(0))
End If
If intTamanio% > 32 Or intTamanio% < 8 Then
IntTamanio% = CInt(cboTamanio.List(0))
End If
lblMuestra.Font.Size = intTamanio%

Ejecución
• Al momento de cargar el formulario, se ejecuta el procedimiento Form_Load
que se ocupa de cargar todas las fuentes disponibles en el sistema (colección
Screen, especificación Fonts) al objeto de lista desplegable que los contendrá
para su selección: lstFuentes. Esto se hace a través de un ciclo For Next,
desde cero hasta el número de fuentes disponlbles menos uno
(Screen. ListCount -1), obteniendo el nombre de cada una de las fuentes
de la colección (Fonts).
Después de hacer esto, selecciona de manera automática el elemento de la lista
desplegable que tenga el Índice 0.










Capítulo 13: Controles de listas desplegables 365
Posteriormente agrega las opciones de tamaño que estarán disponlbles en el
ComboBox (cboTamanio), coloca en el cuadro de texto del ComboBox el
contenido del elemento que tenga el índice O y ejecuta la función definida por el
usuario, con los valores iniciales que se acaban de establecer.
• Haga clic en una fuente diferente a la que tiene seleccionada en este momento.
Se ejecuta el procedimiento lstFuentes_Click. Se asignará a la especificación
Name de la propiedad Font del objeto lblMuestra, lo que contenga como
Elemento el elemento seleccionado, que invariablemente será un nombre de
fuente válido.
• Seleccione uno de los tamaños disponlbles en el ComboBox de tamaño (cboTa-
manio).
Se ejecutará el procedimiento cboTamanio_Click. Se asignará a la
especificación Size de la propiedad Font del objeto lblMuestra, lo que
contenga como Elemento el elemento seleccionado, que invariablemente será un
tamaño de fuente válido.
• En el cuadro de texto del ComboBox escriba "14". Éste es un tamaño que no se
encuentra como opción en el objeto, pero indudablemente es un tamaño válido.
Se ejecutará el procedimiento cboTamanio_Change. Se utilizará una variable
para almacenar el tamaño deseado (intTamanio); el programa valida que lo
escrito sea numérico, si es numérico, la variable asume el valor proporcionado, si
no lo es, asume el valor del primer elemento del ComboBox. Posteriormente se
valida si el valor de la variable no excede los límites fijados (8-32); en caso de
que los exceda, se asignará a la variable el valor del primer elemento del cuadro
combinado.
La especificación Size de la propiedad Font del objeto LblMuestra se
establecerá al valor que tenga la variable de trabajo al final del proceso.
>> Uso de un objeto ComboBox sensible a la escritura. [13.05]
frmAutos.frm
A continuación aprenderá a utilizar un objeto ComboBox, sensible a la escritura, que
se coloca en la primera ocurrencia de un elemento que empiece con una determinada
letra.












366 Parte 3: Controles gráficos y programación orientada a eventos

Implementación visual


Tabla de objetos y propiedades de frmAutos

Codificación de frmAutos
• Editar código: Form, Evento: Load.
cboMarca.Additem "Ford"
cboMarca.Additem "General Motors"




Capítulo 13: Controles de lista s desplegables 367

cboMarca.AddItem "Chrysier"
cboMarca.AddItem "Audi"
cboMarca.AddItem "Nissan"
cboMarca.AddItem "Mercedez Benz"
• Editar código: cboMarca, Evento: Change.
Dim strLetras As String
Dim intContador As Integer
strLetras$ = Trim(cboMarca.Text)
If cboMarca.Text <> "" Then
For intContador% = 0 To cboMarca.ListCount - 1
If Len(strLetras$) <= _
Len(Trim(cboMarca.List(intContador%)))Then
If Mid(cboMarca.List(intContador%), 1, _
Len(strLetras$)) = strLetras$ Then
cboMarca.Text = cboMarca.List(intContador%)
cboMarca.SelStart = 0
cboMarca.SelLength = Len(cboMarca.Text)
Exit For
End If
End If
Next intContador%
End If

Ejecución
• Al momento de cargar el formulario, se ejecuta el procedimiento Form_Load,
que se ocupa de cargar todos los elementos al objeto ComboBox (cboMarca).
• Escriba en el cuadro de texto del ComboBox (empezando con mayúscula) una
letra "M".
Se ejecutará el procedimiento cboMarca_Change. El procedimiento definirá
una variable de trabajo de tipo String (strLetras$) y una de tipo contador
(intContador%). La variable de trabajo String toma el valor de lo que
haya tecleado en el cuadro de texto; si ésta tiene un valor diferente a vacío (""),
inicia un ciclo



368 Parte 3: Controles gráficos y programación orientada a eventos
For Next que examina todos los elementos del ComboBox, buscando si
alguno comienza con lo tecleado en el cuadro de texto. De ser así, el cuadro de
texto adopta el Elemento de la opción que corresponda y procede a marcarlo para
sustitución.
En el proceso, también se selecciona el elemento que corresponda a lo tecleado.
• Una vez que aparezca el elemento en el cuadro de texto, extienda la lista desple-
gable y compruebe que está seleccionada la opción que apareció marcada en el
cuadro de texto.
==================================================
LO inesperado: Cuando trabaja con colecciones u objetos de tipo ListBox o
ComboBox, los errores más comunes son:
• Llamada a procedimientos ó argumentos no válidos (error 5 en tiempo de ejecu-
ción). Sucede cuando invoca a un procedimiento de manera errónea, o bien si un
argumento proporcionado no sigue alguna convención de Visual Basic. Por ejem-
plo, en ListBox se puede especificar el orden de los elementos del objeto, con el
conocimiento de que el primero siempre tendrá el Índice cero ("0"). Si no respeta
el orden del Índice (0,1,2,3,4,..., n), el error se producirá. Soluciones: verifique
que la especificación Índice comience en cero y de que se siga un consecutivo
hasta el último elemento. La forma de comprobar lo que se hizo es que el Índice
del último elemento de la lista deberá ser n-\, donde n es el número total de
elementos (ListCount).
==================================================


_____________________________________________________________
Resumen
En este capítulo:
• Vimos qué es una colección.
• Vimos las diferencias entre los objetos ComboBox y ListBox.
• Vimos la forma de agregar y eliminar elementos a los objetos de lista des-
plegable.














Capítulo 13: Controles de listas desplegables 369
• Vimos algunas propiedades a nivel colección y a nivel elemento, útiles en el uso
de los objetos de lista desplegable.
• Vimos la capacidad de selección múltiple de los objetos basados en ListBox.
• Vimos el uso de ListBox con estilo Check.
• Vimos el uso de eventos con el objeto ComboBox.
• Vimos la forma de definir cuadros de lista combinados senslbles a lo que se
teclea él.
Es importante que domine el contenido del capítulo para poder continuar, ya que en
el resto del libro se manejarán objetos basados en estos controles.
















































370





















































Capítulo
14
Editor de menús
y manejo del
Portapapeles
Objetivos
Conocer la herramienta que Visual Basic proporciona para elaborar los menús al
estilo Windows y aprender a manejar el área de memoria temporal disponible para
el usuario, llamada Portapapeles.
Al finalizar este capítulo deberá:
• Dominar el uso del Editor de menús
• Saber manejar los objetos y propiedades que permiten manipular el Portapapeles
Una de las diferencias entre las aplicaciones desarrolladas para el entorno de
Windows y las de otros entornos es la de lucir de manera similar y tener una forma
estándar de manejo en todos sus programas; así, si el usuario aprende a manejar una
aplicación, sabrá manejar las demás sin instrucción ni capacitación intensiva
adicional.
Los conceptos que aprenderá en este capítulo no son de uso indispensable en sus
programas, pero sin duda alguna le pueden proporcionar capacidades y un aspecto
profesional impecable, dentro del estándar de Windows.
371





372 Parte 3: Controles gráficos y programación orientada a eventos

El Editor de menús
El Editor de menús es la herramienta que Visual Basic proporciona para elaborar
los sistemas de menú clásicos del entorno, en donde se define una barra de menús
que contiene opciones generales (opciones de primer nivel), de las cuales dependerán
otras (opciones de ejecución) de las que también pueden depender otras (también de
ejecución), y así sucesivamente.
La barra de menús que se genera a través del Editor de menús forma un sistema,
compuesto por opciones que ejecutan tareas al ser seleccionadas. Por tal motivo,
cada una constituye un objeto, mismo que puede ser utilizado a través de un
procedimiento de evento denominado Click.
Las reglas que es conveniente observar al crear un sistema de menús son las si-
guientes:
• Deben existir opciones de primer nivel: identifican una función, tienen como
propósito concentrar opciones dependientes relativas a dicha función. Por ejemplo,
en todas las aplicaciones de Windows hay una opción de primer nivel llamada
Archivo (función de manipular archivos), de la cual dependen opciones que le son
relativas: Nuevo, Abrir, Cerrar, Guardar, Guardar como, etcétera (también
llamadas de ejecución).
• Deben exlstir opciones de ejecución: tienen como objetivo ordenar la ejecución
de una tarea; también pueden servir para concentrar otras opciones más particu-
lares. En el ejemplo anterior, serían de ejecución las opciones Nuevo, Abrir,
Cerrar, etcétera.
• Las opciones de primer nivel no dependen de ninguna otra opción; las de ejecución
siempre dependen de una de primer nivel, o bien, de otra de ejecución.
• Las opciones de ejecución pueden tener definidas teclas de atajo método
abreviado, de tal forma que presionarlas sea equivalente a utilizar el menú y
seleccionar la opción deseada. No confundir con el acceso rápido que brinda la
definición "&" en la propiedad Caption de los objetos.
• Si una opción de ejecución sólo sirve para mostrar otras iguales, no se recomienda
la colocación de teclas de método abreviado.
• Revise cuáles son las convenciones de Windows al momento de definir teclas de
método abreviado; por ejemplo, al manejar el Portapapeles en Windows, la opción
Copiar tiene como estándar la tecla de método abreviado Ctrl+C, Cortar tiene
Ctrl+X y Pegar tiene Ctrl+V. ¿Para qué modificar el estándar generalmente
aceptado de Windows? Es poslble que usted piense que para la opción Pegar es
más conveniente Ctrl+P que Ctrl+V; estamos de acuerdo, pero ¿cómo establecer
su convención de Ctrl+P si millones de personas ya utilizan Ctrl+V y dan por
entendido que es la convención utilizada en su aplicación?




Capítulo 14: Editor de menús y manejo del Portapapeles 373
• Todas las opciones, sean de primer nivel o de ejecución, deberán tener un nombre de objeto
válido de Visual Basic. Si la opción es de primer nivel, deberán tener el prefijo "mnu", y si es
de ejecución, deberán tener como prefijo el nombre de objeto del cual dependen, separando los
niveles con guión bajo (_). Ejemplo: Archivo (mnuArchivo), Guardar
(mnuArchivo_Guardar).
• Se deberá agregar tres puntos a la propiedad Caption para aquellas opciones de ejecución que
no ordenen una tarea, es decir, que invoquen un cuadro de diálogo.
• Las opciones de menú se manifestarán como opciones, idénticas a lo que se especifique en su
propiedad Caption; es posible colocar el valor de "-" (guión), lo que implica que aparezca la
línea de división estándar de Windows.
Cómo invocar el Editor de menús
No existe un control en el Cuadro de herramientas para agregar objetos de tipo
menú, sin embargo éstos existen y para definirlos se utiliza el Editor de menús.
Para invocar este editor requiere tener seleccionado el formulario donde desea
agregar el menú.
Las alternativas que tiene para invocar el Editor de menús son las siguientes:
• Haciendo clic en el icono Editor de menús de la barra de herramientas.
• Utilizando el menú Herramientas - Editor de menús.
• Presionando Ctrl+E.
Lo más relevante del control Menú es:

Una vez agregados al formulario los objetos que componen el menú, podrá modifi-
carlos sin utilizar el Editor de menús, a través de la ventana Propiedades, seleccio-
nando el objeto que desea modificar en la lista desplegable de objetos.
Al ejecutar la aplicación, el menú se comportará tal y como lo hacen los menús en
Windows, respondiendo a las teclas de método abreviado, al ratón o al teclado, a las
flechas de dirección, etcétera.






374 Parte 3: Controles gráficos y programación orientada a eventos
El Editor de menús luce como se muestra en la figura 14.1:

Las partes importantes de este cuadro de diálogo son:
• Caption. Texto que se desplegará como opción en el menú.
• Name. Nombre del objeto.
• Shortcut. Lista desplegable donde puede seleccionar la tecla de método abreviado
para la opción.
• Checked. Indica si aparecerá una opción visiblemente marcada o no; útil para cuando
alguna sea de selección alterna.
• Enabled. Indica si la opción está disponible o no para su selección.
• Visible. Indica si la opción es visible o no.














Capítulo 14: Editor de menús y manejo del Portapapeles 375
>> Cómo se agrega un objeto de tipo menú. [14.01]
frmFormato.frm
A continuación aprenderá a agregar objetos tipo menú utilizando el Editor de menús, a
modificar sus propiedades mediante la ventana Propiedades, a asignar código asociado
a las opciones de menú y a controlar sus variantes en la ejecución.

Implementación visual

1. Genere un nuevo proyecto EXE estándar.
2. Invoque el Editor de menús presionando Ctrl+E o mediante cualquier otra forma ya
vista en este capítulo.
3. En Caption: teclee &Formato; en Name:, mnuFormato, y marque las propiedades
Enabled y Vislble.

376 Parte 3: Controles gráficos y programación orientada a eventos


4. Haga clic en el botón Siguiente. En Caption: teclee &NormaI; en Name:,
mnuFormato_Normal, y marque las propiedades Enabled y Visible. Se supone que
Formato es una opción de primer nivel y Normal es de ejecución; para especificar ese
hecho, teniendo seleccionado el objeto mnuFormato_Normal en la lista de objetos de
menú, haga clic en el botón de flecha hacia la derecha..












Capítulo 14: Editor de menús y manejo del Portapapeles 377
5. Si ya agregó las dos opciones anteriores, podrá agregar las que quiera. Es cuestión
de hacer clic en el botón Siguiente cada que requiera una nueva opción; si desea
eliminar alguna de las opciones del menú, que a fin de cuentas son objetos, sólo
selecciónelos de la lista de objetos de menú y haga clic en el botón Eliminar.
6. Haga clic en el botón Aceptar.
Al aceptar las modificaciones en el Editor de menús, queda en modo de diseño. Sólo se
agregaron dos objetos en el formulario (mnuFormato y mnuFormato_Normal);
agregue los demás que aparecen en la tabla de objetos y propiedades de frmFormato.
==================================================
Nota: La dependencia entre una opción de primer nivel y las de ejecución (y tam-
bién entre las opciones de ejecución con respecto a otra de ejecución de mayor
nivel), se hace valer mediante la sangría que se especifica con las flechas hacia la
derecha (reduce el nivel) o a la izquierda (aumenta el nivel). Si una opción está total-
mente hacia la izquierda en la lista de objetos de menú, será de primer nivel; las que
estén con sangría bajo ese objeto, dependerán de dicha opción. En nuestro ejemplo,
mnuFormato_Normal depende de mnuFormato.
Cada opción de primer nivel debe tener al menos una de ejecución que le sea depen-
diente; de estas opciones de ejecución, pueden depender otras iguales, y de estas
otras. Esta dependencia se puede hacer hasta en cuatro niveles.
==================================================

Tabla de objetos y propiedades de frmFormato


















378 Parte 3: Controles gráficos y programación orientada a eventos



Capítulo 14: Editor de menús y manejo del Portapapeles 379



Propiedades nuevas en frmFormato














380 Parte 3: Controles gráficos y programación orientada a eventos
Después de insertar todos los objetos de menú, el Editor de menús debe lucir de la
siguiente forma:

>> Cómo introducir código a una opción de menú y utilizar un menú. [14.02]
A continuación aprenderá cómo se agrega el código en un menú y cómo utilizar dicho
menú.
1. Utilice el formulario frmFormato del ejemplo 14.01.
2. En tiempo de diseño, seleccione Salir - Salir de la aplicación.
3. Se abrirá la ventana Código en el evento mnuSalir_Salir_Click.







Capítulo 14: Editor de menús y manejo del Portapapeles 381
Codificación de frmFormato
• Editar código: mnuSalir_Salir, Evento: Click.
End
Ejecución
• Al ejecutar el formulario, el menú tiene todas las capacidades de funcionamiento que
los menús de cualquier aplicación basada en el entorno de Windows.
• Presione Alt+F.
Se comprueba la tecla de método abreviado en las opciones de primer nivel. Vea cómo
se activa el menú, del cual dependen todas las opciones de ejecución asociadas al de
primer nivel invocado.
• Seleccione la opción de primer nivel Salir, y la de ejecución Salir de la aplicación.
El procedimiento mnuSalir_Salir_Click se ejecuta. En vista de que la instrucción
End se encuentra en dicho procedimiento de evento, la aplicación culmina su ejecución.
>> Activación dinámica de opciones. [14.03]
A continuación aprenderá cómo se modifican las propiedades de los objetos que
componen un sistema de menús, con la finalidad de dar la apariencia de aparecer y
desaparecer las opciones. Se demostrará la utilidad de la propiedad Checked.
1. Edite el siguiente código y ejecute la aplicación.
• Editar código: mnuFormato_Mas, Evento: Click.
If mnuFormato_Mas.Checked Then
mnuFormato_Mas.Checked = False
mnuFormato_Guion.Visible = False
mnuFormato_Negritas.Visible = False
mnuFormato_Italicas.Visible = False











382 Parte 3: Controles gráficos y programación orientada a eventos
mnuFormato_Subrayado.Visible = False
mnuFormato_Tamano.Visible = False
Else
mnuFormato_Mas. Checked = True
mnuFormato_Guion.Visible = True
mnuFormato_Negritas.Visible = True
mnuFormato_Italicas.Visible = True
mnuFormato_Subrayado.Visible = True
mnuFormato_Tamano.Visible = True
End If
Ejecución
• Haga clic en el menú de la aplicación Formato.
Observe que la opción Más opciones... está marcada (Checked = True), por lo que
aparecen todas las opciones de formato en el menú.
• Haga clic en el menú de la aplicación Formato — Más opciones... .
Como la opción Más opciones... está marcada (Checked = True) y se ha selec-
cionado, se le da a entender al sistema de menús que se quiere desmarcar dicha opción
(Checked = False), con lo que obtendríamos el funcionamiento de tipo
apuntador de dicha opción. De manera conjunta y puesto que se desmarcó la opción,
todas las opciones de formato no deben estar disponibles. Para ello se establece a
False la propiedad Visible de cada una de las opciones, con lo que dejan de estar
visibles.
• Haga clic en el menú de la aplicación Formato.
Observe que la opción Más opciones... está desmarcada (Checked = False), por
lo que no aparecen todas las opciones de formato en el menú.
• Haga clic en el menú de la aplicación Formato -Más opciones... .
Como la opción Más opciones... está desmarcada (Checked = False) y se ha
seleccionado, se le da a entender al sistema de menús que se quiere marcar dicha
opción (Checked = True). De manera conjunta y puesto que se marcó la opción,
todas las opciones de formato deben estar disponibles. Para ello se establece a True la
propiedad Visible de cada una de las opciones, con lo que estarán visibles.
Vea el código del procedimiento de evento mnuFormato_Mas_Click, y compruebe
que cuando se hace uso de una opción con manejo de Checked, el código consiste en
una disyuntiva (If) que determina lo que sucederá cuando se tenga la





Capitulo 14: Editor de menús y manejo del Portapapeles 383
opción marcada o desmarcada (Checked en True o False, respectivamente), que
curiosamente, casi siempre hacen exactamente lo contrario.
>> Modificación del tipo de letra utilizando el menú. [14.04]
A continuación aprenderá a modificar las propiedades de tipo dé letra utilizando el
menú. Complemento del ejercicio.
1. Edite el siguiente código y ejecute la aplicación.
• Editar código: mnuFormato_Normal, Evento: Click.
lblEjemplo.Font.Size = 10
lblEjemplo.Font.Bold = False
lblEjemplo.Font.Italic = False
lblEjemplo.Font.Underline = False

• Editar código: mnuFormato_Negritas, Evento: Click.
lblEjemplo.Font.Bold = True
• Editar código: mnuFormato_Italicas, Evento: Click.
lblEjemplo.Font.Italic = True
• Editar código: mnuFormato_Subrayado, Evento: Click.
lblEjemplo.Font.Underline = True
Ejecución
• Haga clic en el menú de la aplicación Formato - Negritas, Formato - Itálicas,
Formato - Subrayado y Formato - Normal.
Compruebe que las modificaciones en el texto de ejemplo se realizan. Las opciones
Negritas, Itálicas y Subrayado afectan lblEjemplo, mientras que Normal revierte
todos los cambios realizados.








384 Parte 3: Controles gráficos y programación orientada a eventos
>> Opciones de menú mutuamente excluyentes. [14.05]
A continuación aprenderá a codificar el uso de opciones de menú mutuamente ex-
cluyentes, es decir, seleccionar sólo una de entre varias. Se apoyará con la propiedad
Checked. Verá cómo se comportan las opciones de 3er. nivel.
1. Edite el siguiente código y ejecute la aplicación.
• Editar código: mnuFormato_Tamanio_T10, Evento: Click.
mnuFormato_Tamanio_T10.Checked = True
mnuFormato_Tamanio_T14.Checked = False
mnuFormato_Tamanio_T24.Checked = False
lblEjemplo.Font.Size = 10
• Editar código: mnuFormato_Tamanio_T14, Evento: Click.

mnuFormato_Tamanio_T10. Checked = False
mnuFormato_Tamanio_T14. Checked = True
mnuFormato_Tamanio_T24. Checked = False
lblEjemplo.Font.Size = 14
• Editar código: mnuFormato_Tamanio_T24, Evento: Click.

mnuFormato_Tamanio_T10.Checked = False
mnuFormato_Tamanio_T14.Checked = False
mnuFormato_Tamanio_T24.Checked = True
lblEjemplo.Font.Size = 24
Ejecución
• Haga clic en el menú de la aplicación Formato - Tamaño -14 puntos, Formato -
Tamaño - 24 puntos y Formato - Tamaño -10 puntos, Formato - Tamaño -14
puntos.
Compruebe que las modificaciones en el texto de ejemplo se realizan en cuanto al
tamaño. La forma en que opera cada una de las opciones seleccionadas es la siguiente:
establecen a False a la propiedad Checked de aquellas opciones








Capítulo 14: Editor de menús y manejo del Portapapeles 385
dentro del mismo submenú que no han sido seleccionadas, establecen a True la
propiedad Checked de la opción seleccionada, lo que da la apariencia de que sólo
una de las opciones del submenú puede estar activa (cosa que es cierta). Después se
altera el tamaño de lblEjemplo a través de la propiedad Size, al tamaño
seleccionado. El ejercicio hasta ahora tiene establecido el texto en tamaño 14 puntos.
• Haga clic en el menú de la aplicación Formato - Normal, Formato - Tamaño.
Observe que al aplicar la opción Normal, el texto vuelve a su dimensión original. Sin
embargo, el submenú de Tamaño es inexacto: el tamaño del texto es actualmente de
10 puntos, mientras que el submenú muestra como seleccionada la opción 14 puntos,
lo cual no es cierto.
¿Qué modificaciones en el código realizaría para que se actualizara también la
apariencia del submenú?



Manejo del Portapapeles
Otro de los elementos más característicos del entorno de Windows es el Portapapeles,
que podría definirse como la parte de la memoria RAM que se encuentra reservada para
el alojamiento de datos para fines de intercambio entre elementos de interfaz o
programas. Junto con el Portapapeles, se tienen tres funciones básicas de su manejo, que
seguramente usted ya conoce: Copiar, Cortar y Pegar.
Visual Basic maneja ciertos objetos implícitos, tales como Screen, Clipboard,
etcétera. El usuario no necesita definirlos: están disponibles en todo momento porque
forman parte del entorno de Windows. En otras palabras, lo que queremos decirle es que
no requiere el uso de ningún control para poder disponer del Portapapeles.
Para que entienda un poco mejor los conceptos relacionados al uso del Portapapeles,
debe estar consciente de lo siguiente:
• El uso del Portapapeles siempre se hace sobre un objeto determinado. A este objeto
podemos llamarlo objeto fuente.










386 Parte 3: Controles gráficos y programación orientada a eventos
• Copiar es la tarea de cargar datos en el Portapapeles, manteniendo el objeto fuente sin
modificación. Para poder copiar datos, es necesario tener seleccionada o marcada
una porción del objeto fuente.
• Cortar es la tarea de cargar datos en el Portapapeles, eliminando la porción cargada en el
Portapapeles del objeto fuente. Para poder cortar datos, es necesario tener seleccionada o
marcada una porción del objeto fuente.
• Pegar es la tarea de leer el contenido del Portapapeles e insertarlo en el objeto fuente (que en
este caso actúa como destino).
Las operaciones de Copiar, Cortar y Pegar son tan ampliamente difundidas que seguro las
conoce. Lo que quizá no sepa es la manera en que Visual Basic realiza el manejo de los datos
entre el Portapapeles y el objeto fuente.
Para ejemplificar el manejo del Portapapeles, supondremos la existencia de un objeto que
usaremos como fuente, llamado txtTexto, que contiene en su propiedad Text la expresión
"Éste es un ejemplo".
Len: longitud del texto
La longitud de una expresión String se puede conocer fácilmente a través de la función Len.
Para conocer la longitud de nuestro objeto fuente sería:
Len(txtTexto.Text)

Propiedades del objeto fuente: SelStart, SelLength
y SelText
Cuando marca o selecciona algún objeto o texto en el entorno de Windows, esto es claramente
Visible; esto se logra haciendo clic, doble clic, Mayús y las teclas de dirección, ¡Usted ya sabe
cómo! Por ejemplo, ¿qué vería si marcamos una porción de txtTexto.Text?


Internamente tendríamos lo siguiente:
• El dato inicia en una posición cero.
• El número de posición que le corresponde al primer carácter-seleccionado es el 8.
La propiedad que almacena esta información es SelStart.





Capítulo 14: Editor de menús y manejo del Portapapeles 387
• La cantidad de caracteres que se seleccionaron son 3. La propiedad que almacena esta
información es SelLenght.
• El texto seleccionado es "un". La propiedad que almacena esta información es SelText.
Codificado, tendríamos las siguientes expresiones:

txtTexto.SelStart = 8
txtTexto.SelLenght = 3
txtTexto.SelText = "un "
¿Qué pasa si no tiene nada seleccionado? SelStart tendrá un valor igual a la longitud de su
objeto fuente, y SelLenght tendrá un valor de cero.
Métodos del objeto Clipboard: Clear, SetText y GetText
Por parte del objeto fuente, todo lo que hay que manipular son las propiedades SelStart,
SelLenght y SelText; por parte del Clipboard, éste no tiene propiedades, ya que es
manejado exclusivamente a través de métodos.
El método Clear, por ejemplo, se encarga de eliminar el contenido del Portapapeles. El método
SetText se encarga de cargar datos al Portapapeles, mientras que GetText se encarga de
recuperar los datos que se encuentren en el Portapapeles.
>> Cómo se maneja el Portapapeles en Visual Basic. [14.06]
FrmEditar.frm
A continuación aprenderá a manejar el Portapapeles a través de una aplicación de Visual Basic.
Se conjugará el uso del Editor de menús para disponer con las propiedades SelStart,
SelLenght y SelText de un objeto definido como fuente, y los métodos Clear, SetText
y GetText del objeto Clipboard.
La aplicación tendrá las siguientes opciones de menú y el siguiente comportamiento:
Marcar todo Siempre disponible
Desmarcar todo Siempre disponible
Copiar Siempre disponible
Cortar Siempre disponible
Pegar Sólo cuando haya algo en el Portapapeles






388 Parte 3: Controles gráficos y programación orientada a eventos
Implementación visual

1. Genere un nuevo proyecto EXE estándar.
Tabla de objetos y propiedades de frmEditar


Capítulo 14: Editor de menús y manejo del Portapapeles 389



Propiedades nuevas en frmEditar









390 Parte 3: Controjes gráficos y programación orientada a eventos
Métodos nuevos en frmEditar

Codificación de frmFormato
• Editar código: Form, Evento: Activate.
Clipboard.Clear
• Editar código: mnuEditar, Evento: Click.
Dim strTemporal As String
strTemporal$ = Clipboard.GetText
If Len(strTemporal$) > 0 Then
mnuEditar_Pegar.Enabled = True
Else
mnuEditar_Pegar.Enabled = False
End If
• Crear procedimiento: Informar, Alcance privado.

lblLongitud.Caption = Len(txtOrigen.Text)
lblInicio.Caption = txtOrigen.SelStart
lblMarcado.Caption = txtOrigen.SelLength
• Editar código: mnuEditar_Todo, Evento: Click.
If Len(txtOrigen.Text) > 0 Then
txtOrigen.SelStart = 0
txtOrigen.SelLength = Len(txtOrigen.Text)
Else
MsgBox "No hay nada que marcar", _
vbinformation, "Editar"
End If
• Editar código: mnuEditar_Nada, Evento: Click.
txtOrigen.SelLength = 0
Call Informar




Capítulo 14: Editor de menús y manejo del Portapapeles 391
• Editar código: mnuEditar_Copiar, Evento: Click.
Clipboard.Clear
Clipboard.SetText txtOrigen.SelText
Call Informar
• Editar código: mnuEditar_Cortar, Evento: Click.
Clipboard.Clear
Clipboard.SetText txtOrigen.SelText
txtOrigen.SelText = ""
Call Informar
• Editar código: mnuEditar_Pegar, Evento: Click.
txtOrigen.SelText = Clipboard.GetText
Call Informar
• Editar código: mnuEditar_Salir, Evento: Click.
End
• Editar código: txtOrigen, Evento: Change.

Call Informar
Ejecución
• Ejecute la aplicación.
Al activarse el formulario, el procedimiento Form_Activate se encarga de eliminar
cualquier contenido que tenga el Portapapeles. Adicionalmente se ejecuta el procedimiento
Informar; éste se encarga de utilizar las tres etiquetas de la interfaz (lblLongitud.
lblInicio y lblMarcado), para desplegar el ancho de lo marcado en el objeto
TextBox, la posición inicial de marcado (que es igual a la posición del cursor mientras se
escribe), y la cantidad de caracteres seleccionados, respectivamente.







392 Parte 3: Controles gráficos y programación orientada a eventos
• Haga clic en el menú Edición.
Observe que la opción Pegar no está disponible. El procedimiento mnuEditar_Click
genera una variable temporal para comprobar si el Portapapeles contiene algo. Se asigna el
contenido del Portapapeles a una variable: si la longitud de dicha variable es mayor a cero,
entonces el Portapapeles tiene algo. Hacemos uso de la variable en virtud de que el
Portapapeles no tiene propiedades, y por tanto es imposible evaluar la longitud del
Portapapeles.
En caso de que el Portapapeles contenga algo, se habilita la opción Pegar del menú
(mnuEditar_Pegar), y de lo contrario, se inhabilita. En nuestro caso, no disponemos de
nada en el Portapapeles, por lo que la opción referida no está disponible.
Siempre que se desee ejecutar una opción del menú, sea de primero o segundo nivel, se
ejecutará el procedimiento mnuEditar_Click, incluso cuando se utilicen las teclas de
método abreviado que tienen algunas de las opciones de ejecución.
• Escriba la siguiente frase: "Esta aplicación demuestra el uso del Portapapeles".
El procedimiento txtOrigen_change se encarga de ejecutar el procedimiento
Informar cada vez que el contenido del cuadro de texto se modifica, por lo que usted verá la
actualización dinámica de valores en las etiquetas de la interfaz. Deberá tener lo siguiente al
terminar de teclear la frase que se indicó: 46, 46, 0.
• Seleccione la palabra "uso" de la frase. Haga clic en el menú Edición - Copiar.
Al marcar el texto, se prepara internamente al sistema para considerar una operación que
involucre al Portapapeles. Al hacer clic en el menú Edición -Copiar, se ejecuta el
procedimiento mnuEditar_Copiar_Click, el cual se encarga de eliminar cualquier
contenido que tenga el Portapapeles, para posteriormente cargar en el Portapapeles
(Clipboard.SetText) el texto que se tenga seleccionado (txtOrigen.SelText). A
continuación se ejecuta el procedimiento Informar, que deberá manifestar 46, 29, 3, que
corresponde a la longitud de la frase, posición inicial de lo marcado y longitud de lo
seleccionado.
• Coloque el cursor al final de la frase de ejemplo. Haga clic en el menú Edición. Haga clic en el
menú Edición - Pegar.
Observe que la opción Pegar ya está disponible, en virtud de que el procedimiento
mnuEditar_Click determina que el Portapapeles ya contiene algo. Al hacer clic en
Edición - Pegar se ejecuta el procedimiento mnuEditar_Pegar_Click; hay que
mencionar que cuando usted se movió al final de la frase, txtOrigen.SelStart tuvo el
valor de la nueva posición del cursor (47) y txtOrigen.SelText no tuvo valor ("") ya que
no hubo nada seleccionado. Consideramos importante mencionar estos pormenores, ya que las
etiquetas de la interfaz sólo se actualizan al utilizar las opciones del menú y no cuando Visual
Basic realiza las actualizaciones internamente, lo que sería lo ideal.








Capítulo 14: Editor de menús y manejo del Portapapeles 393
mnuEditar_Pegar_Click se encarga de asignar a txtOrigen.SelText el valor
extraído del Portapapeles (Clipboard.GetText), comenzando en la posición inicial de lo
marcado (txtOrigen.SelStart). Se procede a ejecutar también el procedimiento
Informar.
• Seleccione la palabra "demuestra" de la frase. Haga clic en el menú Edición -Cortar.
Se ejecuta el procedimiento mnuEditar_Cortar_Click, el cual se encarga de eliminar
cualquier contenido que tenga el Portapapeles, para posteriormente cargar en el Portapapeles
(Clipboard.SetText) el texto que se tenga seleccionado (txtOrigen.SelText).
Hasta aquí es lo mismo que mnuEditar_Copiar_Click; la diferencia que tienen, es que
al "cortar", lo seleccionado (txtOrigen.SelText) ya no tiene valor ("").
• Haga clic en el menú Edición - Salir.
Se ejecutará el procedimiento mnuEditar_Sallr_Click, con lo que el programa
termina su ejecución.

=========================================================
Nota: El Portapapeles puede almacenar otros datos, diferentes a texto.
Estos datos, generalmente de tipo gráfico (bmp, wmf y dib), deben ser manejados de diferente
manera, a través de los métodos GetData y SetData del objeto Clipboard, haciendo
referencia del tipo de datos que se trate (vbCFBitmap, vbCFMetafile y vbCFDIB,
respectivamente). Puede ser que se apoye también en la función LoadPicture, que veremos
en su momento, para poder asignar gráficos a variables y elementos que producen alojamiento
en memoria.
En el caso de datos gráficos, las propiedades de posición (SelStart, SelLenght y
SelText) pierden su relevancia.
=========================================================

__________________________________________________________
Resumen
En este capítulo:
• Vimos cómo crear sistemas de menús a través del Editor de menús.
• Vimos cómo manejar el uso de opciones apuntadores a través de la propiedad Checked.









394 Parte 3: Controles gráficos y programación orientada a eventos
• Vimos las particularidades del manejo del Portapapeles.
• Vimos la técnica para habilitar e inhabilitar opciones del menú de acuerdo a la existencia de
información en el Portapapeles.
Manejar lo expuesto en este capítulo resulta indispensable para darle a sus aplicaciones la
uniformidad del entorno de Windows.























































Capítulo
15
Manejo
de imágenes
Objetivo
Conocer el uso de los controles de imagen de Visual Basic a través de los controles básicos de
Visual Basic y de componentes ActiveX.
Al finalizar este capítulo deberá:
• Saber utilizar el control Image
• Saber utilizar la función LoadPicture
• Saber utilizar el control PictureBox
• Saber cómo agregar componentes a un proyecto
• Saber utilizar el control ImageList
Las capacidades de manejo de imágenes son fundamentales para las plataformas GUI, ya que sin
ellas sería lo mismo tener una interfaz de sólo texto. En este capítulo se verán los pormenores
que Visual Basic tiene para el manejo de imágenes; se introducirá en el manejo de controles
ActiveX y las páginas de propiedades.
395















396 Parte 3: Controles gráficos y programación orientada a eventos
Controles básicos para mostrar imágenes
Image
Imagen. Es un control que permite mostrar gráficos a partir de mapas de bits, iconos,
metarchivos, metarchivos mejorados, y otros formatos comprimidos como gif y jpeg.
La propiedad esencial de este tipo de controles es Picture. En ella se especifica qué gráfico
deberá ser mostrado en el objeto.
Lo más relevante de este control es:

LoadPicture
¿Cómo asignar un gráfico a un objeto basado en Image a través de la propiedad Picture?
La cosa parece sencilla. En tiempo de diseño, a través de la ventana Propiedades, basta
encontrar la propiedad Picture, hacer clic en el botón de selección (...), seleccionar un
archivo de imagen válido y eso es todo: la imagen aparecerá automáticamente en la interfaz.
En tiempo de ejecución es más complicado. Suponga que desea cargar en un objeto basado en el
control Image (de nombre imgGrafico) la imagen contenida en el archivo tierra.jpg.
En código no podríamos asignarla de la siguiente forma:
imgGrafico.Picturef = "tierra.jpg"
Ya que estaríamos cargando un dato de tipo String, es decir, una cadena de caracteres.







Capítulo 15: Manejo de imágenes 397
Por otro lado, no podríamos cargarla de la siguiente forma:
imgGrafico.Picture = tierra.jpg
Ya que el validador sintáctico del lenguaje asumiría que tierra es un objeto y jpg
una propiedad asociada a dicho objeto.
La propiedad Picture almacena una imagen y es necesario asignarle algunas. Una
forma práctica de poder hacerlo es mediante el uso de la función LoadPicture, que
se encarga de pasar un valor de tipo imagen a partir del nombre del archivo que la
contiene.
Sintaxis:

LoadPicture("Archivo.ext" )
Donde Archivo es el nombre del archivo que contiene la imagen a mostrar en el objeto.
Archivo puede incluir la ruta del archivo, así como nombres relativos reconocidos por el
sistema operativo Windows.
====================================================
Lo inesperado: Cuando trabaja con la propiedad Picture y la función
LoadPicture, los errores más comunes son:
• No coinciden los tipos (error de compilación). Está tratando de asignarle a la
propiedad Picture un valor que no es una imagen. Soluciones: utilice la función
LoadPicture para asegurarse de que lo que está asignando a la propiedad es una
imagen.
• No se ha encontrado el archivo (error 53 en tiempo de ejecución). Se presenta cuando
en la función LoadPicture hace referencia a un archivo que no existe o la ruta está
equivocada. Soluciones: revise que el nombre del archivo esté bien definido, que la
ruta sea correcta y que el archivo exista realmente .
• La imagen no es válida (error 481 en tiempo de ejecución). La imagen que pretendió
cargar al objeto no es válida, ya que el formato es desconocido o no soportado por
Visual Basic. Soluciones: incluya en sus aplicaciones imágenes en formatos estándar,
como mapas de bits, gif, jpeg o metarchivos.
====================================================
====================================================
Nota: Si utiliza formatos comprimidos (gif/jpeg), el consumo de memoria será menor.
Utilizar mapas de bits (bmp) puede degradar el desempeño de sus aplicaciones.
====================================================











398 Parte 3: Controles gráficos y programación orientada a eventos
>>- Uso de objetos basados en el control Image y carga de imágenes con LoadPicture.
[15.01]
frmGrafico.frm
A continuación aprenderá a cargar una imagen en un objeto basado en Image a través
de la función LoadPicture.
Implementación visual



Tabla de objetos y propiedades de frmGrafico.frm













Capítulo 15: Manejo de imágenes 399



Propiedades nuevas en frmGrafico


Codificación de frmGrafico
• Editar código: cmdVerGrafico, Evento: Click.

imgGrafico.Picture = LoadPicture("c:\avbp\capT5\Tierra.jpg")

====================================================
Nota: Asumimos que tiene instalados los archivos de apoyo para este libro en la
unidad C. Deberá cambiar la unidad y la ruta en caso de que haya realizado una insta-
lación diferente a la sugerida. Esta nota es válida para todas las referencias a la ruta
C:\AVBP\.
====================================================
Ejecución
• Haga clic en el botón de comando Ver el gráfico.
• El procedimiento cmdVerGrafico_Click se ejecutará cargando el archivo
Tierra.jpg que se encuentra en la ruta c:\avbp\capl5, y asignará la imagen al objeto
Image.
Observe que la imagen es más pequeña que el objeto, pero gracias a la propiedad
Stretch, ésta se ajusta automáticamente al tamaño del objeto; en caso de que hubiera
sido más grande que éste, también lo hubiera ajustado.





400 Parte 3: Controles gráficos y programación orientada a eventos
Esta capacidad de Image es muy importante, ya que permite mostrar en un mismo
espacio en la interfaz, imágenes de las cuales desconocemos realmente su dimensión.
PictureBox
Es un control que muestra gráficos a partir de mapas de bits, iconos, metarchivos,
metarchivos mejorados, y otros formatos comprimidos como gif y jpeg. Hasta este
punto parecería que Image y PictureBox se parecen en su función, es más, hasta el
icono del control se parece.
Ésta es una verdad muy relativa. PictureBox puede, además, actuar como objeto
contenedor de objetos tipo OptionButton. así como mostrar el resultado de métodos
gráficos y texto escrito para ser manipulados a través del método Print. Estas capa-
cidades de PictureBox permiten ir creando una imagen, y no sólo mostrarla, por lo
que este control es muy completo y útil para aquellos que desarrollan aplicaciones de
dibujo.

====================================================
Nota: Si lo que desea es mostrar una imagen en formato estándar, le recomendamos
utilizar objetos basados en Image. Si además requiere modificar el contenido o insertar
objetos en la imagen, utilice mejor PictureBox. En el primer caso, usar Image es
mejor porque demanda mucho menos recursos del sistema que PictureBox; para el
segundo caso, sólo con PictureBox podrá ser realizado.
====================================================
La propiedad esencial de los objetos basados en este control es Picture, en la cual se
especifica qué imagen se desea cargar; esto generalmente representa seleccionar un
archivo válido de imagen, asociado al objeto.
Lo más relevante de este control es:



Capítulo 15: Manejo de imágenes 401
============================================================
Nota: La propiedad Stretch de los objetos basados en Image permite que las
imágenes a cargar se ajusten al tamaño del objeto que las contiene. La propiedad
Autosize de los objetos basados en PictureBox permite que el objeto se adapte
al tamaño de la imagen que va a contener. Utilice objetos basados en Image cuando
no conoce el tamaño de las imágenes y sólo pretende mostrarlas.
============================================================
>> Uso de objetos basados en el control PictureBox y modificación dinámica de
imágenes. [15.02]
frmDibujo.frm
A continuación aprenderá a trabajar con objetos basados en el control PictureBox, y
un poco en relación con los métodos disponibles para dichos objetos.
Implementación visual





402 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmDibujo

Propiedades nuevas en frmDibujo



Capítulo 15: Manejo de imágenes 403


Codificación de frmDibujo
• Editar código: cmdDibujar, Evento: Clic.


Dim sngX As Single
Dim sngY As Single
Dim sngRadio As Single

sngX! = picAreaDibujo.ScaleHeight / 2
sngY! = picAreaDibujo.ScaleWidth / 2
sngRadio! = sngX! / 2

' Círculo

picAreaDibujo.Circle (sngX!, sngY!), sngRadio!

' Agrega los ejes

picAreaDibujo.Line (sngX!, sngY!)-(sngX! – sngRadio!, sngY!)
picAreaDibujo.Line (sngX!, sngY!)-(sngX!, sngY! - sngRadio!)
picAreaDibujo.Line (sngX!, sngY!)-(sngX! + sngRadio!, sngY!)
picAreaDibujo.Line (sngX!, sngY!)-(sngX!, sngY! + sngRadio!)
• Editar código: picAreaDibujo, Evento: MouseMove.
If chkModoDraw.Value = vbChecked Then
picAreaDibujo.PSet (X, Y)
End If

• Editar código: cmdLimpiar, Evento: Click.
picAreaDibujo.Cls






404 Parte 3: Controles gráficos y programación orientada a eventos
• Editar código: cmdSalir, Evento: Click.
End

Ejecución
• La casilla de verificación Activar modo Draw está desactivada. Mueva el puntero del
ratón sobre el objeto picAreaDibujo y compruebe que no pasa nada.
• Haga clic en el botón de comando Dibujar.
El procedimiento cmdDibujar_Click se ejecutará. Se crean variables para calcular
posiciones dentro del objeto; se determina el centro de éste (mitad del alto, X, y del
ancho. Y). Se generan las coordenadas X, Y, de la base del dibujo. El radio será igual al
valor de X, entre 2, por decir un valor.
Se traza un círculo, a partir del punto X, Y, considerando el radio que se determinó.
Esto se hace a través del método Circle del objeto PictureBox.
Sintaxis:
Objeto.Circle (x,y), Radio
Posteriormente, se trazan líneas desde el punto X, Y hacia los 4 puntos cardinales,
sumando y restando al punto de origen, el valor del radio para X y para Y. Esto se hace
a través del método Line del objeto PictureBox, proporcionando
Sintaxis:
Objeto.Line (x,y) - (xl,yl)
• Haga clic en la casilla de verificación Activar modo Draw, para activarla. Poste-
riormente mueva el puntero del ratón sobre el objeto picAreaDibujo.
El procedimiento picAreaDibujo_MouseMove se ejecutará a cada variación de
posición dentro del objeto picAreaDibujo. Si la casilla de verificación está acti-
vada, el procedimiento de evento trazará un punto del tamaño especificado por
ScaleDraw, en el punto X, Y en donde se encuentre el puntero del ratón. Las
coordenadas X, Y son proporcionadas de manera implícita por el evento
MouseMove. El punto es trazado por el método Pset, del objeto PictureBox






.
Capítulo 15: Manejo de imágenes 405
Sintaxis:
Objeto.Pset {x,y)
• Haga clic en el botón de comando Limpiar.
El procedimiento cmdLimpiar_Click eliminará el contenido del objeto PictureBox.
• Haga clic en el botón de comando Salir.
El procedimiento cmdSalir_Click sólo contiene la instrucción End, que da por
terminada la sesión de trabajo.
Adición de componentes al proyecto
Ya hemos comentado que una de las máximas capacidades de Visual Basic es su posi-
bilidad de extenderse como herramienta de desarrollo. Sería utópico pensar que Visual
Basic fuera la herramienta de desarrollo líder que es, si sólo dispusiera de las
posibilidades que encierran los controles que aparecen en el Cuadro de herramientas.
En Visual Basic usted puede agregar componentes, es decir, nuevos elementos de
interfaz que se comportan de acuerdo a las características de la clase que los define. Los
componentes se alejan de ser una simple subrutina o subprograma, ya que tienen un
comportamiento más dinámico. La explicación de los componentes ActiveX se
explicará a detalle en otra parte del libro.
La forma de trabajo con los componentes es muy sencilla:
• Evalúe si los controles que se encuentran en el Cuadro de herramientas de manera
básica son suficientes para desarrollar fácilmente la aplicación sobre la que desea
trabajar.
• Si no es así, busque entre los componentes que su edición de Visual Basic incluye
pero que no muestra en el Cuadro de herramientas, por comodidad. Si un
componente agrega un control que satisface su necesidad, actívelo y trabaje con él; su
problema estará resuelto.
• Si su edición de Visual Basic no incluye un componente que proporcione un control
que satisfaga su necesidad, deberá buscar alguna casa de desarrollo de software que le
proporcione o venda uno adecuado. Por supuesto, tiene la posibilidad de desarrollarlo
usted mismo.






406 Parte 3: Controles gráficos y programación orientada a eventos
Un componente agrega uno o más controles al Cuadro de herramientas. Son tan
variados los propósitos que persiguen los componentes, que sería inadecuado disponer
de todos los controles de los componentes en el Cuadro de herramientas; no
mentimos al decirle que si hiciera eso, su pantalla no sería suficiente para mostrar el
Cuadro de herramientas. Es por ello que los componentes sólo están disponibles a
petición.
Los controles agregados pueden ser más complejos y dinámicos que los que conoce
hasta el momento. Algunos son tan poderosos y complejos, que la ventana Propiedades
resulta insuficiente; en ese caso, el control mismo dispone de su ayuda y su propio
cuadro de diálogo que facilita su uso.
==================================================
Nota: Los cuadros de diálogo adicionales que permiten actualizar de manera orga-
nizada las propiedades de un control ActiveX, son conocidos como páginas de
propiedades. Sugerimos su uso en tiempo de diseño, ya que brindan mucha claridad en
el manejo de los objetos y su preparación para el trabajo en la interfaz, además que hay
cosas que sólo pueden ser establecidas a través de dichas páginas de propiedades.
==================================================

>> Cómo agregar componentes a un proyecto de Visual Basic. [15.03]
A continuación aprenderá a agregar componentes a un proyecto de Visual Basic y verá
cómo se agregan controles en el Cuadro de herramientas.
1. Genere un nuevo proyecto EXE estándar.
2. Vaya al menú Proyecto - Componentes (o presione la tecla Ctrl+T).
3. Aparecerá el cuadro de diálogo Componentes (vea la figura 15.3). Se desplegarán
todos los componentes disponibles en su sistema hasta el momento, en forma de
una lista desplegable de tipo CheckBox.
4. Visa el contenido del Cuadro de herramientas. ¿Cuántos controles tiene?
______________.










Capítulo 15: Manejo de imágenes 407


5. Busque Microsoft Windows Common Controls 6.0. Active la casilla de verifi-
cación y haga clic en el botón de comando Aplicar. En este momento, usted
acaba de agregar un componente a su proyecto.
¿Qué aparece en la parte inferior del cuadro de diálogo, a manera de Frame,
con encabezado Microsoft Windows Common Controls 6.01
6.

7 ¿Cuántos controles tiene el Cuadro de herramientas en estos momentos?
_________. El Cuadro de herramientas debe lucir más o menos como se
muestra en la figura 15.4:






408 Parte 3: Controles gráficos y programación orientada a eventos

8. Se colocaron nuevos controles, por ejemplo ImageList, que utilizaremos en este
mismo capítulo.
9. Haga clic en el botón Cerrar, del cuadro de diálogo componentes.

============================================================
Nota: En la respuesta del punto 6 de la práctica anterior, pudimos ver que se
mostraba un archivo con su ruta. Estos archivos, de extensión ocx, deberán ser dis-
tribuidos junto con la aplicación, ya que de lo contrario, todos los controles asocia-
dos al componente no funcionarán. Es recomendable que los coloque en el directorio
de archivos del sistema de Windows (C:\Windows\System, por lo general), para que
estén disponibles para todas las aplicaciones que los requieran.
Una vez instalados, no es necesario volverlos a instalar, aunque no recomendamos
que se confíe, dando por cierta su existencia. Adjúntelos al conjunto de archivos a
distribuir; en caso de que ya existan, eso no tendrá repercusiones en sus aplicaciones
ni en su espacio en disco.







Capítulo 15: Manejo de imágenes 409
En caso de que un componente OCX sea distribuido con su aplicación, verifique que
su uso es autorizado y que no cometerá delito por la violación a derechos de autor o
propiedad intelectual. De manera inocente puede convertirse en un pirata
informático.
============================================================
Almacenamiento de imágenes
En este capítulo ya hemos manipulado imágenes utilizando los controles Image y
PictureBox. Para mostrar las que están contenidas en archivos de imágenes
estándar, utilizamos la propiedad Picture, de la siguiente forma:
Sintaxis:
Objeto.Picture = LoadPicture(“RutaNombreArchivo")
Ejemplo:
imgGrafico.Picture = LoadPicture("c:\avbp\cap15\Tierra.jpg")
La referencia que se hace en el ejemplo es una referencia explícita de archivo, es
decir, para que el programa funcione, es necesario que el archivo se llame
Tierra.jpg, y que se encuentre en c:\avbp\capl5. Cualquier otro nombre o ruta
causará error.
No nos sorprendería que en su programa de instalación desee darle la oportunidad al
instalador de que decida dónde se deposita su aplicación. Sería muy problemático
entonces tener que decirle que debe cuidar que un conjunto de archivos (que puede
ser muy numeroso) debe estar en un directorio determinado, con un nombre deter-
minado.
Ciertamente, manejar de esa forma las imágenes resulta muy inadecuado, ya que el
número de archivos que compongan su sistema será muy grande, cualquiera podría
modificar las imágenes, borrarlas o cambiarlas de lugar, lo que sería sinónimo de
problemas.
Lo ideal sería que las imágenes quedaran almacenadas en el formulario que las uti-
liza, estando siempre disponibles y libres de modificaciones o eliminaciones. Para
ello existe un control llamado ImageList, perteneciente al componente Microsoft
Windows Common Controls 6.0






410 Parte 3: Controles gráficos y programación orientada a eventos
ImageList ( Microsoft Windows Common Controls 6.0)
El control ImageList almacena imágenes en un tamaño estándar y los subordina a
un módulo determinado. Si usted define un objeto de tipo ImageList, Visual
Basic genera un archivo de extensión frx que forma parte de su formulario y se
distribuye con él. A partir de ese momento no necesitará referenciar las imágenes al
archivo que físicamente las contiene, sino al objeto que las contiene, a través de un
identificador único de imágenes.
Los objetos basados en ImageList son invisibles en modo de ejecución. Una vez
que usted agrega las imágenes, éstas conforman una colección de imágenes.
>> Almacenamiento de imágenes en un objeto ImageList. [15.04]
A continuación aprenderá a generar una colección de imágenes dependiente de un
formulario, a través del uso de ImageList.
1. Utilizará el formulario que comenzó a crear en la práctica anterior.
2. Agregue un objeto de tipo ImageList, haciendo doble clic en el control que ya
debe encontrarse en el Cuadro de herramientas. Acomode el control de tal
forma que no estorbe (vea la figura 15.5).

============================================================
Nota: Visual Basic tiene una gran cantidad de objetos que son invisibles en tiempo
de ejecución. Donde los coloque en tiempo de diseño no importa, ya que no se verán
al ejecutar la aplicación.
Puede hacerse un favor si los coloca donde no le estorben en el diseño de su interfaz.
Es muy incómodo estarlos moviendo a cada momento.
============================================================
















Capítulo 15: Manejo de imágenes 411



3. Una vez que el objeto ImageList esté selecionado, observe que la ventana Pro-
piedades tiene un número muy pequeño de ellas. En este caso, sólo se utilizan
para asignar las propiedades de la colección, pero no de los elementos de la
misma, que vendrán a ser las imágenes que sean agregadas.
4. Establezca la propiedad Name del objeto basado en ImageList a
imlImagenes
5. Coloque el puntero del ratón sobre el objeto imlImagenes, haga clic con el
botón derecho del ratón para que aparezca el menú contextual que se muestra en
la figura 15.6. Seleccione la opción Propiedades.









412 Parte 3: Controles gráficos y programación orientada a eventos
6. Aparecerá el cuadro de diálogo de propiedades del objeto (vea la figura 15.7).

============================================================
Nota: Al cuadro de diálogo para modificar las propiedades de los controles
ActiveX, por lo general se conoce como página de propiedades.
Cuando se haga referencia en este libro a una página de propiedades, deberá entender
que es el cuadro de diálogo en donde se pueden modificar las propiedades de un
objeto basado en controles ActiveX.
Ningún control básico de Visual Basic, como TextBox, CommandButton o
CheckBox, tiene página de propiedades. Por otro lado, no todos los controles
ActiveX tienen página de propiedades.
============================================================


7. Este cuadro de diálogo tiene tres fichas: General, Imágenes y Color. La primera
se encarga de definir la medida estándar de las imágenes (en píxeles); si las imá-
genes son de diferente medida, debe seleccionar la opción Custom. Primero
seleccione Custom y después la ficha Imágenes (vea la figura 15.8).








Capítulo 15: Manejo de imágenes 413


8. En la ficha Imágenes se asigna automáticamente un número de elemento
(Index). También se especifica una clave (Key) que identifica como único a un
elemento dentro de la colección. Para agregar una imagen, haga clic en el botón
Insertar imagen... Aparecerá la ventana de apertura de archivos del sistema
operativo Windows. Seleccione la imagen Tierra.jpg que se encuentra en la ruta
c:\avbp\capl5\. Al agregarla, el cuadro de diálogo le permitirá asignar la clave
(Key); en el caso de esta imagen, coloque como clave la palabra Tierra (vea la
figura 15.9). Casualmente se llamó como el archivo, pero esto no es una regla.





414 Parte 3: Controles gráficos y programación orientada a eventos
9. Agregue las siguientes imágenes (todas se encuentran en la ruta c:\avbp\capl5\):

10. Para aceptar los cambios, le recomendamos hacer clic en el botón Aplicar, y
posteriormente en el botón Aceptar. Puede ingresar en cualquier momento a la
página de propiedades y modificar lo ya definido,
Mediante el control ImageList almacenó imágenes para su uso dedicado en su
aplicación. Seguramente se generará un archivo de extensión frx, homónimo al de
módulo (extensión frm), en donde quedarán almacenadas las imágenes.
Al momento de compilar a exe, las imágenes se agregarán al archivo ejecutable.
El control ImageList genera objetos de tipo colección; hay un objeto general que
cuenta con elementos que le son dependientes. Tanto el objeto general como los ele
mentos tienen sus propiedades.
En resumen, tendríamos lo siguiente:

Se puede hacer un amplio manejo de la colección, identificada por Visual Basic
como ListImages, a través de las diversas propiedades que posee el objeto :
• Para contar (Count) la cantidad de imágenes contenidas en la lista de imágenes
(ListImages) que constituye el objeto (imiImagenes):

imlImagenes.ListImages.Count









Capítulo 15: Manejo de imágenes 415
• Para referenciar la imagen (Picture) del primer elemento de la lista de imágenes
(ListImages) que constituye el objeto (imlImagenes). es necesario hacer refe-
rencia al elemento por su índice (Index), por su clave (Key), si se conoce, o por su
número de elemento (Item) )¡
imlImagenes.ListImages(1).Picture
imlImagenes.ListImages("Tierra").Picture
imlImagenes.ListImages.Item(l).Picture


============================================================
Nota: La propiedad Picture de un objeto de tipo ImageList contiene un
número interno, aleatorio, que se asigna a cada una de las imágenes almacenadas en
tiempo de ejecución. Al referenciar dicho número. Visual Basic extrae la imagen
dentro de las convenciones de imagen (Picture), por lo que el uso de la función
LoadPicture ya no es necesario.
============================================================
• Para referenciar la clave (Key) de una imagen contenida en la lista de imágenes
(ListImages) que constituye el objeto (imlImagenes), de la cual sólo
conocemos el índice (Index), o viceversa:
imiImagenes.ListImages("Tierra").Index
imiImagenes.ListImages.Item(1).Key
============================================================
Lo inesperado: Cuando trabaja con la colección ImageList, los errores más
comunes son:
• No se encontró el elemento (error 35601 en tiempo de ejecución). Se presenta
cuando la clave a la que se hace referencia no existe. Una cosa muy importante
que debe considerar es que la referencia a la clave es sensible a mayúsculas y
minúsculas, de tal forma que Tierra y tierra no son la misma cosa. Soluciones:
revise que todas las claves existan en la colección, y que no existan discrepancias
de mayúsculas y minúsculas entre su definición y su codificación. Una buena idea
es formar su propio estándar de sólo minúsculas, sólo mayúsculas o sólo
mayúsculas la letra inicial.
• El índice está fuera de los límites (error 35600 en tiempo de ejecución). Se pre-
senta cuando hace referencia a un índice que no se encuentra en la colección.
Soluciones: los índices serán a partir de 1, hasta llegar al número de imágenes
almacenadas. Esté consciente de los índices que puede referenciar, particular-
mente cuando elimina imágenes. Acostúmbrese a utilizar la referencia a través de
Key, es más efectivo.
============================================================


416 Parte 3; Controles gráficos y programación orientada a eventos
>>Uso de una colección de imágenes ImageList. [15.05]
frmCGrafico.frm
A continuación aprenderá a utilizar una colección de imágenes. Es necesario que
haya realizado el ejercicio anterior.
Implementación visual

Tabla de objetos y propiedades de frmCGrafico







Capítulo 15: Manejo de imágenes 417

Codificación de frmCGrafico

• Editar código: (General), Evento: (Declarations).
Dim intCuenta As Integer
Dim intImagenes As Integer
• Editar código: Form, Evento: Load.
picGrafico.Picture = imlImagenes.ListImages( "Tierra").Picture
intCuenta% = 1

• Editar código: cmdAdelante, Evento: Clíck.

intImagenes% = imlImagenes.ListImages.Count
If intCuenta% = intImagenes% Then
intCuenta% = 1
Else
intCuenta% = intCuenta% + 1
End If
picGrafico.Picture = imlImagenes.ListImages(intCuenta%).Picture
• Editar código: cmdAtras, Evento: Clíck.
intImagenes% = imlImagenes.ListImages.Count
If intCuenta% = 1 Then
intCuenta% = intImagenes%
Else
IntCuenta% = intCuenta% - 1
End If
picGrafico.Picture = imlImagenes.ListImages(intCuenta%).Picture




418 Parte 3: Controles gráficos y programación orientada a eventos
Ejecución
• Antes de que se active el formulario, se ejecuta el código que se encuentra en el
área de declaraciones generales, declarando dos variables de trabajo: una que
actuará como contador apuntador, y la otra para almacenar el número de imáge-
nes contenidas en la colección ImageList. Esta última variable permitirá que
el programa funcione aun cuando se le agreguen o eliminen imágenes.
• Al cargarse el formulario, se ejecuta el evento Form_Load.
Se asignará a la propiedad Picture del objeto picGrafico la imagen
almacenada que se identifique mediante la clave Tierra, que es la primera imagen
de la colección. El valor de la variable apuntador se establece en 1.
• Haga clic en el botón >> (cmdAdelante). Después hágalo las veces que quiera.
Se ejecutará el procedimiento cmdAdelante_Click. Se determina el número
de imágenes almacenadas en la colección y el valor se asigna a la variable de
trabajo intCuenta%. Esta variable es muy importante, ya que el rango de
navegación entre imágenes será de 1 a intCuenta%.
La lógica del programa es la siguiente: al hacer clic en el botón >>, le indica al
programa que desea ver la imagen siguiente, es decir, la que tiene el índice con-
secutivo siguiente (intCuenta% + 1) al que tiene actualmente
(intCuenta%). En caso de que el índice que tenga actualmente (intCuenta%)
sea igual al total de imágenes almacenadas (intImagenes%), ya no podría
avanzar hacia un siguiente elemento porque no lo hay; en ese caso, la cuenta se
iniciará.
Una vez que se determina el índice del elemento que se debe mostrar, se asigna a
la propiedad Picture del objeto PictureBox, el contenido en imagen del
elemento seleccionado.
• Haga clic en el botón << (cmdAtras). Después hágalo las veces que quiera.
Se ejecutará el procedimiento cmdAtras_Click. Se determina el número de
imágenes almacenadas en la colección y el valor se asigna a la variable de trabajo
intCuenta%. Esta variable es muy importante, ya que el rango de navegación
entre imágenes será de 1 a intCuenta%.
La lógica del programa es la siguiente: al hacer clic en el botón <<, le indica al
programa que desea ver la imagen anterior, es decir, la que tiene el índice con-
secutivo anterior (intCuenta% - 1) al que tiene actualmente
(intCuenta%). En caso de que el índice que tenga actualmente
(intCuenta%) sea igual a 1, ya no podría retroceder hacia un elemento anterior
porque no lo hay; en ese caso, la cuenta se igualará al último elemento
(intImagenes%).



Capítulo 15: Manejo de imágenes 419
Una vez que se determina el índice del elemento que se debe mostrar, se asigna a la
propiedad Picture del objeto PictureBox, el contenido en imagen del elemento
seleccionado.
_____________________________________________________
Resumen
En este capítulo:
• Vimos las particularidades de los controles básicos de manejo de imágenes:
Image y PictureBox.
• Vimos las particularidades de la función LoadPicture.
• Vimos las diferencias significativas entre Image y PictureBox, a través de la
capacidad de dibujo ampliado de PictureBox.
• Vimos cómo agregar componentes al Cuadro de herramientas de Visual Basic,
ampliando las capacidades de diseño de interfaz.
• Vimos cómo los componentes ActiveX poseen páginas de propiedades que brindan
una mayor funcionalidad en el desarrollo.
• Vimos cómo crear y manejar un almacén de imágenes a través del control
ImageList.
Es importante que domine el contenido del capítulo si desea que sus aplicaciones ten-
gan una verdadera orientación hacia entornos gráficos.
Algunas respuestas a los ejercidos
[15.03] Cómo agregar componentes a un proyecto de Visual Basic.
4. 21
6. C:WINDOWS\SYSTEM\MSCOMCTRL.OCX
7. 30







420























Capítulo
16
Arrastrar y colocar

Objetivo
Dominar el uso de la técnica de arrastrar y colocar a través de sus eventos, así como
la manipulación gráfica de iconos para darle un toque profesional a las aplicaciones.
Al finalizar este capítulo deberá:
• Saber cómo habilitar un objeto para operaciones de arrastrar y colocar
• Saber utilizar los eventos involucrados en operaciones de arrastrar y colocar
• Saber utilizar argumentos implícitos en funciones de arrastrar y colocar
La técnica de arrastrar y colocar es uno de los rasgos más distintivos de los entornos
gráficos; a través de este capítulo podrá dominar los pormenores de este tipo de ope-
raciones que agregan vistosidad a su interfaz.
421



422 Parte 3: Controles gráficos y programación orientada a eventos

Arrastrar y colocar
Una de las características más sobresalientes del entorno de Windows es la de poder
arrastrar y colocar.
Un objeto que puede arrastrarse se conoce como fuente, origen o source. Para arras-
trar un objeto, coloque el puntero del ratón sobre él, presione el botón del ratón y sin
soltarlo, mueva el puntero del ratón (con todo y el objeto fuente) hacia la nueva
posición en donde desee colocar el objeto arrastrado, con el simple hecho de dejar de
presionar el botón del ratón que mantenía presionado.
En el proceso, es probable que arrastre el objeto fuente sobre otros objetos (DragOver);
por lo menos arrastrará sobre el objeto Form el objeto fuente. La figura 16.1 ilustra
un poco lo que pasa en una operación de arrastrar y colocar.


1. El objeto Command1 actúa como objeto fuente. Se coloca el puntero del ratón
sobre el objeto, se presiona el botón del ratón y se mantiene presionado; estando en la
posición inicial (1) se arrastra a la posición destino (3).
Todo el peso de las operaciones de arrastrar y colocar recae sobre los objetos de
destino, es decir, los que no son el objeto fuente; dichos objetos de destino son los
que harán algo al detectar que un objeto es arrastrado sobre ellos (DragOver) o
colocado sobre ellos (DragDrop). El objeto fuente sólo participa en su característica
de poder ser arrastrado, cosa que ocurre al establecer su propiedad DragMode a
lAutomatic



.
Capítulo 16: Arrastrar y colocar 423
Al arrastrar un objeto fuente, se ejecuta un procedimiento de evento denominado
DragOver asociado al objeto sobre el cual el objeto fuente es arrastrado; dicho
procedimiento cuenta con argumentos implícitos importantes: Source, que
contiene la referencia o identificación interna del objeto fuente, y X, Y (Left,
Top) que contienen la nueva posición del objeto a medida que se arrastra.
2. En el proceso de ser arrastrado, una representación visual indicará que se está
ejecutando una operación de arrastrar y colocar, a la que se le llama icono de
arrastre; por lo general es un borde punteado o gris, de las mismas dimensiones
que el objeto fuente. Dicho icono es propiedad del objeto fuente.
Dicha representación gráfica se establece a través de la propiedad DragIcon del
objeto de destino.
3. Al llegar a la posición final se libera el botón del ratón que se mantenía presionado,
y en ese momento ocurre el evento DragDrop del objeto de destino.
>> Programa que comprueba las operaciones de arrastrar y colocar. [16.01]
frmArrastra.frm
A continuación aprenderá a utilizar los eventos asociados a las operaciones de arras-
trar y colocar.
Implementadón visual






424 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmArrastra

Propiedades nuevas en frmArrastra

Eventos nuevos en frmArrastra



Capítulo 16: Arrastrar y colocar 425
Codificación de frmArrastra
• Editar código: Form, Evento: DragOver.
lblMensaje.Caption = " X: " & X & " Y: " & Y
• Editar código: form. Evento: DragDrop.

lblMensaje.Caption = "Soltó el objeto fuente. Nueva ubicación"
cmdFuente.Left = X
cmdFuente.Top = Y
Ejecución
• Arrastre el botón Arrástreme (cmdFuente), pero no lo coloque (operación de
arrastre).
Visual Basic detectará que está arrastrando el objeto cmdFuente sobre el
objeto frmArrastra. Debido a eso, en cada variación de posición del puntero
del ratón se ejecutará el evento Form_DragOver, que se encargará de
modificar la propiedad Caption del objeto lblMensaje. y mostrará el valor
de los atributos implícitos del procedimiento de evento. En todo momento, el
procedimiento DragOver sabe qué objeto es el que se está moviendo sobre el
objeto de destino, y en qué posición se encuentra el objeto fuente (X, Y).
• Coloque el objeto.
Al colocar el objeto que estaba arrastrando, el objeto frmArrastra detecta
que un objeto fuente se ha colocado sobre él, causando el evento
Form_DragDrop, que se encarga de modificar la propiedad Caption del
objeto lblMensaje, y muestra un mensaje de que el objeto se ha colocado.
Para comprobar la variabilidad de los argumentos implícitos, el valor de las
propiedades Left y Top toman el valor de la posición del puntero del ratón al
momento de colocar el objeto fuente (X, Y). Como podrá comprobar,
efectivamente los argumentos implícitos cambian de acuerdo a las acciones que
usted realice en su interfaz.

426 Parte 3: Controles gráficos y programación orientada a eventos
>>Programa que comprueba las operaciones de arrastrar y colocar cuando el
objeto de destino no es de tipo Form. [16.02]
frmDrag1.frm
A continuación aprenderá a utilizar los eventos asociados a las operaciones de arras-
trar y colocar, cuando el objeto de destino no es un objeto de tipo Form. Para este
ejemplo utilizará un objeto basado en ImageList, por lo que deberá habilitar el
componente Microsoft Windows Common Controls 6.0, como se vio en el capítulo
anterior.
Implementación visual


Tabla de objetos y propiedades de frmDrag1













Capítulo 16: Arrastrar y colocar 427

Codificación de frmDrag1
• Editar código: Form, Evento: Load.
picObjeto1.Picture = imlImagenes.ListImages("Tierra").Picture
• Editar código: picObjrto2, Evento: DragDrop.

picObjeto2.Picture = Source.Picture
Source.Picture = LoadPicture("")
Ejecución
• Al cargarse el formulario, se ejecuta el procedimiento Form_Load.
Este procedimiento se encarga de asignar a la propiedad Picture del objeto
pic0bjeto1, la imagen identificada como Tierra en la colección de imágenes
llamada imlImagenes. A continuación aparecerá en el primer objeto
PictureBox la imagen Tierra.
• Arrastre la imagen y colóquela en el objeto de imagen que está vacío.
El objeto pic0bjeto1 actúa como objeto fuente y puede ser arrastrado porque
tiene su propiedad DragMode establecida a 1.













428 Parte 3: Controles gráficos y programación orientada a eventos
Cuando el objeto fuente es arrastrado y colocado en el objeto pic0bjeto2. este
último detecta que algo está siendo colocado sobre él, lo que ocasiona la ejecución del
procedimiento de evento picObjeto2_DragDrop; la forma en que el objeto de
destino (pic0bjeto2) determina qué objeto es el que está siendo colocado sobre él
es consultando el valor del argumento implícito Source.
En este caso Source sólo puede ser picObjeto1. ya que es el único objeto que se
puede arrastrar y colocar en nuestra interfaz; seguramente se topará con otras
aplicaciones en las que el objeto que se puede arrastrar y colocar es indeterminado. La
única forma de tener siempre la certeza de hacer referencia a un objeto fuente, sea
cual sea su nombre, es mediante Source.
picObjeto2_DragDrop se encarga de asignar a la propiedad Picture del obje-
to picObjeto2, la imagen contenida en la propiedad Picture del objeto fuente,
que en este caso es pic0bjeto1. Posteriormente, a través de la función
LoadPicture, se elimina la imagen de picObjeto1. y da la apariencia de que la
imagen dejó de estar en un objeto para pasarse a otro.
>> Programa que comprueba las operaciones de arrastrar y colocar, y que utiliza un
objeto de destino que no es de tipo Form. [16.03]
frmDrag2.frm
A continuación aprenderá a utilizar los eventos asociados a las operaciones de arras-
trar y colocar, cuando el objeto de destino no es un objeto de tipo Form, ya darle ma-
yor riqueza visual utilizando iconos de transferencia. Para este ejemplo utilizará un
objeto basado en ImageList, por lo que deberá habilitar el componente Microsoft
Windows Common Controls 6.0, como se vio en el capítulo anterior.
El siguiente es el comportamiento que se desea para el programa:
• Mientras arrastra el objeto fuente, el icono de transferencia deberá
indicar que el objeto está siendo arrastrado.
• El objeto fuente no podrá ser colocado en el área libre del formula-
rio, por lo que mientras sea arrastrado sobre el formulario, el icono
de transferencia indicará que está prohibido colocar el objeto.




Capítulo 16: Arrastrar y colocar 429

• El único objeto de destino válido es el segundo PictureBox; cuando
el objeto arrastrado esté sobre dicho objeto, el icono deberá cambiar de
tal forma que sugiera colocar el objeto ahí.
• Una vez que el objeto se ha colocado en el objeto de destino válido,
deberá inhabilitarse toda posibilidad de arrastrar nuevamente el objeto
fuente.
Implementación visual


Tabla de objetos y propiedades de frmDrag2











430 Parte 3: Controles gráficos y programación orientada a eventos




Codificación de frmDrag2

• Editar código: Form, Evento: Load.
picObjeto1.Picture = imlImagenes.ListImages("Tierra").Picture
picObjeto1.DragIcon = imlImagenes.ListImages("Drag").Picture
• Editar código: Form, Evento: DragOver.
picObjeto1.DragIcon = imlImagenes.ListImages("No").Picture
:• Editar código: picObjetol, Evento: DragOver.
picObjeto1.DragIcon = imlImagenes.ListImages("Drop").Picture


















Capitulo 16: Arrastrar y colocar 431

:• Editar código: picObjeto2, Evento: DragDrop.

picObjeto2.Picture = Source.Picture
Source.Picture = LoadPicture("")
picObjeto1.DragIcon = LoadPicture("")
picObjeto1.DragMode = 0


Ejecución
:• Al cargarse el formulario, se ejecuta el procedimiento Form_Load.
El procedimiento se encargará de asignar a la propiedad Picture del objeto
Pic0bjeto1, la imagen identificada como Tierra de la colección
imlImagenes. A continuación aparecerá la imagen Tierra en el primer objeto
PictureBox .
Además, la imagen Drag de la colección imlImagenes se establecerá como
icono de arrastre. Esta imagen sólo estará visible cuando se arrastre el objeto
fuente.
:• Arrastre la imagen Tierra y manténgase en cualquier parte del formulario, sin
entrar al objeto de destino.
Puesto que el objeto Form no es un objeto de destino válido (cosa que se puede
comprobar fácilmente, ya que no tiene codificado su evento DragDrop), el
icono de arrastre debe indicar una prohibición. Mientras arrastre el objeto fuente
sobre el objeto Form, se ejecutará el procedimiento de evento
Form_DragOver, que establecerá como icono de arrastre la imagen
identificada como No de la colección imlImagenes.
:• Arrastre la imagen Tierra, entre al objeto de destino, pero todavía no coloque el
objeto.
Puesto que el objeto pic0bjeto2 es un destino válido (cosa que se puede com-
probar fácilmente, ya que tiene codificado su evento DragDrop), el icono de
arrastre debe sugerir que coloque el objeto arrastrado. Mientras arrastre el objeto
fuente sobre el objeto pic0bjeto2, se ejecutará el procedimiento de evento
picObjeto2_DragOver, que establecerá como icono de arrastre la imagen
identificada como Drop de la colección imlImagenes.
:• Coloque el objeto fuente en el objeto de destino.
Se ejecutará el procedimiento de evento picObjeto2_DragDrop, que se
encarga de asignar a la propiedad Picture del objeto de destino, el contenido
de la propiedad Picture del objeto fuente. Posteriormente, y para dar la
apariencia de haber movido el contenido de un lado a otro, a la propiedad
Picture del obje-









432 Parte 3: Controles gráficos y programación orientada a eventos
to fuente se le asigna una imagen nula utilizando LoadPicture, con lo que su
contenido desaparece. Se hace lo mismo con el icono de arrastre. Para evitar que
se intente arrastrar otra vez el objeto fuente, la propiedad DragMode se
establece a 0, que equivale a modo manual, con lo que ya no son posibles las
operaciones realizadas por el programa, más que mediante el uso de métodos y
otra forma de programación.

Estados de transición y punteros predefinidos
Dentro de las operaciones de arrastrar y colocar. Visual Basic siempre sabe en qué
estado de la operación nos encontramos: sabe si estamos arrastrando el objeto o no,
sabe si estamos arrastrándolo sobre un espacio sobre el que no se puede colocar el
objeto, o bien si el espacio sobre el que lo arrastramos es un espacio válido. Todos
estos momentos en la operación de arrastrar y colocar no llegan a ser relevantes como
para constituir eventos nuevos; sin embargo, es posible utilizarlos.
Mediante el evento DragOver, y a través del argumento implícito State, se puede
obtener la información que Visual Basic procesa internamente del proceso de arrastrar
y colocar, al momento en que un objeto es arrastrado.
State puede tener los siguientes valores:



Los estados que acabamos de ilustrar ocurren internamente cuando se desarrolla una
operación de arrastrar y colocar; la forma más práctica y común de poner de mani-
fiesto los cambios de estado es a través de los punteros del ratón que Windows adop-
ta. Por ejemplo, es muy común que cuando se arrastra un objeto sobre un lugar en el
que no se puede colocar, aparezca un puntero de prohibición. En este capítulo ya
vimos la manera en que se puede alterar el icono de arrastre a través de la propiedad
DragIcon.










Capítulo 16: Arrastrar y colocar 433
Punteros predefinidos del entorno de Windows
El entorno de Windows cuenta con un conjunto de punteros de ratón estándar que son
utilizados en todas las operaciones. Por ejemplo, si un proceso se está ejecutando de
modo interno, es usual ver un pequeño reloj de arena. Es tan intensivo y tan común su
uso, que forman parte del entorno mismo.
Visual Basic le permite disponer de dichos punteros, a través de la propiedad
Mouse-Pointer. Los códigos asignados para los punteros predefinidos son los
siguientes:















434 Parte 3: Controles gráficos y programación orientada a eventos
>> Programa que comprueba los estados de las operaciones de arrastrar y colocar,
así como los punteros predefinidos del entorno de Windows. [16.04]
frmEstados.frm
A continuación aprenderá a utilizar los estados implícitos en las operaciones de arras-
trar y colocar, y el uso de los punteros predefinidos del entorno de Windows.
Cuando el estado de la operación sea Entrar (0), se deberá colocar el puntero prede-
terminado del objeto, que por lo general es un contorno grisáceo de las dimensiones
del objeto que es arrastrado. Cuando el estado de la operación sea Salir (1), se deberá
colocar el puntero de prohibición de la operación colocar. Si el estado de la operación
es Sobre, el puntero deberá ser el reloj de arena de Windows. Todo esto sucede mien-
tras el objeto es arrastrado.
Implementación visual

Tabla de objetos y propiedades de frmEstados














Capítulo 16: Arrastrar y colocar 435
Codificación de frmEstados
• Editar código: Form, Evento: DragOver,
If State = 0 Then
Source.MousePointer = vbNoDrop
End If
If State = 1 Then
Source.MousePointer = vbDefault
End If
If State = 2 Then
Source.MousePointer = vbHourglass
End If
Ejecución
• Arrastre el objeto lblMensaje por todas partes, incluso fuera del formulario.
Al comenzar a arrastrar el objeto lblMensaje sobre el formulario, se ejecutará
el procedimiento Form_DragOver. Dicho procedimiento de evento proporcio-
nará en todo momento el valor del estado de la operación de arrastrar y colocar.
A partir de ahí y a través de las estructuras condicionales, se asigna a la propie-
dad MousePointer la constante correspondiente al puntero que se desee
mostrar en cada uno de los estados. El resultado es inmediato y gráficamente
visible.

Manejo en modo manual de arrastrar y colocar
Por lo general, el manejo en modo automático de las operaciones de arrastrar y
colocar es sencillo y recomendable; sin embargo, dicho esquema no es útil en todos
los casos.
El origen de esta restricción tiene que ver con el evento Click. Al tratar de arrastrar
un objeto, es inevitable que usted coloque el puntero del ratón sobre un objeto y
presione el botón del ratón: eso forma parte del concepto de arrastrar y colocar. Pero,
¿cómo le haría para arrastrar un botón de comando, que al hacer clic en él
desencadenara una tarea? Como puede ver, algunos objetos asumen un
comportamiento fundamental de su operación cuando se hace clic en ellos, tal es el
caso de los CommandButton, ListBox y ComboBox, entre otros.













436 Parte 3: Controles gráficos y programación orientada a eventos
Cuando requerimos manejo de tipo arrastrar y colocar, pero no podemos damos el
lujo de sacrificar la funcionalidad de hacer clic en un objeto, es necesario operar de
modo manual aquellas tareas de arrastrar y colocar.
El modo manual de arrastrar y colocar se basa en lo siguiente:
• La propiedad DragMode del objeto fuente deberá estar establecida a 0-Manual,
que de hecho es el valor predeterminado de esa propiedad.
• Se debe buscar un evento sustituto con el cual activar la función de arrastrar y
colocar.
• Se debe activar manualmente el modo de arrastre a través del método Drag.
• El proceso que ocurre al momento de colocar permanece igual.
El método Drag tiene la siguiente Sintaxis:
ObjetoFuente.Drag Acción
Donde Acción es uno de los siguientes valores:



Utilizar el método Drag con la acción vbBeginDrag es equivalente a colocar el puntero
del ratón en el objeto fuente, presionar el botón del ratón y sin soltarlo, mover el puntero del
ratón (con todo y el objeto fuente) hacia una nueva posición en donde se desea colocar el
objeto arrastrado.
>> Programa que comprueba las operaciones de arrastrar y colocar utilizando el modo
manual. [16.05]
frmPermiso.frm

A continuación aprenderá a utilizar los eventos asociados a las operaciones de arrastrar y
colocar, en su modo manual. Para este ejemplo se utilizará un objeto basado en








Capítulo 16: Arrastrar y colocar 437
ImageList. por lo que deberá habilitar el componente Microsoft Windows Common
Controls 6.0, como se vio en el capítulo anterior.
El siguiente es el comportamiento que se desea para el programa:
• El programa simula la asignación de permisos para el manejo de archivos.
• Hay dos listas habilitadas de tipo ListBox para selección múltiple (MultiSelect);
una contiene los permisos disponibles para su asignación, y la otra contiene la lista de
los permisos asignados.
• Debido a que los objetos basados en ListBox son sensibles al clic, ya que mediante él
asumen la selección o liberación de los elementos contenidos en la lista, se deberá
presionar el botón derecho del ratón para activar el proceso de arrastrar y colocar.
• El icono de arrastre deberá denotar la transferencia de opciones de una lista a otra.
• La funcionalidad de arrastrar y colocar deberá estar habilitada para ambas listas, por lo
que ambas pueden ser fuente y destino.

Implementación visual

























438 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmPermiso

Codificación de frmPermiso

• Editar código: Form, Evento: Load.

lstDisponibles.Additem "Leer"
lstDisponibles.Additem "Escribir"
lstDisponibles.Additem "Crear archivos"
lstDisponibles.Additem "Eliminar archivos"







Capítulo 16: Arrastrar y colocar 439
lstDisponibles.DragIcon = imlImagenes.ListImages("Mover").Picture
lstAsignados.DragIcon = imlImagenes.ListImages("Mover").Picture

• Editar código: lstDisponibles, Evento: MouseDown.
If Button = 2 Then
If lstDisponibles.ListCount = 0 Then
Beep
Else
lstDisponibles.Drag vbBeginDrag
End If
End If

• Editar código: lstAsignados, Evento: MouseDown.
If Button = 2 Then
If lstAsignados.ListCount = 0 Then
Beep
Else
lstAsignados.Drag vbBeginDrag
End If
End If

• Editar código: IstDisponibles, Evento: DragDrop.
Dim intContador As Integer
For intContador% = 0 To Source.ListCount - 1
If Source.Selected(intContador%) Then
lstDisponibles.Additem Source.List(intContador%)
End If
Next intContador%
For intContador% = Source.ListCount - 1 To 0 Step -1
If Source.Selected(intContador%) Then
Source.RemoveItem intContador%
End If
Next intContador%

• Editar código: lstAsignados, Evento: DragDrop.
Dim intContador As Integer
For intContador% = 0 To Source.ListCount - 1
If Source.Selected(intContador%) Then
lstAsignados.AddItem Source.List(intContador%)
End If
Next intContador%





440 Parte 3: Controles gráficos y programación orientada a eventos
For intContador% = Source.ListCount - 1 To 0 Step -1
If Source.Selected(intContador%) Then
Source.RemoveItem intContador%
End If
Next intContador%

• Editar código: cmdAceptar, Evento: Click.

End
Ejecución
• Al cargarse el formulario, se ejecuta el procedimiento Form_Load.
El procedimiento se encargará de cargar las opciones de permisos en la lista desplegable
lstDisponibles. Al inicio, sólo dicha lista desplegable tendrá elementos, mismos
que podrán ser intercambiados de una lista a otra.
Además, la imagen Mover de la colección imlImagenes se establecerá como icono de
arrastre para ambas listas desplegables.
• Intente arrastrar cualquier elemento de la lista desplegable lstDisponibles hacia la
lista desplegable lstAsignados, utilizando el procedimiento convencional.
Podrá darse cuenta que el clic en los objetos de tipo lista desplegable tiene una función
de seleccionar y remover la selección de los elementos, por lo que sería prácticamente
imposible desarrollar la operación de arrastrar y colocar como es normal.
• Seleccione uno o más elementos de la lista desplegable lstDisponibles; haga clic
en los elementos, y en casos de selección múltiple, puede utilizar las teclas Mayús o
Ctrl. Presione el botón derecho del ratón y manténgalo presionado.
Se desencadenará el procedimiento de evento lstDisponibles_MouseDown.
Hasta este momento usted no sabe qué botón del ratón fue presionado, ya que el evento
MouseDown se ejecuta para cualquier botón; afortunadamente. Visual Basic tiene en
este evento un argumento implícito llamado Button, que permite determinar cuál de
los botones fue presionado.
El procedimiento lstDisponibles_MouseDown se encargará de analizar el valor
del argumento implícito Button. Si éste es 2, entonces el botón que se presionó es el
botón derecho (que es el que nos interesa); por lo que se evalúa si en la lista desplegable
hay elementos por arrastrar. Si no hay elementos por arrastrar, se emitirá un Beep; de
lo contrario, se iniciará una operación de arrastrar y colocar.










Capítulo 16: Arrastrar y colocar 441
Si la operación de arrastrar y colocar se inicia, el icono de arrastre se cambiará por la
imagen contenida en imilmagenes.
Este mismo comportamiento se repite al hacer lo mismo sobre la lista desplegable
lstAsignados.
• Arrastre los elementos que haya seleccionado y colóquelos en la lista desplegable
lstAsignados.
Se ejecutará el procedimiento de evento lstAslgnados_DragDrop, que se encarga
de definir una variable de trabajo para la manipulación de los elementos de las listas
desplegables. Primeramente evaluará todos los elementos de la lista desplegable que sea
el objeto fuente; si alguno de los elementos está seleccionado, agregará una opción
idéntica en el objeto de destino.
Como se supone que los elementos fueron movidos, se evalúan nuevamente los
elementos del objeto fuente, de forma regresiva, a partir del número de elementos de la
lista desplegable, hasta cero; si alguno de los elementos está seleccionado, lo eliminará.
Esto da la apariencia de agregarlos en un lado y eliminarlos en otro, cosa que realmente
sucede. En la segunda evaluación a los elementos de la lista desplegable que actúa
como fuente, es importante que la cuenta sea regresiva, ya que de otra forma, el proceso
iterativo se iniciaría con el total de los elementos, y al eliminar uno de ellos, haríamos
una referencia inválida al final, ya que al eliminar un elemento, automáticamente todos
se ajustan de tal forma que el índice sea continuo y consecutivo. De forma regresiva lo
peor que puede suceder es que eliminemos el último elemento, que de hecho nunca más
volveremos a invocar.
El mismo comportamiento se repetirá si la operación se realiza tomando como objeto
fuente lstAsignados.
• Haga clic en el botón Aceptar.
Se ejecutará el procedimiento de evento cmdAceptar_Click, que concluirá la eje-
cución de la aplicación.
________________________________________________________
Resumen
En este capítulo:
• Vimos las particularidades del proceso de arrastrar y colocar.
• Vimos cómo habilitar a los objetos para operaciones de arrastrar y colocar en modo
automático.












442 Parte 3: Controles gráficos y programación orientada a eventos
• Vimos la utilidad de los argumentos implícitos del evento DragDrop.
• Vimos la forma en que se le puede agregar dinamismo a las operaciones de arrastrar y
colocar a través de la manipulación de iconos de arrastre.
• Vimos los estados de operación de arrastrar y colocar, así como los punteros predefinidos
del entorno de Windows y la forma de utilizarlos en aplicaciones de Visual Basic.
• Vimos la forma de trabajar con operaciones de arrastrar y colocar de modo manual.

Es importante que conozca el contenido del capítulo para poder proporcionar características
del entorno de Windows a sus aplicaciones. Lo visto en este capítulo y en el pasado, es
suficiente para que sus aplicaciones no parezcan herramientas de trabajo viejas basadas en
modo de texto.
Asuma el futuro proporcionando características estándar de Windows a sus programas.
























Capítulo
17
Control del tiempo

Objetivo
Conocer el uso del control de tiempo de Visual Basic.
Al finalizar este capítulo deberá:
• Conocer el uso del control Timer
Algunos filósofos dicen que el tiempo es de creación humana, que en realidad no existe, tan
sólo transcurre. Se le da un valor absoluto y relativo al mismo tiempo; mientras los filósofos
se ponen de acuerdo, nosotros veremos el control de Visual Basic que nos permite manejar
el tiempo.
Sólo hay dos cosas para las que nos puede importar el tiempo al momento de estar
desarrollando aplicaciones: saber la hora (valor absoluto) y determinar intervalos (valor
relativo), generalmente para establecer límites.
Este capítulo es pequeño, pero le dará un panorama bastante ilustrativo de lo que pude hacer
en Visual Basic si controla el tiempo.
443
















444 Parte 3: Controles gráficos y programación orientada a eventos

Control básico para controlar el tiempo
Timer
Este objeto le permite controlar acciones en intervalos de tiempo calculados en mili-
segundos.
El evento más importante de los objetos basados en este control es Timer, mismo que se
ejecuta de manera periódica con base en un intervalo de tiempo determinado. La propiedad
esencial de este tipo de controles es la propiedad Interval. En ella se especifica el
intervalo, expresado en milisegundos, de cada cuándo se ejecutará el procedimiento de
evento Timer.
Lo más relevante de este control es:


El control Timer es invisible en tiempo de ejecución.
>>Uso del control Timer como valor absoluto. Un reloj. [17.01]
frmReloj.frm
A continuación aprenderá a crear una aplicación que muestre un reloj digital, utili-
zando el control Timer.
Implementación visual







Capítulo 17: Control del tiempo 445
Tabla de objetos y propiedades de frmReloj

Propiedades nuevas en frmReloj


Eventos nuevos en frmReloj

Codificación de frmReloj

• Editar código: Form, Evento: Load.

lblHora.Font = "Arial"
lblHora.FontSize = 18
lblHora.Caption = Time


446 Parte 3: Controles gráficos y programación orientada a eventos
• Editar código: tmrControl, Evento: Timer.

lblHora.Caption = Time
Ejecución
• Al iniciar la ejecución, se ejecuta el procedimiento Form_Load.
El procedimiento se encarga de hacer las definiciones iniciales del tipo y tamaño
de letra que tendrá el objeto lblHora. Se muestra la hora actual, definida por el
sistema, estableciendo la propiedad Caption del objeto lblHora al valor de la
función Time.
• Cada 1000 milisegundos, es decir, cada segundo, se ejecutará el procedimiento
temporizado.
El procedimiento tmrControl_Timer se ejecutará regularmente cada 1000
milisegundos (intervalo definido a través de la propiedad Interval); su función
es actualizar el mensaje del objeto lblHora con el valor de la hora del sistema.
Al cambiar, dará la apariencia de reloj digital.
>> Uso del control Timer como valor relativo. Cuenta regresiva en captura. [17.02]
frmEntrada.frm
A continuación aprenderá a trabajar con objetos basados en Timer, para crear cro-
nómetros. En nuestro ejemplo, si transcurren 15 segundos y el objeto TextBox que
requiere un código de acceso sigue vacío, se da por terminada la espera.
Esta utilidad es importante en aplicaciones de alta seguridad, en donde las pantallas
de captura no pueden permanecer inactivas, ya que se pueden realizar accesos no
autorizados a la información. Por ejemplo, un caso común es una pantalla de consul-
ta de saldos en un banco.

















Capítulo 17: Control del tiempo 447
Implementación visual

Tabla de objetos y propiedades de frmEntrada


===================================================
Nota: La propiedad Interval de los objetos basados en Timer, se hace efectiva
cuando se asigna a la propiedad Enabled el valor True (valor predeterminado). El
valor máximo que se puede asignar es 65,535 milisegundos, lo que equivale a un poco
más de un minuto. Considere estos límites cuando utilice objetos basados en Timer.
Si requiere controlar periodos más largos, necesita utilizar su ingenio de programador,
anidando dos controles Timer, en donde uno inicializa a otro, proporcionando un
control de hasta 65,535 x 65,535 milisegundos de tiempo.
===================================================



448 Parte 3: Controles gráficos y programación orientada a eventos
Codificación de frmEntrada
• Editar código: (General), Evento: (Declarations).
Dim intSegundo As Integer
• Editar código: Form, Evento: Load.
lblRegresivo.Caption = "00:00:15"
intSegundo% =15
• Editar código: tmrControl, Evento: Timer.
intSegundo% = intSegundo% - 1
lblRegresivo.Caption = "00:00:" & Format(intSegundo%, "00")
If intSegundo% = 0 And txtCodigo.Text = "" Then
MsgBox "Tiempo excedido"
End
End If

• Editar código: txtCodigo, Evento; Change.
intSegundo% = 15
Ejecución
• Antes que cualquier cosa, se ejecutan las definiciones establecidas en las decla-
raciones generales.
Se define una variable que actuará como contador en la regresión. Se define aquí
para que esté disponible en toda la aplicación.
















Capítulo 17: Control del tiempo 449
• Al cargarse el formulario, se ejecuta el procedimiento Form_Load.
Este procedimiento se encarga de colocar en lblRegresivo el texto que indica el
conteo inicial. Además, la variable de trabajo intSegundo% asume el valor de
segundos que se irá reduciendo hasta cero.
• Cada 1,000 milisegundos, es decir, cada segundo, se ejecutará el procedimiento
tmrControl_Timer. No escriba nada en el cuadro de texto, deje que se
consuman los segundos.
El procedimiento se encargará de reducir en uno el valor de la variable de trabajo,
prácticamente cada segundo que transcurra desde que se comenzó a ejecutar la
aplicación.
En lblRegresivo se desplegará en segundos la cuenta regresiva.
Si la variable de trabajo es igual a cero y no se ha escrito nada en txtCodigo, se
enviará un mensaje de que el tiempo se ha excedido, y terminará la aplicación.
Ejecute nuevamente; espere a que la cuenta regresiva llegue a los 10 segundos y
pulse una letra en txtCodigo.
Al modificar el contenido del cuadro de texto, se ejecuta el procedimiento de evento
txtCodigo_Change, el cual inicia nuevamente la cuenta regresiva. Inicia en 16,
para que la cuenta se inicie la próxima vez que ocurra el intervalo con 16-1, es decir,
los 15 segundos originales.


_____________________________________________________
Resumen
En este capítulo:
• Vimos el uso del control Timer.
• Vimos cómo a través de Timer se puede utilizar el tiempo en modo absoluto, para
conocer la hora.
• Vimos cómo a través de Timer se puede utilizar el tiempo, para temporizar pro-
cesos.
Es importante que domine el contenido del capítulo, si desea que sus aplicaciones
cuenten con reloj digital, o bien, que controlen su disponibilidad con base al tiempo
de actividad o inactividad.

















450


























































Capítulo
18
Manejo del sistema
de archivos
Objetivo
Conocer el uso de los controles básicos para el sistema de archivos, así como del objeto
FileSystem, que permite manipular archivos y directorios del sistema.
Al finalizar este capítulo deberá:
• Saber utilizar el control DriveListBox
• Saber utilizar el control DirListBox
• Saber utilizar el control FileListBox
• Conocer los métodos del objeto FileSystem que permiten manipular directorios
• Conocer los métodos del objeto FileSystem que permiten manipular archivos
El manejo del sistema de archivos es un trabajo de bajo nivel, que permite la interacción
más pura con el sistema operativo. A través de lo visto en este capítulo, podrá hacer del
manejo de archivos y directorios una experiencia visual ilimitada.
Si en su organización deben realizarse las tareas de mantenimiento de archivos, debe
decidir si desea que dichas tareas se desarrollen a través del sistema operativo (en cuyo
caso deberá capacitar a los usuarios) o bien, incluir las características para que los
usuarios hagan la tarea desde la aplicación.
451





452 Parte 3: Controles gráficos y programación orientada a eventos
El sistema de archivos
Uno de los elementos más importantes de todo sistema operativo es el sistema de
archivos; dicho elemento es el ordenamiento lógico, sistemático, por medio del cual los
archivos son organizados, identificados, almacenados y recuperados, dentro de un medio
de almacenamiento.
La eficiencia de un sistema de archivos radica en la velocidad de entrada y salida que
permite, el aprovechamiento del medio de almacenamiento (todo sistema de archivos
desperdicia espacio), y la seguridad en la información que proporciona. Algunos incluso
dan algunas ventajas adicionales como la compresión implícita de datos, entre otras
cosas.
En este capítulo veremos la forma en que Visual Basic permite manejar el sistema de
archivos de la computadora. La herramienta puede hacerlo a través de los controles
básicos de manejo del sistema de archivos, o bien, a través del objeto FileSystem.
Controles básicos para el manejo del sistema de archivos
DriveListBox
Es un control que explora el sistema de archivos y determina cuántas unidades de
almacenamiento se tienen, para después desplegarlas en una interfaz tipo ComboBox y
permitir su selección.
El evento más importante de los objetos basados en este control es Change, que se eje-
cuta cuando usted selecciona una de las unidades de almacenamiento reconocidas por el
sistema.

====================================================
Nota: Las unidades de almacenamiento reconocidas por el control DriveListBox
pueden ser físicas y lógicas.
Cualquier unidad lógica (referencia, a manera de Drive, a un recurso compartido dentro
de la red), es manejada de la misma forma que las unidades de almacenamiento físico
que se encuentran en su computadora.
El sistema operativo se encargará de los permisos y accesos á las mismas.
====================================================



Capítulo 18: Manejo del sistema de archivos 453
Lo más relevante de este control es:

DirListBox

Es un control que explora el sistema de archivos y determina cuántos directorios hay en
una determinada ruta (path), para después desplegarlos y permitir su selección en una
interfaz de modo de árbol de directorio.
El evento más importante de los objetos basados en este control es Change. que se
ejecuta cuando usted selecciona uno de los directorios reconocidos por el sistema.

====================================================
Nota: En Visual Basic una ruta es entendida, incluyendo el nombre de un archivo, en
algunos casos. Podrá ver esto en algunas de las descripciones de la documentación del
lenguaje; posteriormente haremos mención de dicho manejo sinónimo de términos. La
referencia App.Path, por otro lado, devuelve la ruta activa de la aplicación, lo que
puede ser útil.
====================================================

Lo más relevante de este control es:

FileListBox

Es un control que explora el sistema de archivos y determina cuántos archivos hay en
un directorio determinado, para después desplegarlos y permitir su selección en una
interfaz de modo ListBox.



454 Parte 3: Controles gráficos y programación orientada a eventos
El evento más importante de los objetos basados en este control es Change, que se
ejecuta cuando usted selecciona uno de los archivos reconocidos por el sistema.
Además, este control tiene la capacidad de discriminar los archivos que se habilitan en
el FileListBox, de acuerdo a sus atributos de archivo, tales como Archive,
Hidden, ReadOnly, etcétera.
Lo más relevante de este control es:

>> Uso de los controles básicos para el manejo del sistema de archivos. [18.01]
frmVerImagen.frm
A continuación aprenderá a utilizar los controles para el manejo del sistema de archi-
vos. Este ejemplo le permite visualizar las imágenes .gif, jpeg e .ico a través de un
objeto Image.
El programa también se encargará de discriminar los archivos de posible visualiza-
ción dependiendo de sus atributos de archivo.
También utilizará otros elementos de interfaz de Visual Basic, como el contenedor de
objetos Frame, así como las matrices de controles. Si no tiene bien afianzados dichos
conceptos, sería conveniente que los revisara en el capítulo 12.











Capítulo 18: Manejo del sistema de archivos 455
Implementación visual
Tabla de objetos y propiedades de frmVerImagen







456 Parte 3: Controles gráficos y programación orientada a eventos









Capítulo 18: Manejo del sistema de archivos 457
Propiedades nuevas en frmVerImagen

Eventos nuevos en frmVerImagen

Métodos nuevos en frmVerImagen

Codificación de frmVerImagen
• Editar código: (General), Evento: ActualizaResumen.
dirDirectorio.Path = drvDisco.Drive
filArchivo.Path = dirDirectorio.Path
lblUnidades.Caption = "Unidades:" & _
Format(drvDisco.ListCount, "00")



458 Parte 3: Controles gráficos y programación orientada a eventos
lblDirectorios.Caption = "Directorios:" & _
Format(dirDirectorio.ListCount, "000")
lblArchivos.Caption = "Archivos:" & _
Format(filArchivo.ListCount, "000")
• Editar código: General, Evento: VerificaAtributos,
filArchivo.Archive = (chkAtributo(0).Value = vbChecked)
filArchivo.Hidden = (chkAtributo(1).Value = vbChecked)
filArchivo.Normal = (chkAtributo(2).Value = vbChecked)
filArchivo.System = (chkAtributo(3).Value = vbChecked)
filArchivo.ReadOnly = (chkAtributo(4).Value = vbChecked)
filArchivo.Refresh
Call ActualizaResumen
• Editar código: Form, Evento: Load,
filArchivo.Pattern = "*.gif;*.jpg;*.ico"
Call ActualizaResumen
Call VerificaAtributos
• Editar código: drvDisco, Evento: Change.
Call ActualizaResumen
• Editar código: dirDirectorio, Evento: Change.
Call ActualizaResumen
Editar código: chkAtributos, Evento: Click.
Call VerificaAtributos
• Editar código: filArchivos, Evento: Click.
Dim strRuta As String
strRuta$ = dirDirectorio.Path & "\" & filArchivo.FileName
imgVer.Picture = LoadPicture(strRuta$)











Capítulo 18: Manejo del sistema de archivos 459
Ejecución
• Tareas repetitivas que se ejecutarán en la aplicación. ActualizaResumen y
VerIficaAtributos.
La aplicación muestra un resumen de unidades de almacenamiento disponibles en el
sistema, así como el número de directorios disponibles en dichas unidades de
almacenamiento, además del número de archivos disponibles en un determinado
directorio que se encuentre seleccionado. Asimismo, puede variar el número de
archivos que estén disponibles para su selección, dependiendo de sus atributos de
archivo (modificado, sólo lectura, sistema, oculto, etcétera).
Atender todas estas variantes generaría una repetición innecesaria de código para
poder mantener un resumen actualizado y verdadero. Para automatizar el proceso
informativo de la aplicación, se generaron dos procedimientos definidos por el
usuario.
El procedimiento ActualizaResumen se encarga de establecer la propiedad
Path del objeto dirDirectorio a la unidad de disco seleccionada en el objeto
drvDisco; también establece la propiedad Path del objeto filArchivo al
valor de la propiedad Path del objeto dirDirectorio. De esa manera, el objeto
drvDisco determina el contenido de dirDirectorio, y la selección en
dirDirectorio determina el contenido de filArchivo. Esto genera una
coherencia en el contenido de los objetos. Una vez mantenida la coherencia, se
actualiza la información de resumen, misma que se actualiza con la información de
la propiedad ListCount de cada uno de los objetos básicos de control del sistema
de archivos; dicha propiedad siempre almacena la cantidad de elementos que hay en
cada uno de ellos. Para guardar un aspecto agradable, se proporciona una vista a
través de la función Format.
Por otro lado, el procedimiento VerificaAtributos se encarga de revisar los
valores de cada uno de los elementos de la matriz de controles chkAtributo;
cada uno representa la visualización (vbChecked) o no visualización
(vbUnchecked) de los determinados atributos de archivo. Las propiedades
Archive, Hidden, Normal, System y ReadOnly aceptan un valor lógico
(True o False); recuerde que los objetos CheckBox tienen tres valores posibles
(vbChecked, vbUnchecked y vbGrayed), y por tanto su valor es numérico, no
lógico. Por tal motivo, y considerando que nos interesa saber si está marcado o no el
CheckBox, el procedimiento se encarga de un sencillo manejo, de asignar a las
propiedades de atributo de archivo el valor lógico resultante de saber si está marcado
el CheckBox. A cada uno de los atributos de archivo le corresponde un elemento
de la matriz de controles chkAtributo.
Una vez hecho esto, se procede a actualizar el contenido del objeto filArchivo a
través del método Refresh. Se procede a actualizar el resumen, ya que el cambio
de atributos de archivo puede repercutir en la aparición de más o menos archivos en
el objeto filArchivo.






460 Parte 3: Controles gráficos y programación orientada a eventos
• Al cargarse el formulario se ejecuta el procedimiento Form_Load.
El procedimiento se encarga de especificar que el patrón de archivos a desplegar en
el objeto filArchivo son todos aquellos cuyas extensiones sean gif, jpeg o ico;
se utiliza la notación del sistema operativo DOS para referenciarlos. Si se define más
de una extensión para su despliegue, éstas deben estar separadas por punto y coma
(;). Después de esto, se ejecutan los procedimientos ActualizaResumen y
VerificaAtributos.
Observe que al ejecutar el programa, el resumen indica qué Archivos son cero. Esto
se debe a que todas las propiedades de archivo se encuentran desmarcadas, y por
tanto VerificaAtributos establece a False los valores de las propiedades
Archive, Hidden, Normal, System y ReadOnly del objeto
filArchivo. Ciertamente, ningún archivo está ausente de al menos una de estas
características.
• Cambie de unidad de almacenamiento y de directorio, hasta irse a uno que usted
sepa que posee archivos gif, jpeg o ico. Seguramente, C:\Windows tendrá algunos.
Al estar, cambiando de ruta, si modificó la unidad de almacenamiento, se ejecutó el
procedimiento de evento drvDisco_Change, mismo que se encargó de ejecutar
el procedimiento ActualizaResumen. Si cambió de directorio, se ejecutó el pro-
cedimiento dirDirectorio_Change, que también ejecuta
ActualizaResumen. Recuerde que ActualizaResumen se encarga de
mantener la coherencia de las propiedades Path entre los objetos drvDisco,
dirDirectorio y filArchivo.
• En el recuadro Atributos, marque el CheckBox asociado al atributo Normal.
Se ejecutará el procedimiento chkAtributos_Click; para cuando se ejecuta,
chkAtributo. Valué del elemento 2 (asociado al atributo Normal) ya tiene el
valor de vbChecked, lo que provoca que la propiedad Normal del objeto
filArchivo se establezca a True. Con este cambio, el objeto filArchivo
entiende que todos los archivos que tengan dicho atributo de archivo serán
mostrados. El método Refresh se encargará de que se actualice visualmente el
archivo filArchivo.
Puede utilizar este mismo procedimiento para seleccionar cualquiera de los atributos
de archivo que desee.
Finalmente se actualiza el resumen a través del procedimiento
ActualizaResumen.
• Seleccione alguno de los archivos que aparecen en el objeto filArchivo.
Se ejecutará el procedimiento filArchivo_Click, el cual se encarga de formar
el nombre completo del archivo seleccionado, concatenando la ruta que se encuentra
seleccionada en el objeto dirDirectorio, más una diagonal invertida intermedia
(\) y el nombre del archivo seleccionado. Podríamos haber utilizado la propiedad
Path del objeto filArchivo, pero consideramos que era mejor utilizar la
asociada a dirDirectorio, para ilustrar lo determinante que es un objeto de
otro.

Capítulo 18: Manejo del sistema de archivos 461
Cuando ya tiene el nombre completo del archivo, incluyendo la ruta, se procede a
mostrar la imagen a través de la propiedad Picture del objeto imgVer, con
apoyo de la función LaodPicture.
Manejo del objeto FileSystem
Manejar el sistema de archivos a través de los controles básicos es sencillo, aunque
limitado a funciones exclusivamente de lectura. Hay aplicaciones en las que desea-
mos poder agregar un archivo, eliminarlo, copiarlo, entre otras cosas; ciertamente, el
DriveListBox, DirListBox y FileListBox no ayudan en dichas tareas.
Visual Basic posee varios objetos que permiten manejar diferentes recursos de su
computadora, tales como la pantalla (Screen), el Portapapeles (Clipboard), la
impresora (Printer) y el que nos interesa: el sistema de archivos (FileSystem).
==================================================
Nota: Los objetos Screen, Clipboard, Printer y FileSystem están
definidos en todo momento en Visual Basic, usted no tiene que definirlos. Para
revisar lo que hay, puede invocar el Examinador de objetos de Visual Basic,
presionando F2. Tal vez encuentre en dicha ventana algo que esté buscando para
alguna aplicación específica.
==================================================
Manipulación de subdirectorios
El objeto FileSystem utiliza los siguiente métodos para el manejo de directorios:



















462 Parte 3: Controles gráficos y programación orientada a eventos
Podemos citar los siguientes ejemplos de manejo del objeto FlleSystem, que
manipula directorios:
• Asigna a la variable strRuta$, la ruta que mantiene el control del sistema.
strRuta$ = FileSystem.CurDir ("D")
• Transfiere el control del sistema al directorio C:\Windows.
FileSystem.ChDir "C:\Windows"
• Crea un directorio nuevo, con el nombre C:\NuevoDir.
FileSystem.MkDir "C:\NuevoDir"
• Elimina el directorio C:\NuevoDir.
FileSystem.RmDir "C:\NuevoDir"
• Si el directorio C;\Nuevo no se existe, reporta que no existe, utilizando la función
MsgBox.
If FileSystem.Dir("C:\Nuevo\") = "" Then
MsgBox "No existe"
End If

==================================================
LO inesperado: Cuando trabaja con el objeto FileSystem, los errores más co-
munes son:
• No se ha encontrado la ruta de archivo (error 76 en tiempo de ejecución). Se pre-
senta cuando desea realizar una operación que tiene como destino un archivo o
directorio que no existe. Este error también se utiliza para una generalidad de errores
de difícil clasificación, por ejemplo, el uso de nombres inapropiados de archivos o
directorios. Soluciones: revise, antes de intentar la operación que requiere un
archivo o directorio, que éste exista. Utilice el método Dir. Verifique que los
nombres de archivo sean válidos para el sistema operativo.









Capítulo 18: Manejo del sistema de archivos 463
• Error de acceso a ruta o archivo (error 75 en tiempo de ejecución). Sucede cuando
la operación que desea realizar no es posible, en virtud de que pone en conflicto al
sistema operativo con la situación de su sistema. Algunos ejemplos son: el uso
inadecuado de recursos que se encuentran como de sólo lectura, el uso de unidades
de almacenamiento no disponibles, la creación de elementos que ya se encuentran
creados, etcétera. Soluciones: verifique que el acceso a los recursos que desea está
disponible sin restricciones de lectura, y que no se está tratando de crear lo ya
creado.
• El dispositivo no está disponible (error 68 en tiempo de ejecución). Sucede cuando
trata de realizar una operación con un dispositivo que no se encuentra disponible en
su sistema, como puede ser una unidad de almacenamiento que no tiene, o una
unidad lógica de almacenamiento a la cual por el momento no puede acceder.
Soluciones: verifique que los dispositivos que pretenda utilizar siempre estén
disponibles. Para saber si un dispositivo de almacenamiento está disponible
(suponga que desea generar un directorio en F:), puede recurrir a la idea que pro-
ponemos en el siguiente código:
Dim bolDisponible As Boolean
bolDisponible = (FileSystem.CurDir ( "F:\") <> "")
Puede realizar la tarea con el dispositivo, si bolDisponible tiene un valor True.
==================================================

>> Uso del objeto FileSystem para manipulación de directorios. [18.02]
frmDirs.frm
A continuación aprenderá a trabajar con el objeto FileSystem, para el manejo de
directorios.
La aplicación deberá utilizar un objeto basado en DirListBox, con el cual tendrá
interacción. El programa deberá permitir lo siguiente:
• Ir hacia un directorio anterior. Crear un directorio nuevo. Remover un directorio
existente.
• Mostrar en todo momento el directorio que tiene el control del sistema, tanto
interna como visualmente.










464 Parte 3: Controles gráficos y programación orientada a eventos
Implementación visual

Tabla de objetos y propiedades de frmDirs



Capítulo 18: Manejo del sistema de archivos 465
Métodos nuevos en frmDirs

==================================================
Nota: Los métodos del objeto FileSystem pueden utilizarse sin la referencia del
objeto, a manera de funciones, de tal forma que:
strRuta$ = FileSystem.CurDir("D")
es lo mismo que:
strRuta$ = CurDir("D")
Nosotros, por didáctica, preferimos que los entendiera asociados al objeto; sin em-
bargo, es decisión suya el manejo que desee. Se sobreentiende que el manejo de las
funciones para el manejo del sistema de archivos aplican como métodos del objeto
FileSystem.
==================================================
Codificación de frmDirs
• Editar código: Form,Evento: Activate.
lblInfo.Caption = FileSystem.CurDir
• Editar código: dirDirectorios, Evento: Change.
FileSystem.ChDir dirDirectorios.Path
lblInfo.Caption = FileSystem.CurDir






466 Parte 3: Controles gráficos y programación orientada a eventos
• Editar código: cmdAnterior, Evento: Click.
FileSystem.ChDir (FileSystem.CurDir & "\..")
dirDirectorios.Path = FileSystem.CurDir
dirDirectorios.Refresh
lblInfo.Caption = FileSystem.CurDir
• Editar código: cmdCrearDirectorio, Evento: Click.
Dim strNombreDir As String
strNombreDir$ = InputBox("Nombre del nuevo directorio:")
If strNombreDir$ <> "" Then
If Dir(FileSystem.CurDir & "\" & strNombreDir$) <> "" Then
', vbDirectory) <> "" Then 'agregarlo , vbDirectory
MsgBox "Ese directorio ya existe"
Else
FileSystem.MkDir FileSystem.CurDir & "\" & _
strNombreDir$
dirDirectorios.Path = FileSystem.CurDir & "\" & _
strNombreDir$
End If
End If
dirDirectorios.Refresh
lblInfo.Caption = FileSystem.CurDir

• Editar código; cmdRemoverDirectorio: Click.

Dim strRuta As String
strRuta$ = FileSystem.CurDir
If MsgBox("Está seguro de querer eliminar " & vbCrLf & _
strRuta$, vbOKCancel + vbExclamation) = vbOK Then
FileSystem.ChDir strRuta$ & "\.."
dirDirectorios.Path = FileSystem.CurDir
dirDirectorios.Refresh
FileSystem.RmDir strRuta$
dirDirectorios.Refresh
End If
lblInfo.Caption = FileSystem.CurDir




Capítulo 18: Manejo del sistema de archivos 467
• Editar código; cmdSalir: Evento: Click.

End
Ejecución
• En el momento en que se active el formulario, se ejecutará el procedimiento de
evento Form_Activate.
En este caso, dicho procedimiento sólo tiene un objetivo cosmético: establece la
propiedad Caption del objeto lblInfo a la ruta que tiene el control del
sistema; no se especifica unidad de almacenamiento alguna, por lo que se asume la
unidad que el sistema considera como predeterminada en el momento.
lblInfo siempre muestra el directorio que tiene el control del sistema.
• Seleccione un directorio que esté dentro de otro, utilizando el objeto dirDirec-
torios.
Al cambiarse de directorio suceden dos cosas. La primera es que se cambiará el
directorio de control del sistema por aquel que usted haya seleccionado. El hecho
de operar el objeto de tipo DirListBox no actualiza las referencias del objeto
FileSystem, por lo que hay que utilizar código para cambiar de directorio de
manera que podamos guardar la coherencia entre lo que se ve y lo que interna-
mente se reconoce.
La segunda cosa que hace este procedimiento es establecer la propiedad Caption
del objeto lblInfo a la ruta que tiene el control del sistema.
• Haga clic en el botón Ir al anterior.
Se ejecutará el procedimiento de evento cmdAnterior_Click, mismo que
cambiará el control al directorio anterior, considerando la convención del sistema
operativo "\.." que indica al directorio anterior. Realmente cambia el control del
sistema (ChDir) del directorio actual (FileSystem.CurDir) al anterior (\..)
Además, se actualiza la ruta del objeto dirDirectorios con la nueva ruta que
posee el control, y el objeto se actualiza visualmente. Por último, se actualiza el
objeto lblInfo con la ruta nueva.
• Haga clic en el botón Crear directorio.
Se ejecutará el procedimiento de evento cmdCrearDirectorio_Click, el
cual declarará una variable de trabajo para verificar la existencia del directorio a
crear. Mediante la función InputBox se pregunta el nombre del directorio a
crear; una vez capturado, se verifica que no se haya omitido el nombre del
directorio, en




468 Parte 3: Controles gráficos y programación orientada a eventos
cuyo caso no se hace nada. Si no omitió el nombre, indica que desea la creación
del directorio; se comprueba que no exista un directorio o archivo con ese nombre
en el directorio que tiene el control del sistema (que por cierto fue incluido en el
nombre del directorio a crear). En caso de que ya exista, se envía un mensaje de
que ya existe; en caso contrario, el procedimiento se encarga de generar el nuevo
directorio, asignar como ruta nueva del objeto dirDirectorios la ruta creada,
actualizar visualmente dicho objeto, y actualizar el objeto lblInfo, para que
muestre la nueva ruta, misma que tiene el control.
• Una vez que esté en el nuevo directorio que ha creado, haga clic en el botón
Remover directorio.
Se ejecutará el procedimiento de evento cmdRemoverDirectorio_Click, el
cual declarará una variable de trabajo para almacenar el nombre del directorio a
remover, ya que no se puede eliminar un directorio que estemos utilizando, por lo
que será necesario ir a otro directorio diferente, sin perder de vista el que queremos
eliminar.
Mediante la función MsgBox, se pregunta si desea eliminar realmente el directorio
seleccionado. En caso de contestar de manera afirmativa, se transferirá el control
del sistema al directorio anterior (recuerde que tiene almacenado en una variable
de trabajo el nombre del directorio a eliminar), se actualizará la ruta del objeto
dirDirectorios y se actualizará visualmente. A continuación se procederá a
remover el directorio que señale la variable de trabajo, y se actualiza nuevamente
el objeto dirDirectorios.
Por último, se actualiza el objeto lblInfo, con el dato del directorio que tiene el
control.
• Haga clic en Salir.
El procedimiento de evento cmdSalir_Click se encarga de dar por terminada
la ejecución de la aplicación.
Manipulación de archivos
El objeto FileSystem nos permite el manejo de archivos de manera muy similar
a como manejamos los directorios, a través de los siguientes métodos:















Capítulo 18: Manejo del sistema de archivos 469


El manejo de los atributos de archivo se hacen a través de constantes de Visual Basic:
vbNormal,vbReadOnly,vbHidden, vbArchive, vbSystem.
Podemos citar los siguientes ejemplos de manejo del objeto FileSystem, que
manipula directorios:
• Elimina el archivo C:\Borrame.txt
FileSystem.Kill "C:\Borrame.txt"
• Genera una copia del archivo C:\Archivo1.txt, de nombre C:\Archivo2.txt.
FileSystem.FileCopy "C:\Archivo1.txt", "C:\Archivo2.txt"
• Verifica si el archivo C:\Archivo.txt tiene el atributo de sólo lectura, en cuyo caso
notifica dicha condición a través de la instrucción MsgBox.
If FileSystem.GetAttr("C:\Archivo.txt") = vbReadOnly Then
MsgBox "El archivo es de sólo lectura"
End If
• Establece el atributo System al archivo llamado C:\Archivo.txt.
FileSystem.SetAttr "C:\Archivo.txt", vbSystem
>> Uso del objeto FileSystem para manipulación de archivos. [18.03]
frmArchs.frm
A continuación aprenderá a trabajar con el objeto FileSystem para el manejo de
archivos.
La aplicación deberá utilizar un objeto basado en FileListBox, con el cual tendrá
interacción. El programa deberá permitir lo siguiente:






470 Parte 3: Controles gráficos y programación orientada a eventos
• Ir hacia un directorio anterior. Crear un directorio nuevo. Remover un directorio
existente.
• Mostrar en todo momento el directorio que tiene el control del sistema, tanto
interna como visualmente.
Implementación visual

Tabla de objetos y propiedades de frmArchs







Capítulo 18: Manejo del sistema de archivos 471

Métodos nuevos en frmArchs


Codificación de frmArchs

• Editar código: dirDirectorios, Evento: Change.
filArchivos.Path = dirDirectorios.Path
• Editar código: filArchivos, Evento: Click.
FileSystem.ChDir dirDirectorios.Path
Dim strArchivo As String
strArchivo$ = dirDirectorios.Path & "\" & filArchivos.FileName





472 Parte 3: Controles gráficos y programación orientada a eventos
txtNombreArch.Text = strArchivo$ & vbCrLf & _
FileSystem.FileDateTime(strArchivo$) & vbCrLf & _
FileSystem.FileLen(strArchivo$) & " Bytes"
If FileSystem.GetAttr(strArchivo$) = vbReadOnly Then
chkSoloLectura.Value = vbChecked
Else
chkSoloLectura.Value = vbUnchecked
End If
• Editar código: chkSoloLectura, Evento: Click.
Dim strArchivo As String
strArchivo$ = dirDirectorios.Path & "\" & filArchivos.FileName
If FileSystem.Dir(strArchivo$) <> "" Then
If chkSoloLectura.Value = vbChecked Then
FileSystem.SetAttr strArchivo$, vbReadOnly
Else
FileSystem.SetAttr strArchivo$, vbNormal
End If
End If
• Editar código: cmdGenerarCopia, Evento: Click.
Dim strArchivo As String
strArchivo$ = InputBox("Cuál es el nombre de la copia:")
If strArchivo$ <> "" Then
If FileSystem.Dir(strArchivo$) = "" Then
FileSystem.FileCopy filArchivos.FileName, strArchivo$
Else
MsgBox "Ese archivo ya existe"
End If
End If
filArchivos.Refresh
• Editar código: cmdEliminar, Evento: Click.
Dim strArchivo As String
strArchivo$ = dirDirectorios.Path & "\" & filArchivos.FileName
If FileSystem.Dir(strArchivo$) <> "" Then




Capítulo 18: Manejo del sistema de archivos 473

If MsgBox("Realmente quiere borrar " & vbCrLf & _
strArchivo$, vbOKCancel + vbExclamation) = vbOK Then
If chkSoloLectura.Value = vbChecked Then
MsgBox "El archivo es de sólo lectura"
Else
FileSystem.Kill strArchivo$
End If
filArchivos.Refresh
End If
End If
• Editar código: cmdSalir, Evento: Click.
End
Ejecución
• Seleccione un directorio del objeto dirDirectorios.
Al cambiar de directorio se ejecuta el procedimiento de evento dirDirecto-
rios_Change. Dicho procedimiento de encarga de asignar como ruta del objeto
dirDirectorios, la ruta seleccionada en el objeto dirDirectorios (manejo
de la propiedad Path).
• Haga clic en cualquier archivo de los que aparecen en la lista de archivos, de
preferencia en uno que no sea muy grande.
Se ejecutará el procedimiento de evento dirDirectorios_Click, que se
encarga de establecer el control del sistema a la ruta que esté seleccionada en el
objeto dirDirectorios. Posteriormente genera una variable de trabajo y
almacena el nombre del archivo seleccionado con todo y su ruta.
A través del objeto txtNombreArch se despliega el nombre del archivo con su
ruta, su fecha y hora, y su longitud en bytes; se utiliza la constante vbCrLf, para
dar la apariencia en varias líneas. Posterior a eso, se procede a modificar el objeto
chkSoloLectura, asignándole el valor resultante de la comprobación con
relación a si el archivo es o no de sólo lectura.
El cambio operado será visible a través de la marca en el objeto
chkSoloLectura, ya que su valor (Value) será vbChecked o
vbUnchecked.
• Haga clic en la casilla de verificación Sólo lectura.
Se ejecutará el procedimiento de evento chkSoloLectura_Click, se generará una
variable de trabajo para desplegar el nombre del archivo con todo y su ruta; si se comprueba
que el archivo existe (si el método Dir es diferente a ""), entonces


474 Parte 3: Controles gráficos y programación orientada a eventos
se procede a modificar el atributo de sólo lectura del archivo: si es archivo normal,
pasará a ser de sólo lectura (vbReadOnly), y por el contrario, si es sólo lectura, pa-
sará a ser normal (vbNormal).
• Haga clic en el botón de comando Generar copia. Escriba un nombre de archivo
válido y no existente cuando sea requerido.
Se ejecutará el procedimiento de evento cmdGenerarCopla_Click, el cual
declarará una variable de trabajo para preguntar el nombre que se le desea dar a la
copia. Mediante la función InputBox se pregunta el nombre que se desea dar a la
copia; si dicho nombre no se omite, el sistema valida que el nombre proporcionado
no exista ya: si no existe, la copia se realiza dentro del mismo directorio (que es el
que tiene el control del sistema), o de lo contrario, informa que ese archivo ya existe
y no generará copia alguna.
• Seleccione el archivo que acaba de generar a través de una copia. Haga clic en el
botón de comando Eliminar.
Se ejecutará el procedimiento de evento cmdEliininar_Click, el cual declarará
una variable de trabajo para almacenar el nombre del archivo con todo y su ruta. Si
el archivo existe, entonces se le preguntará si realmente desea eliminar el archivo
seleccionado; en caso de que conteste de manera afirmativa, se verifica si el archivo
es de sólo lectura, en cuyo caso se desplegará un mensaje que informa la
imposibilidad de eliminar el archivo. Si no se cumple ningún impedimento, el
archivo es eliminado y la lista de archivos es actualizada, para que ya no se muestre
el archivo que se acaba de eliminar.
• Haga clic en Salir.
El procedimiento de evento cmdSalir_Click se encarga de dar por terminada la
ejecución de la aplicación
_________________________________________________
Resumen
En este capítulo:
• Vimos el uso del control DriveListBox.
• Vimos el uso del control DirListBox.
• Vimos el uso del control FileListBox.
• Vimos los métodos del objeto FileSystem que permiten manipular directorios,
tales como ChDir, MkDir, RmDir, CurDir.











Capítulo 18: Manejo del sistema de archivos 475

• Conocimos los métodos del objeto FileSystem que permiten manipular archivos,
tales como Dir, Kill, FileCopy, GetAttr, SetAttr, etcétera.
• Aprendió cómo se pueden realizar a través de codificación las operaciones que usted
realiza de manera ordinaria en el sistema operativo, utilizando los objetos que usted
decida.
Es importante que domine el contenido del capítulo si desea que sus aplicaciones
manipulen archivos a nivel operativo, o si pretende que su aplicación permita la gene-
ración y disposición de ellos. La capacidad de copiar archivos es muy importante si
desea opciones de respaldo sencillas.

476



































































Cuadros de
diálogo comunes
Objetivo
Conocer el uso del control CommonDialog. que permite disponer de cuadros de
diálogo estándar de Windows.
Al finalizar este capítulo deberá:
• Saber utilizar el control CommonDialog
• Conocer la definición de CommonDialog para el uso del cuadro de diálogo
Color
• Conocer la definición de CommonDialog para el uso del cuadro de diálogo
Fuente
• Conocer la definición de CommonDialog para el uso del cuadro de diálogo
Imprimir
• Conocer la definición de CommonDialog para el uso del cuadro de diálogo
Abrir/Guardar como
• Saber utilizar indicadores
El manejo de los cuadros que todo mundo sabe utilizar puede ser un aliado
poderoso para la implementación efectiva de sus aplicaciones. No desarrolle
nuevos cuadros de
477




478 Parte 3; Controles gráficos y programación orientada a eventos
diálogo si están a su disposición aquellos que Windows utiliza; no pierda tiempo
construyendo lo ya construido. Este capítulo le dice cómo.

Cuadros de diálogo comunes
Sería paradójico que Windows, en su estructura básica, no correspondiera al
modelo de desarrollo en Visual Basic. Ciertamente, Visual Basic maneja un
esquema de uso de objetos y recursos muy similar al que el sistema operativo
utiliza: de ahí su integración tan completa.

La forma de trabajo basada en módulos o bibliotecas de vínculos dinámicos
(DLLs) permite realizar llamadas a dichos módulos, como programas a nuestra
disposición, siempre y cuando sepamos los elementos que condenen y la sintaxis
para su uso.
En el entorno de Windows hay un módulo de vínculo dinámico llamado
commdig.dll, el cual permite disponer de ciertos elementos de la interfaz de
Windows, que son de uso común en todas las aplicaciones, y que permiten la
gestión de recursos de la computadora y su configuración. Veremos cómo podemos
disponer, sin necesidad de programar toda una interfaz, de aquellos cuadros de
diálogo que nos son familiares, como los de:
• Selección de color y definición de color personalizado
• Selección de fuente o upo de letra
• Selección y configuración de la impresora
• Apertura y guardado de archivos
CommonDialog ( Microsoft Common Dialog Control 6.0)
Este control proporciona un conjunto de cuadros de diálogo estándar del sistema
operativo de Windows, para realizar operaciones tan diversas como abrir y guardar
archivos, establecer las opciones de impresión y seleccionar colores y fuentes.
Este control no tiene una propiedad principal, como casi todos los controles, ya que
éste sirve para varias funciones. Dependiendo de la funcionalidad que se le quiera
dar, será el uso de propiedades y métodos que se recomienden.








Capítulo 19: Cuadros de diálogo comunes 479
El control CommonDialog proporciona una interfaz entre Visual Basic y las
rutinas de la biblioteca de vínculos dinámicos Commdig.dll de Microsoft
Windows. Para crear un cuadro de diálogo utilizando este control, el archivo
Commdig.dll debe encontrarse en el directorio C:\WINDOWS\SYSTEM.
Para poder disponer de un objeto basado en el control CommonDialog, es
necesario que agregue el control al formulario, ya que no forma parte de los
controles básicos que aparecen en el Cuadro de herramientas de Visual Basic.
>>Cómo agregar el control CommonDialog al Cuadro de herramientas.
[19.01]
1. Inicie un nuevo proyecto EXE estándar.
2. Vaya al menú Proyecto - Componentes (o presione Ctrl+T).
3. Aparecerá el cuadro de diálogo Componentes.
4. En la ficha Controles, busque el componente Microsoft Common Dialog
Control. Marque dicho control.
5. Haga clic en Aplicar y luego en Cerrar.
Al agregar un objeto basado en CommonDialog, se agregará al formulario un
objeto que será invisible en tiempo de ejecución; por tal motivo, puede colocarlo
donde no le estorbe.
En tiempo de ejecución puede invocar un determinado cuadro de diálogo a través
de su método de llamada correspondiente. En la siguiente tabla se muestran los
métodos que activan los diferentes cuadros de diálogo de CommonDialog:

==============================================
Nota: La posición donde aparecerá el cuadro de diálogo es aleatoria y no puede
especificarse.
==============================================





480 Parte 3: Controles gráficos y programación orientada a eventos
Indicadores
Para utilizar adecuadamente los objetos basados en CommonDialog. debe
cumplir con tres requisitos:
1. Agregar el objeto basado en CommonDialog al formulario y establecer los
valores de las propiedades básicas, de acuerdo con la funcionalidad que desea
obtener.
2. Especificar los indicadores (flags).
3. Utilizar el método adecuado para activar el cuadro de diálogo correspondiente.
Por ejemplo:
1. Incluya el control CommonDialog al proyecto, y agregue un objeto que se
llame dlgBase (con esto, habrá establecido la propiedad Name [básica]).
2. Requiere un cuadro de diálogo del tipo Abrir archivo, que oculte los archivos
de sólo lectura (indicador cdlOFNHideReadOnly).
Para ello debe establecer el indicador correspondiente:
dlgBase.Flags = cdlOFNHideReadOnly
3. Ponga en ejecución el cuadro de diálogo a través del método indicado, que en
este caso es ShowOpen.
Los indicadores son calificadores que determinan la operación de los cuadros de
diálogo comunes de Windows; éstos son proporcionados a través de la propiedad
Flags en los objetos basados en CommonDialog, y determinan la funcionalidad
del objeto.
Para un objeto, pueden operar uno o más indicadores, mismos que pueden definirse
en una misma línea, separados por la instrucción Or.
Ejemplo:
dlgBase.Flags = cdlOFNHideReadOnly Or cdlOFNExplorer
Para cada una de las diversas funciones de los objetos basados en
CommonDialog, proporcionaremos una tabla de los indicadores que apliquen.






Capítulo 19: Cuadros de diálogo comunes 481
Manejo de errores
Los cuadros de diálogo sirven para diferentes propósitos, y siempre ofrecen al
usuario la posibilidad de que no realice modificación alguna. El botón Cancelar
está disponible en todo momento, y al hacer clic en él, el cuadro de diálogo asume
un valor predeterminado.
Para indicar la ejecución de una determinada operación cuando se hace clic en el
botón Cancelar, los cuadros de diálogo comunes ofrecen poca flexibilidad: usted
no puede determinar, mediante un valor único ofrecido por el objeto, la indicación
de que dicho botón fue utilizado.
Hay una forma de poder controlar ese inconveniente. La propiedad
CancelError de los objetos basados en CommonDialog. cuando está
establecida a True, obliga a Visual Basic a asumir que ha ocurrido un error cuando
se hizo clic en el botón Cancelar. De esa forma, con una sencilla rutina de captura
de errores es posible indicar una acción determinada.
Suponga que en una aplicación tiene un botón llamado cmdCambiaColor, el
cual activa el cuadro de diálogo Color a través de un objeto basado en
CommonDialog llamado dlgBase. Para manejar el uso del botón Cancelar, el
código sería el siguiente.
Private Sub cmdCambioColor_Click()

' Si se hace clic en Cancelar, se origina un
error dlgBase.CancelError = True
' Cuando surja un error, se dirige a
ManejoError
On Error GoTo ManejoError
' Se prepara al objeto para que muestre la
ventana Color
dlgBase.Flags = cdlCCRGBInit
' Se activa la ventana Color
dlgBase.ShowColor
' Concluye el procedimiento antes de llegar a '
la rutina de manejo de errores
Exit Sub
' Inicio de rutina de manejo de errores
ManejoError:
MsgBox "Se hizo clic en Cancelar"

End Sub
Se resaltaron aquellas líneas que son fundamentales para el manejo que se propone.


482 Parte 3: Controles gráficos y programación orientada a eventos
Cuadro de diálogo Color
El cuadro de diálogo Color se presenta mediante el método ShowColor del
control CommonDialog. Dicho cuadro de diálogo permite que el usuario
seleccione un color de una paleta o que cree y seleccione un color personalizado.
Para usar el cuadro de diálogo Color, establezca las propiedades pertinentes del
control CommonDialog. Después utilice el método ShowColor, para activar el
cuadro de diálogo, y la propiedad Color, para obtener el color seleccionado.
Las definiciones Flags para el cuadro de diálogo Color son:

De todas las definiciones Flags, cdlCCRGBInit es la más importante, ya que
es la que se encarga de preparar el entorno para la activación del cuadro de diálogo
Color.
==============================================
Nota: El valor de las constantes Flags es numérico. Asignar a la propiedad
Flags el valor resultante de la suma del valor correspondiente de dos o más
constantes, es lo mismo que colocar las constantes separadas por Or.
==============================================
>>Uso del control CommonDialog para manipular el color en el formato
estándar de Windows. [19.02]
frmColor.frm
A continuación aprenderá a utilizar el control CommonDialog, del componente
Microsoft Common Dialog Control, con la finalidad de poder seleccionar colores
en la interfaz estándar de Windows.


Capítulo 19: Cuadros de diálogo comunes 483
Implementación visual


Tabla de objetos y propiedades de frmColor










484 Parte 3: Controles gráficos y programación orientada a eventos
Propiedades nuevas en frmcolor

Métodos nuevos en frmColor
Codificación de frmColor
• Editar código: cmdMostrar, Evento: Click
dlgBase.CancelError = True
On Error GoTo ManejoError
dlgBase.Flags = cdlCCRGBInit
If chkPersonalizados.Value = vbChecked Then
dlgBase.Flags = cdlCCFullOpen
Else
dlgBase.Flags = cdlCCPreventFullOpen
End If
dlgBase.ShowColor
shpCuadro.FillColor = dlgBase.Color
Exit Sub
ManejoError:
MsgBox "Color no seleccionado"













Capitulo 19: Cuadros de diálogo comunes 485
Ejecución
• Haga clic en el botón Elegir. En este momento no se permite personalizar.
Al hacer clic en dicho botón. Se ejecuta el procedimiento de evento cmdMos -
trar_ciick. Dicho procedimiento se encarga de establecer que si se hace clic en
el botón Cancelar, se genere un error. Dicho error será manejado por el pro-
cedimiento ManejoError. Cuando se genere un error (es decir, cuando se haga
clic en Cancelar), el control de la ejecución se trasladará al segmento
ManejoError, dentro del mismo procedimiento, el cual muestra un mensaje
explicativo y a continuación se encuentra el fin del procedimiento.
Se prepara el objeto para que maneje el cuadro de diálogo Color, a través de la
propiedad Flags. Posteriormente, se evalúa si chkPersonalizados está
marcado, en cuyo caso establece la visualización completa, utilizando la propiedad
Flags; de lo contrario, impide la visualización completa, también a través de la
propiedad Flags. Se procede a activar el cuadro de diálogo a través del método
ShowColor.
Se asigna el color seleccionado en el cuadro de diálogo Color, como color de
llenado del objeto shpCuadro.
La instrucción Exit Sub nos indica que queremos que el procedimiento se dé por
terminado antes de su final, por lo que ManejoError: ya no se ejecuta. Si no
especifica Exit Sub, el programa se seguiría ejecutando, haciendo caso omiso a la
etiqueta de referencia (ManejoError:), que sólo sirve para indicar dónde co-
mienza el segmento del procedimiento llamado a través de GoTo.
• Haga clic en el CheckBox Permitir personalizar.
Al hacer clic en el botón, se ejecuta el procedimiento de evento cmdMos-
trar_ciick. La única variante con el ejercicio anterior, es que ahora sí muestra la
visualización completa del cuadro de diálogo, ya que la especificación dada a través
de la propiedad Flags así lo indicó.
Cuadro de diálogo Fuente
El cuadro de diálogo Fuente se presenta mediante el método ShowFont del control
CommonDialog. Este cuadro de diálogo permite que el usuario seleccione una
fuente, un tamaño, un color y un estilo para esa fuente.
Para usar el cuadro de diálogo Fuente, establezca las propiedades del control
CommonDialog relativas al cuadro de diálogo Fuente. Posteriormente, utilice el
método ShowFont para activar el cuadro.
Una vez que el usuario realice sus selecciones en el cuadro de diálogo Fuente, las
siguientes propiedades contienen información acerca de la selección del usuario:





486 Parte 3: Controles gráficos y programación orientada a eventos


Las definiciones Flags para el cuadro de diálogo Fuente son:






Capítulo 19: Cuadros de diálogo comunes 487




488 Parte 3: Controles gráficos y programación orientada a eventos

=================================================
LO inesperado: Tiene que establecer la propiedad Flags a
cdlCFScreenFonts, cdlCFPrinterFonts o cdlCFBoth antes de presentar el
cuadro de diálogo Fuente. De lo contrario, se produce el error No hay ninguna fuente.
=================================================
De todas las definiciones Flags, cdlCFBoth y cdlCFEffects son las más
importantes, ya que proporcionan las opciones disponibles (fuentes), así como los
atributos especiales para la modificación del tipo de letra (atributos),
respectivamente.
>> Uso del control CommonDialog para manipular las fuentes (tipos de letra)
en el formato estándar de Windows. [19.03]
frmFuente.frm
A continuación aprenderá a utilizar el control CommonDialog. del componente
Microsoft Common Dialog Control, con la finalidad de poder seleccionar las fuentes
en la interfaz estándar de Windows.
Implementación visual











Capítulo 19; Cuadros de diálogo comunes 489
Tabla de objetos y propiedades de frmFuente

Propiedades nuevas en frmFuente

Métodos nuevos en frmFuente





490 Parte 3: Controles gráficos y programación orientada a eventos
Codificación de frmFuente
• Editar código: cmdModificar, Evento: Click
dlgBase.CancelError = True
On Error GoTo ManejoError:
dlgBase.Flags = cdlCFEffects Or cdlCFBoth
dlgBase.ShowFont
lblMuestra.Font.Name = dlgBase.FontName
lblMuestra.Font.Size = dlgBase.FontSize
lblMuestra.Font.Bold = dlgBase.FontBold
lblMuestra.Font.Italic = dlgBase.FontItalic
lblMuestra.Font.Underline = dlgBase.FontUnderline
lblMuestra.Font.Strikethrough = dlgBase.FontStrikethru
lblMuestra.ForeColor = dlgBase.Color
Exit Sub
ManejoError:
MsgBox "No se cambió fuente"

Ejecución
1. Haga clic en el botón Modificar.
Al hacer clic en dicho botón, se ejecuta el procedimiento de evento cmdModifi-
car_Cllck. Dicho procedimiento se encarga de establecer que si se hace clic en el
botón Cancelar, se genere un error. Dicho error será manejado por el procedimiento
ManejoError. Cuando se genere un error (es decir, cuando se haga clic en
Cancelar), el control de la ejecución se trasladará al segmento ManejoError,
dentro del mismo procedimiento, el cual muestra un mensaje explicativo y a con-
tinuación se encuentra el fin del procedimiento.
Se prepara el objeto para que maneje el cuadro de diálogo Fuente, a través de la
propiedad Flags. Mediante la propiedad Flags se establece que el cuadro de
diálogo permitirá modificar los atributos de texto (cdlCFEffects) y mostrará las
fuentes disponibles en impresora y pantalla (cdlCFBoth). A través de la instrucción
Or se ve cómo se pueden asignar ambos valores. Se utiliza el método ShowFont
para activar el cuadro de diálogo.





Capitulo 19: Cuadros de diálogo comunes 491
A todas las propiedades del texto asociadas a Font (Name, Size, Bold, etcétera) se
les asigna su valor correspondiente en el objeto basado en CommonDialog
(FontName, FontSize, FontBold), que están disponibles a través de las
propiedades de este último.
La instrucción Exit Sub nos indica que queremos que el procedimiento se dé por
terminado antes de su final, por lo que ManejoError: ya no se ejecuta. Si no se
especificara Exit Sub, el programa se seguiría ejecutando, haciendo caso omiso a
la etiqueta de referencia (ManejoError:), que sólo sirve para indicar dónde
comienza el segmento del procedimiento llamado a través de GoTo.

Cuadro de diálogo Imprimir
El cuadro de diálogo Imprimir se presenta mediante el método ShowPrinter del
control CommonDialog. El cuadro de diálogo Imprimir permite que el usuario
especifique cómo se va a imprimir el resultado.
El usuario puede especificar la impresión de un intervalo de páginas, la calidad de la
impresión, el número de copias, etcétera. Este cuadro de diálogo también contiene
información acerca de la impresora instalada actualmente y permite que el usuario
configure o vuelva a instalar una nueva impresora predeterminada.
Este cuadro de diálogo no envía los datos a la impresora, sino que permite que el
usuario especifique cómo quiere imprimir sus datos. Si la propiedad
PrinterDefault es True, puede usar el objeto Printer para imprimir datos en
el formato que se seleccione. Para ver más de lo que permite hacer el objeto
Printer, es conveniente que revise el Examinador de objetos (F2).
En tiempo de ejecución, cuando el usuario hace selecciones en el cuadro de diálogo
Imprimir, la información determinada puede conocerse a través de las siguientes
propiedades:













492 Parte 3; Controles gráficos y programación orientada a eventos
Las definiciones Flags para el cuadro de diálogo Imprimir son:






Capítulo 19: Cuadros de diálogo comunes 493

>> Uso del control CommonDialog para manipular las especificaciones de
impresora en el formato estándar de Windows. [19.04]
frmImpresora.frm
A continuación aprenderá a utilizar el control CommonDialog. del componente Mi-
crosoft Common Dialog Control, con la finalidad de poder seleccionar las especifi-
caciones de la impresora en la interfaz estándar de Windows.







494 Parte 3: Controles gráficos y programación orientada a eventos
Implementación visual

Tabla de objetos y propiedades de frmImpresora










Capítulo 19: Cuadros de diálogo comunes 495
Propiedades nuevas en frmimpresora

Métodos nuevos en frmimpresora

Codificación de frmimpresora
• Ediltar código: cmdConftgura, Evento: Click.
dlgBase.CancelError = True
On Error GoTo ManejoError:
dlgBase.Flags = cdlPDPrintSetup
dlgBase.ShowPrinter
Exit Sub
ManejoError:
MsgBox "No se imprimió o definió nada en la impresora"
• Editar código: cmdImprime. Evento: Click.
dlgBase.CancelError = True
On Error GoTo ManejoError:
dlgBase.ShowPrinter

Dim intPaginaInicial As Integer
Dim intPaginaFinal As Integer
Dim intNumeroCopias As Integer
Dim intContador As Integer

496 - Parte 3: Controles gráficos y programación orientada a eventos

intPaginaInicial% = dlgBase.FromPage
intPaginaFinal% = dlgBase.ToPage
intNumeroCopias% = dlgBase.Copies

Print "Inicio:"; intPaginaInicial%
Print "Fin:"; intPaginaFinal%
Print "Copias:"; intNumeroCopias%
For intContador% = 1 To intNumeroCopias%
frmImpresora.PrintForm
Next intContador%
Exit Sub
ManejoError:
MsgBox "No se definió nada en la impresora"
Ejecución
• Haga clic en el botón Configurar.
Al hacer clic en el botón, se ejecuta el procedimiento de evento cmdConfigu-
ra_Click. Dicho procedimiento se encarga de establecer que cuando se haga clic
en el botón Cancelar, se genere un error. Dicho error será manejado por el pro-
cedimiento ManejoError. Cuando se genere un error (es decir, cuando se haga
clic en Cancelar), el control de la ejecución se trasladará al segmento
ManejoError, dentro del mismo procedimiento, el cual muestra un mensaje ex-
plicativo y a continuación se encuentra el fin del procedimiento.
A través de la propiedad Flags se determina que cuando se active el cuadro de
diálogo Imprimir, éste tenga la modalidad de configuración. Se procede a activar el
cuadro de diálogo a través del método ShowPrinter.
Realice las modificaciones a la configuración, según desee.
La instrucción Exit Sub indica que el procedimiento se dará por terminado antes
de su final, por lo que ManejoError: ya no se ejecuta. Si no se especificará Exit
Sub, el programa se seguiría ejecutando, haciendo caso omiso de la etiqueta de
referencia (ManejoError:), que sólo sirve para indicar dónde comienza el seg-
mento del procedimiento llamado a través de GoTo.
• Haga clic en el botón Imprimir.
Al hacer clic en dicho botón, se ejecuta el procedimiento de eventos cmdimpri-
me_Click. Dicho procedimiento se encarga de establecer que cuando se haga clic
en el botón Cancelar, se genere un error. Dicho error será manejado por el pro-
cedimiento ManejoError. Cuando se genere un error (es decir, cuando se haga




Capítulo 19: Cuadros de diálogo comunes 497
clic en Cancelar), el control de la ejecución se trasladará al segmento
ManejoError, dentro del mismo procedimiento, que muestra un mensaje
explicativo y se encuentra el fin del procedimiento.
Se procede a activar el cuadro de diálogo a través del método ShowPrinter.
Realice las modificaciones a la configuración, según desee. Al aceptar los cambios
que realice, se declararán variables de trabajo para almacenar los valores que se
hayan especificado en el cuadro de diálogo; una vez que se asignan los valores
seleccionados a las variables, éstos se imprimen en el formulario.
En el caso del número de copias, se hace un pequeño ejercicio, utilizando el método
PrintForm del objeto frmimpresora, a fin de comprobar el funcionamiento
de dicho valor.
La instrucción Exit Sub nos indica que queremos que el procedimiento se dé por
terminado antes de su final, por lo que ManejoError: ya no se ejecuta. Si no se
especificará Exit Sub, el programa se seguiría ejecutando, haciendo caso omiso
de la etiqueta de referencia (ManejoError:), que sólo sirve para indicar dónde
comienza el segmento del procedimiento llamado a través de GoTo.

Cuadro de diálogo Abrir/Guardar como
Los cuadros de diálogo Abrir y Guardar como se presentan mediante los métodos
ShowOpen y ShowSave del control CommonDialog. La diferencia entre un cuadro
y otro se presenta sólo en el título del mismo, así como en el método que se debe
utilizar para invocarlos. Ambos cuadros de diálogo permiten que el usuario
especifique una unidad, un directorio, una extensión de nombre de archivo y un
nombre de archivo.
En tiempo de ejecución, cuando el usuario elige un archivo y cierra el cuadro de
diálogo, la propiedad FileName contendrá el nombre de archivo seleccionado o
introducido.
Puede establecer la propiedad Filter de forma que el cuadro de diálogo presente
sólo ciertos tipos de archivos, como archivos de texto, bases de datos, documentos y
otros claramente diferenciados por su extensión. La propiedad Filter requiere las
sspecificaciones separadas por canalizaciones ( | ) y distribuidas en pares; por ejem-
plo, para determinar dos tipos de archivo, tendría que hacer lo siguiente:
Todos I *.* I Documentos I *.doc
El primer elemento de cada par indicaría lo que aparece en el ComboBox de
selección de tipo de archivo, mientras que el segundo elemento de cada par indica el
patrón de filtro de los archivos. Hay otra propiedad, llamada IndexFilter, que
permite definir



498 Parte 3: Controles gráficos y programación orientada a eventos
cuál de las definiciones es la que aparecerá de manera predeterminada; el número de
índice inicia en 1.
La propiedad Flags se puede usar para cambiar varios elementos del cuadro de diá-
logo, así como para avisar al usuario cuándo pueden producirse ciertas situaciones,
como por ejemplo sobrescribir un archivo.
Las definiciones Flags para el cuadro de diálogo Abrir/Guardar como son:


Capítulo 19: Cuadros de diálogo comunes 499










500 Parte 3: Controles gráficos y programación orientada a eventos


Es muy importante hacer notar que hay ciertas características que sólo están dis-
ponibles en ciertos entornos operativos. El único entorno operativo que aún tiene
base instalada y que puede verse perjudicado es Windows NT 3.51, que no basa su
interfaz en el estilo implementado a partir de la salida al mercado de Windows 95
(tiene una interfaz semejante a Windows 3.11).
Por ejemplo, los indicadores cdlOFNExplorer (cuadro de diálogo estilo Windows
95, Windows 2000 y Windows NT 4.0) y cdlOFNNoDereferenceLinks
(relacionado con los accesos directos) sólo funcionan en Windows 95, Windows
2000 y en Windows


Capítulo 19: Cuadros de diálogo comunes 501
NT 4.0. Esto es lógico, ya que sólo los entornos antes mencionados basan de manera
nativa su comportamiento en los cuadros de diálogo comunes proporcionados por
CommonDialog.
Otra diferencia que podemos encontrar es el manejo de nombres largos de archivos.
Cuando se habilita la capacidad multiselect para el cuadro de diálogo, la
propiedad FileName devolverá una lista delimitada, con los nombres de los
múltiples archivos seleccionados. La versión 3.51 de Windows NT, que no tiene la
interfaz de Windows 95, en caso de selección múltiple usa espacios en blanco como
delimitadores (sin aceptar nombres largos de archivo). Los cuadros de diálogo de
selección múltiple de Windows 95, Windows 2000 y Windows NT 4.0 que utilizan
cdlOFNExplorer, usan caracteres nulos como delimitadores. Esto se debe a que
en un nombre largo de archivo es muy común la presencia de espacios en blanco, lo
que seria inapropiado si se consideran delimitadores.
>> Uso del control CommonDialog para manejar el cuadro de diálogo Abrir/
Guardar como, en el formato estándar de Windows. [19.05]
frmApertura.frm
A continuación aprenderá a utilizar el control CommonDialog, del componente
Microsoft Common Dialog Control, con la finalidad de poder manejar el cuadro de
diálogo Abrir/Guardar como....
Implementación visual






502 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmApertura

Propiedades nuevas en frmApertura

Métodos nuevos en frmApertura

Codificación de frmApertura
• Editar Código: cmdAbrir, Evento: Click
dlgBase.CancelError = True
On Error GoTo ManejoError:
dlgBase.Flags = cdlOFNHideReadOnly




Capítulo 19: Cuadros de diálogo comunes 503
dlgBase.Filter = _
"Todos los archivos (*.*) |*.*|Documentos (*.doc)|*.doc"
dlgBase.FilterIndex = 2
dlgBase.ShowOpen
Print "Se seleccionó:" & dlgBase.FileName
Exit Sub
ManejoError:
MsgBox "Se eligió cancelar"
Ejecución
• Haga Clic en el botón Abrir.
Al hacer clic en dicho botón, se ejecuta el procedimiento de evento
cmdAbrir_Click. Dicho procedimiento se encarga de establecer que si se hace
clic en el botón Cancelar, se genere un error. Dicho error será manejado por el
procedimiento ManejoError. Cuando se genere un error (es decir, cuando se haga
clic en Cancelar), el control de la ejecución se trasladará al segmento
ManejoError, dentro del mismo procedimiento, que muestra un mensaje
explicativo y se encuentra el fin del procedimiento.
A través de la propiedad Flags se determina que los archivos con atributos de sólo
lectura serán excluidos de la lista de archivos. También se establece, a través de la
propiedad Filter, los tipos de archivo que se desplegarán. Asimismo, se especifica
que el segundo par de elementos definido a través de Filter se establecerá como
predeterminado. Se utiliza el método ShowOpen para activar el cuadro de diálogo.
Una vez que selecciona un archivo, el formulario simplemente devuelve un resultado,
mismo que se encuentra en la propiedad FileName.
La instrucción Exit Sub nos indica que queremos que el procedimiento se dé por
terminado antes de su final, por lo que ManejoError: ya no se ejecuta. Si no se
especifica Exit Sub, el programa se seguiría ejecutando, haciendo caso omiso de
la etiqueta de referencia (ManejoError:), que sólo sirve para indicar dónde
comienza el segmento del procedimiento llamado a través de GoTo.










504 Parte 3: Controles gráficos y programación orientada a eventos
___________________________________________________________
Resumen
En este capítulo:
• Vimos la forma de agregar el componente Microsoft Common Dialog Control a un
proyecto.
• Vimos el uso del control CommonDialog. en sus modalidades Color, Fuente, Imprimir
y Abrir/Guardar como.
• Vimos la forma en que se puede controlar, a través de una rutina de manejo de errores, la
selección Cancelar de los cuadros de diálogo.
• Vimos la importancia de los indicadores al utilizar objetos basados en CommonDialog.
Es importante que incluya cuadros de diálogo comunes en sus aplicaciones; esto tiene
múltiples beneficios, entre los que se encuentran la reducción de la curva de aprendizaje
requerida para aprender lo que usted desarrolla, el aspecto profesional de sus aplicaciones,
y la reducción en el tiempo de desarrollo (aproveche lo ya desarrollado).







Capítulo
20
Cómo trabajar
en una interfaz de
múltiples documentos
Objetivo
Conocer el enfoque de trabajo orientado a múltiples documentos, llamado Interfaz, de
Documentos Múltiples (MDI).
Al finalizar este capítulo deberá:
• Saber qué es un formulario MDI
• Saber cómo agregar varios formularios, nuevos o ya existentes, a un proyecto
• Saber cómo establecer un formulario como objeto inicial del proyecto
• Saber cómo invocar formularios en una aplicación basada en MDI
• Saber cómo se negocian los menús en un esquema MDI
Este capítulo es innecesario si piensa dedicarse a realizar programas sencillos de un
solo formulario. Como sabemos que eso no va a suceder, aquí se encuentra informa-
ción para organizar aplicaciones robustas que incluyan muchos formularios.
505








506 Parte 3: Controles gráficos y programación orientada a eventos
Fundamentos del entorno MDI
Difícilmente se encontrará en Windows una aplicación que tenga un solo formulario,
ya que lo normal es que una aplicación tenga varios, todos ellos concentrados en una
ventana general.
En entorno MDI es precisamente eso: la existencia de un formulario maestro, por lla-
marlo de alguna manera, que actúa como objeto inicial de toda una aplicación que
concentra dos o más formularios.
En este capítulo veremos la forma de controlar varios formularios a través de uno
maestro. La secuencia de tareas que debemos realizar para llegar a ello es la siguiente:
• Agregar al proyecto un formulario MDI (Proyecto - Agregar formulario MDI),
mismo que actuará como formulario maestro.
• Establecer el formulario MDI como objeto de inicio de la aplicación (Proyecto —
Propiedades de <Proyecto> - Objeto inicial - <Seleccíone el formulario MDI>).
• Agregar formularios nuevos o ya existentes al proyecto (Proyecto -Agregar for-
mulario), mismos que dependerán del formulario MDI.
• Establecer la dependencia de los formularios agregados con respecto al formulario
maestro, estableciendo a True la propiedad MDIChild de cada uno de los
formularios agregados.
>> Cómo agregar un formulario maestro para trabajo en MDI y los formularios
hijos. [20.01]
1. Inicie un nuevo proyecto EXE estándar.
2. Se iniciará un formulario nuevo. La propiedad Name de ese nuevo formulario es
Form1. Cambie el valor de dicha propiedad de tal forma que sea frmPrimero.
3. Vaya al menú Proyecto - Agregar formulario para agregar un nuevo formulario.
Cambie el valor de la propiedad Name de ese nuevo formulario a frmSegundo.
4. Vaya al menú Proyecto - Agregar formulario MDI. Se agregará un formulario de
tipo MDI, que será gráficamente distinto a los otros dos.









Capítulo 20: Cómo trabajar en una interfaz de múltiples documentos 507
5. Establezca la propiedad Name del formulario MDI a MDIPrincipal.
6. Vaya al menú Proyecto - Propiedades de Proyecto 1...
7. En la lista desplegable Objeto inicial, seleccione MDIPrincipal.
8. En el cuadro de texto Nombre de proyecto, escriba MDIDemo.
9. Acepte los valores.
Complemente los objetos que tiene, a fin de que en modo de diseño disponga de lo
siguiente:


Propiedades nuevas










508 Parte 3: Controles gráficos y programación orientada a eventos
Codificación de frmPrimero
• Editar Código: Form, Evento: Load.
frmPrimero.Width = 4000
frmPrimero.Height = 2000
Codificación de frmSegundo
• Editar Código: Form, Evento: Load.

frmPrimero.Width = 5000
frmPrimero.Height = 3000
Limitaciones que implica el uso de un formulario MDI
Cuando trabaja en un entorno MDI, se enfrentará a las siguientes limitaciones:
• Sólo puede establecer un formulario MDI por proyecto; de hecho, la opción de
menú Proyecto -Agregar formulario MDI se inhabilita una vez que agrega uno
de estos formularios.
• Una vez que se establece una dependencia entre un formulario y uno MDI (a
través de la propiedad MDIChild), el formulario dependiente no podrá exceder
en tamaño al MDI.
• Cualquier variación en el tamaño del formulario MDI afectará a los dependientes.
• Algunas propiedades de posición, como StartUpPosition ya no son
operables por un formulario dependiente.
• Cerrar el formulario MDI involucra cerrar todos los dependientes.
• En términos generales, un formulario MDI es un objeto contenedor de objetos
Form. En un formulario MDI no es posible agregar objetos de interfaz, como
CommandButton o TextBox
• La mayoría de los formularios MDI basan su operación a través de menús.
Si no recuerda bien la definición de menús, consulte el capítulo 14 del libro.





Capítulo 20: Cómo trabajar en una interfaz de múltiples documentos 509
>> Cómo trabajar con varios formularios. [20.02]
1. Agregue un menú a MDIPrincipal.

2. Agregue un menú a frmSegundo.

3. Establezca la propiedad NegotiateMenus de frmSegundo a True.



510 Parte 3: Controles gráficos y programación orientada a eventos
Métodos nuevos

Codificación de MDIPrincipal
• Editar código: mnuFormularios_Primero, Evento: Click.

frmPrimero.Show
• Editar código: mnuFormularios_Segundo, Evento: Click.
frmSegundo.Show
• Editar código: mnuFormularios_Salir, Evento: Click.
End
Ejecución
• Ejecute la aplicación.
Se estableció como objeto inicial del proyecto el formulario MDI, de nombre
MDIPrincipal. Este es el que inicia la aplicación.
La ventana aparece maximizada, ya que se estableció esa característica al for-
mulario MDI.
• Seleccione la opción de menú Formularios - Primero.
Se ejecutará el procedimiento mnuFormularios_Primero_Click, que
mostrará el formulario frmPrimero.







Capítulo 20: Cómo trabajar en una interfaz de múltiples documentos 511
• Seleccione la opción de menú Formularios - Segundo.
Se ejecutará el procedimiento mnuFormularios_Segundo_Click, que
mostrará el formulario frmSegundo.
Puesto que frmSegundo posee un menú definido, el formulario MDI y éste
negocian el menú principal de la aplicación. Observe que ya no está el menú del
formulario MDI disponible, sino que ahora está el menú del formulario
frmSegundo. Esta situación se mantendrá hasta que cierre la ventana
frmSegundo.
• Cierre la ventana frmSegundo. Después seleccione la opción de menú Formu-
larios - Salir.
Se ejecutará el procedimiento mnuFormularios_Salir_Click, que
terminará la ejecución de la aplicación.
El formulario frmPrimero nunca fue cerrado, pero por depender de
MDIPrincipal, se cierra con éste.
Cómo preparar su aplicación para compilación y distribución
Le recomendamos que al crear sus aplicaciones desarrolle por separado cada uno de
los formularios, de tal forma que no tenga tan congestionada su pantalla; esto claro,
si no utiliza o comparte código similar entre los múltiples formularios que integran
su aplicación; en ese caso tal vez prefiera tenerlos disponibles a todos.
Si opta por tener todos los formularios cargados en su proyecto, conforme los va
creando, no olvide que cada uno le resta desempeño a su computadora, ya que
Visual Basic tendrá que ver todos los formularios y sus componentes públicos todo
el tiempo.
Es recomendable que elabore los formularios por separado. Una vez que concluya,
defina el menú que desea e integre la aplicación en un formulario MDI. Modifique
las propiedades de su proyecto en aquellos aspectos que le sean relevantes (título
definitivo en Caption, icono, etcétera).
Le resta un solo paso:
Compilar su proyecto para generar el programa EXE que va a distribuir.
Si así lo desea, incluso puede crear los discos de instalación a través del Asistente
para empaquetado y distribución.

















512 Parte 3: Controles gráficos y programación orientada a eventos
____________________________________________________
Resumen
En este capítulo:

• Vimos qué es un formulario MDI y cuáles son sus limitaciones.
• Vimos cómo agregar varios formularios, nuevos o ya existentes, a un proyecto de
Visual Basic.
• Vimos cómo establecer un formulario como objeto inicial del proyecto.
• Vimos cómo invocar formularios en una aplicación basada en MDI, a través del
método Show.
• Vimos cómo se negocian los menús en un esquema MDI.

Este capítulo le servirá para integrar aplicaciones que se componen de varios formu-
larios. De esa forma, un solo programa ejecutable contendrá toda una aplicación.
































Capítulo
21
Controles ActiveX
para mejorar la interfaz

Objetivo
Conocer el uso de los controles comunes de Windows, que permiten enriquecer la
interfaz con elementos de apariencia profesional.
Al finalizar esté capítulo deberá:
• Saber colocar el componente Microsoft Windows Common Controls en un
proyecto de Visual Basic
• Saber utilizar el control ProgressBar
• Saber utilizar el control TreeView
• Saber utilizar el control StatusBar
• Saber utilizar el control ToolBar
Después de ver estos controles tan prácticos como vistosos, sus programas tendrán
una presentación profesional, necesaria para destacar sus proyectos.
513




514 Parte 3: Controles gráficos y programación orientada a eventos
Controles comunes de Windows
A estas alturas del libro ya puede desarrollar una interfaz eficiente y funcional. Muy
a pesar de ello, quizá no ha quedado satisfecho con la muy buena tarea realizada:
siente que ha "visto más", en lo que al diseño de interfaz se refiere.
Una interfaz siempre cumple con la función de introducir, mostrar o señalar elemen-
tos, sean éstos de datos o de procesos; la diferencia entre un control y otro es cómo
lo hace y cómo se ve.
En este capítulo le mostraremos algunos controles que seguramente ya ha visto al
trabajar en programas del entorno de Windows. A partir de este capítulo no sólo
será un espectador de tales controles, sino que podrá integrarlos en sus propios
desarrollos.
Para hacer más sencilla la explicación, improvisamos prácticas que no tienen otro
propósito que demostrar el uso de los controles, así que no se cuestione ¿qué hace
este programa? Mejor pregúntese ¿cómo defino este control y cómo lo utilizo?
En el capítulo 15 aprendió a integrar componentes en un proyecto de Visual Basic
(práctica 15.03), pues agregó el componente llamado Microsoft Windows Common
Controls para poder disponer del almacén de imágenes ImageList. En las
prácticas desarrolladas en este capítulo utilizará el almacén de imágenes
ImageList, pues está profundamente relacionado con todo el manejo gráfico de
los cuatro controles que exploraremos: ProgressBar, TreeView, ToolBar
y StatusBar.
ProgressBar ( Microsoft Windows Common Controls 6.0)
Es un control que permite mostrar gráficamente el avance de un proceso. Value
es la propiedad esencial de este tipo de controles, ya que a través de ella se hace
referencia a una posición relativa entre un límite mínimo (Min) y uno máximo
(Max).
Lo más relevante de este control es:







Capítulo 21: Controles ActiveX para mejorar la interfaz 515
=================================================
Lo inesperado: Cuando trabaja con el control ProgressBar, los errores
más comunes son:
• El valor de la propiedad no es válido (error 380 en tiempo de ejecución). Se pre-
senta cuando la propiedad Value del objeto ProgressBar está fuera de los
límites determinados por las propiedades Min y Max. Soluciones: revise que en
ningún caso la propiedad Value se encuentre abajo del límite establecido por la
propiedad Min, o por encima del límite establecido por la propiedad Max. Value
es un número entero, por lo que no podrá asignar valores que excedan el límite mar-
cado por el tipo de datos.
=================================================

>>Uso de objetos basados en el control ProgressBar. [21.01]
frmProgreso.frm
A continuación aprenderá a definir un objeto ProgressBar, que gráficamente
muestre
la variación de un número dentro de un intervalo.
Para no tener que simular un proceso iterativo, recurriremos al uso de un objeto
basado en el control Timer, el cual permitirá incrementar de manera paulatina el
valor de la propiedad Value, que causará la modificación gráfica de avance.
Implementación visual





516 Parte 3: Controles gráficos y programación orientada a eventos
Tabla de objetos y propiedades de frmprogreso

Propiedades nuevas en frmprogreso

Codificación de frmprogreso

• Editar código: (General), Evento: (Declarations)
Dim intCuentaAvance As Integer












Capítulo 21: Controles ActiveX para mejorar la interfaz 517
• Editar código: tmrBase, Evento:Timer.
intCuentaAvance% = intCuentaAvance% + 1
If intCuentaAvance% > pbrAvance.Max Then
MsgBox "El proceso ya concluyó"
End
End If
pbrAvance.Value = intCuentaAvance%
Ejecución
• Ejecute el programa.
Al cargarse el programa, en el área de declaraciones generales se declara una
variable que servirá para manejar el incremento que se provocará en la propiedad
Value.
• El control basado en Timer provocará la ejecución del procedimiento de evento
Timer, cada 50 milisegundos.
Al ejecutarse el procedimiento tmrBase_Timer, se incrementará el valor de la
variable que servirá para manejar el incremento que se provocará en la propiedad
Value, en cantidad de uno. Posteriormente, el procedimiento evaluará que el
número que se ha generado no exceda el máximo asignado al objeto, ya que se
provocaría un error; en caso de que así sea, aparecerá el mensaje de notificación
que informará que el proceso ya concluyó, procediendo después a dar por termi-
nada la ejecución del programa.
Si el número no excede el límite máximo establecido al objeto, la propiedad
Value asumirá el valor que tenga la variable que servirá para manejar el incre-
mento. Esto provocará las variaciones visuales que usted verá en su programa.
El objeto basado en el control Frame sólo fue colocado por cuestiones estéticas.
Un detalle muy importante que debe considerar es que la propiedad Value es de
tipo Integer, y por tal motivo, su límite máximo de valor es de 32,767. ¿Qué pasa
si desea mostrar la carga de datos a un archivo que contiene 50,000 registros o
datos?
Una solución sería que, en caso de que el número que modificará el valor del objeto
exceda el límite del tipo de datos utilizando, haga la siguiente equivalencia:











518 Parte 3: Controles gráficos y programación orientada a eventos

32767 / 50000 = 0.65534
Donde cada registro de los 50000 representaría un incremento en el valor de Value
de 0.65534; como el valor debe ser entero, basta con hacer la conversión:
pbrAvance.Value = int(NumRegistro * 0.65534)
Lo que nos cuidaría de un probable desfase.
TreeView ( Microsoft Windows Common Controls 6.0)
El control TreeView permite integrar un objeto similar al árbol de directorios que
utiliza el Explorador de Windows.

Cuando maneje dicha herramienta, deberá considerar que:
• Las opciones deben ser entendidas como nodos. Un conjunto de nodos Inter.-
relacionados constituye el sistema de opciones TreeView.
• Siempre hay una opción que contiene otras opciones, lo que forma una jerarquía.
El nodo principal, que no depende de ningún otro nodo, es el nodo raíz.
• El nodo que contiene a otros nodos se le llama nodo padre; a los nodos que son
contenidos y que pueden ser accesibles sólo a través del nodo padre, se les llama
nodos hijos. Existe una relación directa entre ellos; la imposibilidad de utilizar el
nodo padre impide el uso de los nodos hijos.
• Los nodos padre pueden expandirse (Expand) o contraerse (Collapse).
• Los nodos pueden tener asociado un gráfico que sugiera el estado en que se
encuentran (Image). Cuando un nodo padre está expandido, puede tener un








Capítulo 21: Controles ActiveX mejorar la interfaz 519
gráfico asociado diferente que cuando se encuentra contraído. Esto genera una
identidad visual a las opciones.
• Los nodos padre pueden anidarse, es decir, un nodo hijo puede actuar a su vez
como nodo padre.
• Es altamente recomendable que los gráficos a utilizar en el sistema de opciones
TreeView estén almacenados en un control ImageList. La propiedad
ImageList permite definir qué objeto de tipo ImageList actuará como
proveedor de imágenes.
• Todos los nodos son identificados de manera única dentro del sistema de
opciones TreeView, a través de una clave (key).
• Todas las opciones del sistema TreeView se encuentran contenidas en una
colección llamada Nodes.
• Las opciones del sistema de opciones de tipo árbol sólo pueden ser agregadas en
tiempo de ejecución.
Cómo agregar opciones a un sistema TreeView
Como vimos en el texto anterior, TreeView no permite agregar las opciones del
sistema en tiempo de diseño, por lo que éstas deberán ser agregadas en tiempo de
ejecución, preferentemente en el evento Form_Load o Form_Activate.
Ya hablamos de que todas las opciones están contenidas en una colección de nombre
Nodes. En otros objetos de tipo colección ya vimos cómo se añaden elementos a
través del método Add. En el caso de TreeView puede ser un poco diferente, en
virtud de que la sintaxis del método es un poco más compleja. Veamos la sintaxis
del método Add.
Sintaxis:

ObjetoTreeView.Nodes.Add Relatividad, Relación, Clave, TextoAMostrar, Imagen
Donde ObjetoTreeView es el objeto basado en el control TreeView. Relatividad
indica el nombre (Key) de la opción que actúa como padre del nodo que se está
agregando; en el caso de que la opción sea un nodo raíz, el valor simplemente se
omite. Relación indica el tipo de relación que guarda el nodo que se está agregando,
con respecto al nodo indicado en la Relatividad. Clave indica el nombre que se le
dará a la opción que se está agregando. TextoAMostrar es el texto que aparecerá en
la opción. Imagen es la clave que identifica a una imagen almacenada en un objeto
basado en el control ImageList.





520 Parte 3: Controles gráficos y programación orientada a eventos
Suponga que tiene un objeto ImageList de nombre imlBase. donde tiene
almacenados 2 gráficos, identificados como abrir y cerrar, en su propiedad Key.
También define un objeto basado en TreeView, al que llama tvwBase.
¿Cómo definiría un sistema TreeView?

Set tvwBase.ImageList = imlBase
vwBase.Nodes.Add , , "NodoRaiz", "Raiz", "abrir"
tvwBase.Nodes.Add "NodoRaiz", tvwChild, "Opcion_1", _
"1", "cerrar"
tvwOpciones.Nodes.Add "NodoRaiz", tvwChild, "Opcion_2", _
"2", "cerrar"
La primera línea especifica que las imágenes serán tomadas del objeto imlBase.
La siguiente línea establecería como nodo raíz el elemento identificado como
NodoRaiz; como podrá ver no hay relatividad con ninguna opción de nivel
superior, y por tanto, ninguna relación.
Las siguientes dos líneas sirven para definir los nodos hijos de NodoRaiz; para
ello, se especifica relatividad con respecto a dicha opción, después se determina que
la relación que se guarda es de tipo tvwChild (la más común de las relaciones),
después, cada una de las líneas especifica el nombre que tendrán cada una de las
opciones, lo que mostrarán de manera textual, así como la imagen que se desplegará
con ellas. La especificación de imagen no es requerida.
Los diferentes tipos de relación que se pueden especificar son los siguientes.









Capítulo 21: Controles ActiveX para mejorar la interfaz 521
>> Uso de TreeView. [21.02]
frmArbol.frm
A continuación aprenderá a generar un objeto basado en el control TreeView para
la selección de opciones; asimismo, aprenderá el manejo dinámico de imágenes para
las opciones, dependiendo de su estado.
1. Genere un nuevo proyecto EXE estándar.
2. Agregue el componente Microsoft Windows Common Controls 6.0 a su proyecto.
Proyecto - Componentes - Microsoft Windows Common Controls 6.0 -Aplicar -
Cerrar.
Implementación visual




3. Agregue un objeto de tipo ImageList. haciendo doble clic en el control que ya
debe encontrarse en el Cuadro de herramientas. Acomode el control de tal
forma que no estorbe. El nombre del objeto será imlBase.
4. Agregue un objeto de tipo TreeView, haciendo clic en el control que ya debe
encontrarse en el Cuadro de herramientas. Acomode el control de tal forma
que ocupe el espacio tal como lo muestra la figura 21.2. El nombre del objeto
será tvwOpciones.
5. Agregue las siguientes imágenes, con un tamaño de 16 x 16 (todas se encuentran
en la ruta c:\avbp\cap21\), utilizando la página de propiedades del objeto:

522 Parte 3: Controles gráficos y programación orientada a eventos


6. Para aceptar los cambios al agregar imágenes, le recomendamos hacer clic en el
botón Aplicar, y posteriormente en el botón Aceptar. Usted puede ingresar en
cualquier momento a la página de propiedades y modificar lo ya definido.

Tabla de objetos y propiedades de frmArbol


























Capítulo 21: Controles ActiveX para mejorar la Interfaz 523
Propiedades nuevas en frmArbol

Codificación de frmArbol
• Editar código: (General), Evento: (Declarations).
Set tvwOpciones.ImageList = imlBase
' Nivel 1 del árbol
tvwOpciones.Nodes.Add , , "Raiz", "Opciones", "cerrado"
' Nivel 2 del árbol
tvwOpciones.Nodes.Add "Raiz", tvwChild, "Disquete", _
"Usar disquete", "disquete"
tvwOpciones.Nodes.Add "Raiz", tvwChild, "HardDisk", _
"Usar Disco Duro", "hd"
tvwOpciones.Nodes.Add "Raiz", tvwChild, "CDROM", _
"Usar CD-ROM", "cd"
' Nivel 3 del árbol
tvwOpciones.Nodes.Add "Disquete", tvwChild, _
"DisqueteLectura", "Lectura", "lee"
tvwOpciones.Nodes.Add "Disquete", tvwChild, _
"DisqueteEscritura", "Escritura", "escribe"
tvwOpciones.Nodes.Add "HardDisk", tvwChild, "HDLectura", _
"Lectura", "lee"
tvwOpciones.Nodes.Add "HardDisk", tvwChild, _
"HDEscritura", "Escritura", "escribe"
tvwOpciones.Nodes.Add "CDROM", tvwChild, "CDLectura", _
"Lectura", "lee"




524 Parte 3: Controles gráficos y programación orientada a eventos

• Editar código: tvwOpciones, Evento: Expand.
Select Case Node.Key
Case "Raiz"
tvwOpciones.Nodes("Raiz").Image = "abierto"
End Select

• Editar código: tvwOpciones, Evento: Collapse.
Select Case Node.Key
Case "Raiz"
tvwOpciones.Nodes("Raiz").Image = "cerrado"
End Select

• Editar código: tvwOpciones, Evento: NodeClick.
Select Case Node.Key
Case "DisqueteLectura"
lblSeleccion.Caption = "Lectura de Disquete"
Case "DisqueteEscritura"
lblSeleccion.Caption = "Escritura de Disquete"
Case "HDLectura"
lblSeleccion.Caption = "Lectura de Disco Duro"
Case "HDEscritura"
lblSeleccion.Caption = "Escritura de Disco Duro"
Case "CDLectura"
lblSeleccion.Caption = "Lectura de CD-ROM"
End Select

• Editar código: cmdSalir, Evento: Click.
End
Ejecución
• Al cargarse el formulario, se ejecuta el evento Form_Load.
Primeramente, se establecerá el objeto basado en ImageList (imlBase)
como fuente de imágenes para el objeto basado en TreeView
(tvwOpciones). Puesto que las opciones no se pueden agregar en tiempo de
diseño, es necesario agregarlas en tiempo de ejecución y la carga del formato es
un buen momento para ello.

Capítulo 21: Controles ActiveX para mejorar la interfaz 525
Primero se define el nivel 1 del árbol, que se compone del nodo raíz; como sabe,
el nodo raíz no depende en ningún sentido de ningún otro nodo, por lo cual no
guarda relatividad con ningún nodo, de ningún tipo: esto hace que se omitan los
argumentos primero y segundo del método Add. Se asigna al nodo raíz el
nombre Raíz, con el texto Opciones, y con la imagen identificada como
cerrado en el objeto imlBase asociado, para que aparezca a la izquierda del
texto.
El nivel 2 del árbol agrega más opciones al sistema; observe que a estas opciones
se les especifica que guarden una relatividad con respecto a la opción identifi-
cada como Raiz, de tipo tvwChild. A cada una de las opciones se les da un
nombre único (Disquete, HardDisk y CDROM), un texto a desplegar
(Usar disquete, Usar Disco Duro, Usar CD-ROM) y el
identificador de la imagen contenida en ImIBase que se asociará a cada una de
las opciones (disquete, hd y cd).
El nivel 3 del árbol agrega más opciones al sistema, creando opciones con
relación a las opciones de segundo nivel, siguiendo la misma mecánica que las
opciones de nivel 2. Son de igual manejo; sólo el nodo raíz tiene diferencia con
respecto a su definición.
• Haga clic en el nodo raíz.
Se ejecutará el procedimiento tvwOpciones_Expand. Se determina qué nodo
fue el que se expandió. En caso de que fuera aquél identificado como Raiz, se
cambia la imagen asociada a dicho nodo, y se establece la imagen contenida en
imlBase, que se identifica como abierto.
• Haga clic en el nodo raíz nuevamente.
Cuando un nodo se encuentra expandido, al hacer clic en él, éste se contrae. Se
ejecutará el procedimiento de evento tvwOpciones_Collapse. Se
determina qué nodo fue el que se expandió. En caso de que fuera aquél
identificado como Raiz, se cambia la imagen asociada a dicho nodo, y se
establece la imagen contenida en imlBase, que se identifica como cerrado.
• Utilice el sistema de opciones TreeView hasta que tenga acceso a una de las
opciones de nivel 3.
Cada vez que hace clic en alguna de las opciones, sea el nivel que sea, se ejecuta
el evento tvwOpciones_Click. Siempre que eso sucede, se determina qué
nodo fue expandido. Dependiendo de la opción que haya señalado, se actualizará
el valor de la propiedad Caption del objeto lblSeleccion.
• Haga clic en Salir.
Se ejecutará el procedimiento de evento cmdSalir_Click, a través del cual
se da por terminada la aplicación.
526 Parte 3: Controles gráficos y programación orientada a eventos
Status Bar ( Microsoft Windows Common Controls 6.0)
Si entendió la forma de trabajar con el control TreeView, en el cual los elementos
se definen en modo de ejecución y se almacenan en una colección que puede ser
manipulada de forma sencilla, aprender otros controles no se le dificultará. Tal es el
caso de StatusBar, que permite integrar un objeto similar a la barra de estado de
cualquier programa basado en el entorno de Windows; en dicho objeto, que es una
especie de subventana, se distribuye un conjunto de paneles en donde puede
mostrarse información.
Lo relevante de StatusBar es el uso de la propiedad Text a nivel panel, ya que
su función es eminentemente estética. Podríamos resumir lo importante de los objetos
basados en este control:

Cómo agregar opciones a un objeto basado en StatusBar
StatusBar permite definir paneles, que no son otra cosa que espacios definidos
dentro de la barra de estado, en la cual puede asignar un contenido determinado. En un
objeto StatusBar se pueden tener hasta 16 paneles definidos. Para que los paneles
puedan ser referenciados, deben tener un nombre (Key).
Todos los elementos de un objeto StatusBar están contenidos en una colección lla-
mada Panels. Para efectos prácticos de nuestro capítulo, panel y elemento es lo mis-
mo. Como en otros objetos de tipo colección, sabemos que para añadir elementos se
requiere del método Add. Veamos la sintaxis del método Add.
Sintaxis:
ObjetoStatusBar.Panels.Add Índice, Clave, TextoAMostrar, TipoPanel, Imagen





Capítulo 21: Controles ActiveX para mejorar la interfaz 527
Donde ObjetoStatusBar es el objeto basado en el control StatusBar. Índice es el
número progresivo que identifica a cada uno de los elementos. Clave es el nombre por
medio del cual se podrá hacer referencia a cada uno de los elementos. Texto-AMostrar
es el texto que aparecerá de manera predeterminada en el panel. TipoPanel especifica
la naturaleza del panel. Imagen es la clave que identifica a una imagen almacenada en
un objeto basado en el control imageList.
Suponga que tiene definido un objeto basado en StatusBar, al que llama stbBase.
¿Cómo definiría 2 elementos en dicho objeto, si desea colocar texto en ellos, aunque
no de manera predeterminada?
stbBase.Panels.Add 1, "Primero", , sbrText
stbBase. Panels.Add 2, "Segundo", , sbrText
¿Cómo agregaría los textos Opción 1 y Opción 2 a los paneles?
stbBase.Panels("Primero").Text = "Opción 1'
stbBase.Panels("Primero").Text = "Opción 1'
Los objetos basados en StatusBar pueden asumir diferentes propiedades que afec-
tan su comportamiento y apariencia; para cada una de estas propiedades a las que
hacemos mención, existe un conjunto de constantes de Visual Basic que nos pueden
simplificar la tarea al definir los objetos. A continuación mostramos algunas de las
propiedades asociadas a los objetos basados en StatusBar, así como las constantes
que las determinan:
Constantes de la propiedad Style, a nivel objeto StatusBar:
















528 Parte 3: Controles gráficos y programación orientada a eventos
Constantes de la propiedad Alignment, a nivel Panel:

Constantes de la propiedad AutoSize, a nivel Panel:

Constantes de la propiedad Bevel, a nivel Panel:

Constantes de la propiedad Style, a nivel Panel:


Siguiendo con nuestro ejemplo, si queremos agregar un panel que muestre el estado
de Insert y otro que muestre la fecha, sería:
stbBase.Panels.Add 3, "PanelIns", , sbrIns
stbBase.Panels.Add 4, "PanelDate", , sbrDate



Capítulo 21: Controles ActiveX para mejorar la interfaz 529
ToolBar ( Microsoft Windows Common Controls 6.0)
El control ToolBar permite definir barras de herramientas o botones para una apli-
cación. Su manejo es similar a TreeView y a StatusBar: en este objeto se
agregan botones, los cuales se almacenan en una colección Buttons. Algunos
botones, dependiendo del estilo que tengan definido, pueden contener opciones,
mismas que se almacenan en una colección ButtonMenus.

ToolBar permite definir botones, que no son otra cosa que representaciones gráficas
sensibles al ratón, para seleccionar opciones. Cada botón puede tener un estilo pre-
determinado (Style), mismo que puede especificarse a través de constantes de
Visual Basic, las determinan el comportamiento y las capacidades del botón. Éstos
son los diferentes estilos de botón que se pueden establecer:






530 Parte 3: Controles gráficos y programación orientada a eventos
Tanto los botones como las opciones de menú deben tener un nombre único dentro
de la barra de herramientas, a través del cual se realizará la verificación de su
manejo.
Los botones de tipo Check, pueden asumir dos valores:
Constantes de la propiedad Value, a nivel Button, cuando es de tipo Check.

Al igual que los objetos de tipo TreeView, ToolBar puede tomar las imágenes que
aparecerán en los botones de un objeto basado en ImageList. invocando el nombre
que se le haya asignado a la imagen en dicho objeto; además de gráficos, un botón
puede contener texto si se utiliza la propiedad Caption, aunque no son mutuamente
excluy entes: se puede asignar un gráfico y un texto a un botón de manera simultánea.

Cómo agregar opciones a un objeto basado en StatusBar
Como en otros objetos de tipo colección, sabemos que para añadir elementos (en este
caso botones), se requiere del método Add. La sintaxis del método Add es la
siguiente:
Sintaxis:
ObjetoToolBar.Buttons.Add Índice, Clave, TextoAMostrar, EstiloBotón, Imagen
Donde ObjetoToolBar es el objeto basado en el control ToolBar. Índice es el
número progresivo que identifica a cada uno de los elementos o botones. Clave es el
nombre (Key) por medio del cual se podrá hacer referencia a cada uno de los
elementos. TextoAMostrar es el texto que aparecerá en el botón. EstiloBotón
especifica la naturaleza del botón. Imagen es la clave que identifica a una imagen
almacenada en un objeto basado en el control ImageList.
Suponga que tiene definido un objeto tbrBase basado en ToolBar en una
aplicación para editar un texto con formato. Suponga que también tiene un objeto
basado en ImageList llamado imlBase, que contiene las imágenes que se
utilizarán en la barra






Capítulo 21: Controles ActiveX para mejorar la interfaz 531
de herramientas (medida 16 x 16, de preferencia archivos con extensión .ico). Su-
ponga que las imágenes en el objeto imlBase se llaman page, folder y disquete,
que son similares a las que se muestran siempre en las barras de herramientas de las
aplicaciones basadas en Windows.
¿Cómo asociaría el objeto basado en ImageList con el objeto basado en ToolBar?
Set tbrBase. ImageList = imlBase
¿Cómo definiría 3 botones en el objeto tbrBase, para simular los primeros tres
botones de la barra de herramientas de la mayoría de las aplicaciones de Windows?
tbrBase.Buttons.Add 1, "Nuevo", , tbrDefault, "page"
tbrBase.Buttons.Add 2, "Abrir", , tbrDefault, "folder"
tbrBase.Buttons.Add 3, "Guardar", , tbrDefault, "disquete"
¿Cómo agregaría un cuarto botón, que sólo representara un espacio entre botones,
dentro de la barra de herramientas?
tbrBase.Buttons.Add 4, "Espacio1", , tbrSeparator

¿Cómo agregaría un quinto botón, de tipo Check. que indique el modo de edición
Negritas, con una Información sobre herramientas que diga Activar/Desactivar
Negritas?
tbrBase.Buttons.Add 5, "ActNegritas", "Negritas" , tbrCheck
tbrBase.Buttons. Item(5) .ToolTipText = _
"Activar/Desactivar Negritas"

¿Cómo agregaría un sexto botón, de tipo Dropdown que permita seleccionar el
tamaño de la fuente predeterminada?
tbrBase.Buttons.Add 6, "ActNegritas", "Negritas" , tbrCheck
tbrBase.Buttons.Item(6).ButtonMenus.Add 1, "T10", "10 Pts"
tbrBase.Buttons.Item(6).ButtonMenus.Add 2, "T12", "12 Pts"






532 Parte 3: Controles gráficos y programación orientada a eventos
>> Uso de StatusBar y ToolBar. [21.03]
frmBarraH.frm
A continuación aprenderá a generar un objeto basado en el control ToolBar para la
selección de opciones; se coordinará el uso de la barra de herramientas con una barra
de estado. El ejercicio demostrará los diferentes estilos de botones que puede tener
una barra de herramientas y la forma en que se puede capturar la selección realizada.
La aplicación permite enlazarse a una base de datos. Dicha base puede ser tomada de
diferentes fuentes (disquete, red o disco duro); una vez que se establece el enlace, se
tienen dos opciones, leer o escribir. Para mejorar el desempeño de la aplicación, puede
especificar o no el uso de índices.
1. Genere un nuevo proyecto EXE estándar.
2. Agregue el componente Microsoft Windows Common Controls 6.0 a su proyecto.
Proyecto - Componentes - Microsoft Windows Common Controls 6.0 -Aplicar
- Cerrar.

Implementadón visual


3. Agregue un objeto de tipo ImageList, haciendo doble clic en el control que ya debe
encontrarse en el Cuadro de herramientas. Acomode el control de tal forma que no
estorbe. El nombre del objeto será imlBase .
4. Agregue un objeto de tipo ToolBar, haciendo clic en el control que ya debe encontrarse
en el Cuadro de herramientas. Acomode el control de tal forma que ocupe el borde
superior de la ventana, que es la posición normal de las barras de herramientas. El nombre
del objeto será tbrBase.



Capítulo 21: Controles ActiveX para mejorar la Interfaz 533
5. Agregue un objeto de tipo StatusBar, haciendo clic en el control que ya debe
encontrarse en el Cuadro de herramientas. Acomode el control de tal forma
que ocupe el borde inferior de la ventana, que es la posición normal de las barras
de estado. El nombre del objeto será stbBase.
6. Agregue las siguientes imágenes con un tamaño de 16 x 16 (todas se encuentran
en la ruta c:\avbp\cap21\) en el objeto imlBase , utilizando la página de
propiedades del objeto:

7. Para aceptar los cambios al agregar imágenes, le recomendamos hacer clic en el
botón Aplicar, y posteriormente en el botón Aceptar. Usted puede ingresar en
cualquier momento a la página de propiedades, y modificar lo ya definido.

Tabla de objetos y propiedades de frmBarraH






534 Parte 3: Controles gráficos y programación orientada a eventos
Codificación de frmBarraH
• Editar código: Form, Evento: Activate.
Set tbrBase.ImageList = imlBase
' Define elementos de la barra de estado
With stbBase
.Panels.Add 1, "Panel1", , sbrText
.Panels.Add 2, "Panel2", , sbrText
.Panels.Add 3, "Panel3", , sbrText
.Panels.Add 4, "PanelCaps", , sbrCaps
.Panels.Add 5, "PanelFecha", , sbrDate
End With
' Define elementos de la barra de herramientas
With tbrBase.Buttons
.Add 1, "disquete", , tbrDefault, "disquete"
.Add 2, "red", , tbrDefault, "red"
.Add 3, "hd", , tbrDefault, "hd"
.Add 4, "separador1", , tbrSeparator
.Add 5, "operación", , tbrDropdown, "libro"
.Item(5).ButtonMenus.Add 1, "Escritura", "Escritura"
.Item(5).ButtonMenus.Add 2, "Lectura", "Lectura"
.Add 6, "separador2", , tbrSeparator
.Add 7, "acceso", , tbrCheck, "acceso"
.Item(1).ToolTipText = "Utilizar el disquete"
.Item(2).ToolTipText = "Utilizar la red"
.Item(3).ToolTipText = "Utilizar el disco duro"
.Item(5).ToolTipText = "Operación a realizar"
.Item(7).ToolTipText = "Acceso a través de índices"
End With
stbBase.Panels("Panel1").Text = "Disquete"
stbBase.Panels("Panel2").Text = "Lectura"
stbBase.Panels("Panel3").Text = "Sin índice"
• Editar código: tbrBase, Evento: ButtonClick.
Select Case Button.Key
Case "disquete"
stbBase.Panels("Panel1").Text = "Disquete"
MsgBox "Seleccionó el Disquete"





Capítulo 21: Controles ActiveX para mejorar la Interfaz 535
Case "red"
stbBase.Panels("Panel1").Text = "Red"
MsgBox "Seleccionó la Red"
Case "hd"
stbBase.Panels("Panel1").Text = "Disco Duro"
MsgBox "Seleccionó el Disco Duro"
Case "operacion"
MsgBox "Procede con el trabajo:" & vbCrLf & _
"Fuente/Destino:" & stbBase.Panels("Panel1").Text & vbCrLf & _
"Operación:" & stbBase.Panels("Panel2").Text & vbCrLf & _
"Indexación:" & stbBase.Panels("Panel3").Text
End
Case "acceso"
If tbrBase.Buttons("acceso").Value = tbrPressed Then
stbBase.Panels("Panel3").Text = "Utiliza Índice"
Else
stbBase.Panels("Panel3").Text = "Sin índice"
End If
End Select
• Editar código: tbrBase, Evento: ButtonMenuClick.
Select Case ButtonMenu.Key
Case "Lectura"
stbBase.Panels("Panel2").Text = "Lectura"
Case "Escritura"
stbBase.Panels("Panel2").Text = "Escritura"
End Select
Ejecución
• Al activarse el formulario, se ejecuta el evento Form_Activate.
Primeramente, se establecerá el objeto basado en imageList (imlBase ) como
fuente de imágenes para el objeto basado en ToolBar (tbrBase).
Posteriormente se procede a la definición de paneles para el objeto stbBase;
para ello se agrega elementos a la colección Panels del objeto, a través del
método Add, empleando una estructura With.
Los tres primeros paneles que se definen están preparados para mostrar, en forma
de texto, el último estado de selección que se haya realizado a través de la barra de
herramientas. Los siguientes dos paneles mostrarán información que el mismo
sistema proporciona (como el uso de BloqMayús y la fecha).


536 Parte 3: Controles gráficos y programación orientada a eventos
Posteriormente se procede a la definición de botones para el objeto tbrBase; para
ello se agrega elementos a la colección Buttons del objeto, a través del método
Add, empleando una estructura With.
Los primeros tres botones son de tipo Default, y se les asigna una de las imágenes
que se encuentran contenidas en imlBase .
El cuarto y sexto botones son de tipo Separator, por lo que sólo cumplen con esa
función.
El quinto botón es especial, ya que su estilo es Dropdown. Debido al estilo que
posee, se entiende que tendrá una lista desplegable asociada. Las opciones de la lista
desplegable se encontrarán en la colección ButtonMenus. Primero se define el
botón, y luego se definen para ese mismo botón (Item(5)) las opciones de su lista
desplegable, mediante el método Add.
El séptimo botón se definirá como de tipo Check, y tendrá asociada una imagen
contenida en el objeto imlBase .
Ya han sido definidos todos los botones. El procedimiento culmina cuando se le
asignan los valores que se mostrarán de inicio en los primeros tres paneles de la
barra de estado.
• Haga clic en cualquiera de los primeros tres botones de la barra de herramientas.
Al hacer clic se ejecutará el procedimiento tbrBase_ButtonClick. Este
procedimiento tiene un argumento implícito de tipo objeto, con lo cual todas las
propiedades de dicho objeto también constituyen un argumento implícito; dentro de
estas propiedades que actúan como argumentos implícitos, está la propiedad Key del
botón, misma que se utiliza en una estructura Select Case. Todo lo anterior
puede decirse de manera más sencilla: al ejecutarse el evento, ya se sabe en qué
botón se hizo clic, a través de Button. Key.
Dependiendo del botón en que se haya hecho clic, se desencadenará una opción,
consistente en actualizar el primer panel de la barra de estado y mostrar un mensaje
que indique que la selección ha sido reconocida.
• Haga clic en el séptimo botón (acceso).
Al hacer clic, se ejecutará el procedimiento tbrBase_ButtonClick. A través
del argumento implícito Button.Key, el procedimiento de evento sabe que se hizo
clic en el séptimo botón, que se llama acceso, y ejecuta el código que le corresponde
dentro del Select Case.
En caso de que el botón se encuentre activado (tbrPressed), el tercer panel de la
barra de estado se actualiza aclarando que se utilizan índices; si por el contrario el
botón no se encuentra activado, el tercer panel de la barra de estado se actualiza
aclarando que no se utilizan índices.





Capítulo 21: Controles ActiveX para mejorar la interfaz 537
Cuando hace clic en un botón de tipo Check, primero se cambia su estado (de
activado a desactivado, o viceversa), y después se procesa el evento ButtonClick.
• Active la lista desplegable del quinto botón, haciendo clic en la flecha hacia abajo que
aparece al lado del botón. Seleccione la opción Lectura.
Al seleccionar una opción que forma parte de una lista desplegable de un botón de
tipo Dropdown, provoca la ejecución de tbrBase_ButtonMenuClick. Este
procedimiento tiene un argumento implícito de tipo colección, con lo cual todas las
propiedades de dicha colección también constituyen un argumento implícito;
dentro de estas propiedades que actúan como argumentos implícitos, está la propiedad
Key de la opción de menú perteneciente a un botón, misma que es utilizada en una
estructura Select Case. Todo lo anterior puede decirse de manera más sencilla: al
ejecutarse el evento, ya se sabe qué opción del menú se seleccionó de
ButtonMenu.Key.
La estructura Select Case considera para su ejecución el nombre de la opción
seleccionada (ButtonMenu.Key); en este caso, la opción seleccionada fue Lectura,
por lo que actualiza el segundo panel de la barra de estado, especificando que la
operación que se desea hacer es leer.
• Haga clic en el quinto botón (no despliegue el menú).
Los botones de tipo Dropdown tiene doble función: despliegan un menú, pero
también actúan como botones normales. Al hacer clic, se ejecutará el procedimiento
tbrBase_ButtonClick. A través del argumento implícito Button.Key, el
procedimiento de evento sabe que hizo clic en el quinto botón, que se llama
operación, y ejecuta el código que le corresponde dentro del Select Case.
La acción que corresponde es la de enviar un mensaje que contiene el resumen de
todas las opciones seleccionadas hasta el momento. Para ello nos apoyamos en los
valores de los últimos paneles seleccionados.

_____________________________________________________
Resumen
En este capítulo:
• Vimos cómo activar los controles del componente Microsoft Windows Common
Controls en un proyecto de Visual Basic.
• Vimos cómo se utiliza el control ProgressBar.
• Vimos cómo se utiliza el control TreeView.
• Vimos la estructura y organización de elementos del control TreeView, a través
de nodos, y su relatividad.





538 Parte 3: Controles gráficos y programación orientada a eventos
• Vimos la asociación de contenedores de imágenes ImageList con otros controles ActiveX
preparados para la utilización directa de dicho contenedor.
• Vimos cómo se utiliza el control StatusBar.
• Vimos cómo los paneles de una barra de estado pueden tomar directamente valores del
sistema.
• Vimos cómo se utiliza el control ToolBar.
• Vimos las clases de botones que se pueden especificar en una barra de herramientas, tales
como los botones de activar y desactivar, y botones que actúan como menús de lista
desplegable.
Es importante que domine el contenido del capítulo si desea que sus aplicaciones se vean y se
sientan como aplicaciones profesionales de Windows.















Parte 4
Archivos
y bases de datos
Existe una verdad irrefutable: la mayoría de las organizaciones
paga por desarrollos que actualicen bases de datos; lo demás es
extra.
Las bases de datos son las fuentes de la información, misma que
permite tomar decisiones de negocios que determinan el éxito o
fracaso de una organización.
En esta parte del libro nos ocuparemos de aprender cómo generar
bases de datos de escritorio y centralizadas, de tal manera que
pueda construir tanto aplicaciones sencillas como aplicaciones
multiusuario con acceso a bases de datos robustas como SQL
Server, ORACLE, Informix, etcétera. Para ello exploraremos,
mediante Visual Basic, las colecciones de objetos DAO y ADO,
así como enlaces ODBC.
También veremos el uso del control Data, y la forma en que
podemos utilizar los archivos de texto plano para la transferencia
de información entre bases de datos de diferentes plataformas y
controladores de bases de datos.
También aprenderemos la manera de elaborar informes de base
de datos para salida en papel o pantalla, utilizando el Data Report.
Después de esta parte quedará listo para trabajar en cualquier
empresa, utilizando Visual Basic.
Aprender el manejo de bases de datos es la parte más rentable
de todo curso o seminario de Visual Basic, y por qué no, de la
lectura de cualquier libro del lenguaje. ¡Sáquele partido!
Capítulos:
22, 23, 24.25,26,27
28,29.30
Número de prácticas: 32


539



540





















Capítulo
22
Bases de datos
y DAO
Objetivo
Uniformar conceptos de bases de datos, a fin de que los capítulos que tratan la crea-
ción y manipulación de bases de datos sean mejor entendidos.
Al finalizar este capítulo deberá:
• Conocer la teoría de las bases de datos
• Saber qué son las bases de datos, las tablas, los registros y los campos
• Saber qué es una clave primaria y qué es una clave externa
• Saber qué es la integridad referencial
• Saber qué es DAO y cuál es su jerarquía
• Saber qué es el DDL y el DML
Si usted es un experto en bases de datos, sólo lea lo relativo a DAO y comprenda
claramente la estructura de la base de datos Ventas que utilizaremos en esta parte 4
del libro. Si no es experto en bases de datos, lea todo el capítulo y entienda los con-
ceptos, ya que de lo contrario no encontrará lógica alguna.
541




542 Parte 4: Archivos y bases de datos
Conceptos de bases de datos
Uno de los pilares de la computación y su evolución es la capacidad de las aplica-
ciones de almacenar datos. Si las computadoras fueran incapaces de almacenar datos,
serían como simples calculadoras; aquellas tareas complejas o muy extensas serían
imposibles y la determinación de la información recaería en el hombre y otros medios
de registro hasta cierto punto primitivos hoy en día.

Todos sabemos que es importante almacenar información. Nuestra misión como pro-
gramadores, atendiendo este aspecto, es garantizar que el almacenamiento se realice
correctamente.
Resulta importante ver algunos conceptos de bases de datos que es necesario conocer
antes de dominar el manejo de datos a través de Visual Basic; ciertamente este libro
no es para enseñarle análisis y modelación de bases de datos, pero resulta conveniente
realizar un breve repaso de conceptos con la finalidad de unificar términos.
Base de datos, tabla, registro y campo
Una base de datos es una colección de datos organizados de tal forma que puedan ser
recuperados y procesados para generar información, para un propósito específico.
Existen varios enfoques de base de datos (jerárquico, redes, relacional, orientado a
objetos); el que nos interesa, por ser el mas utilizado es el modelo relacional.
==================================================
Nota: El modelo relacional es el modelo de datos que mayor marketshare posee;
todas las bases de datos importantes, tales como SQL Server, Informix, Oracle,
Progress, FoxPro, Access, entre otras, basan su manejo en dicho modelo.
==================================================
En el modelo relacional, la base de datos se compone de tablas. Una tabla puede vi-
sualizarse como una matriz de datos de dos dimensiones, que almacena datos de una
sola naturaleza, uniforme y completa.
La tabla puede estar compuesta por una o más columnas, a las que se les conoce como
campos, también llamados atributos.
La tabla puede contener una o más filas, a las que se les conoce como registros; un
registro es una ocurrencia de la colección de campos.






Capítulo 22: Base de datos y DAO 543
Los equivalentes en inglés de los términos que hemos definidos son utilizados por
Visual Basic para simplificar el uso del lenguaje, haciendo que dichas palabras sean
de uso reservado; base de datos, tabla, registro y campo, tendrán significado en Visual
Basic a través de las palabras Datábase, Table, Record y Field, respectivamente.

En este caso, la tabla Articulo, tiene 3 campos (IDArticulo,
NombreArticulo, PrecioUnitario); contiene 4 ocurrencias de todos los
campos, es decir, 4 registros. Conceptualmente hablando, en una tabla no se pueden
tener cantidades dispares de ocurrencias entre los campos (por ejemplo, tener 10
ocurrencias del campo NombreArticulo, y sólo 5 en el campo de
PrecioUnitario). A la obligación de que en un registro, a cada uno de los
campos le corresponda uno y sólo uno de los restantes, se le llama principio de
correspondencia. En un registro, a cada IDArticulo le corresponde uno y sólo uno,
NombreArticulo y PrecioUnitario.
Clave primaria
Los registros son diferentes entre sí, ya que si dos registros son exactamente iguales,
uno de ellos es innecesario. La diferencia entre los registros puede darse en uno o más
campos; sería complicado tener que estar comparando un registro (campo por campo)
contra otro registro, a fin de encontrarles diferencias. Hacer ese tipo de comparación
sería como determinar que dos páginas de un libro son distintas, basándonos en la lec-
tura de ambas hojas hasta encontrar las discrepancias; ¿qué es lo que hacemos para
saber que una página es diferente de otra? Leemos la página. Ese dato es el mínimo,
suficiente y necesario para diferenciar las páginas una de otra.
Al conjunto de campos que en cantidad mínima, suficiente y necesaria identifican
como único a un registro dentro de una tabla, se le llama clave primaria. Ejemplos de
claves primarias aplicadas en la práctica son muchas. Número de seguro social, Nú-
mero de licencia de conducir. Número de matrícula escolar, etcétera. Las caracterís-




544 Parte 4: Archivos y bases de datos
ticas de la cantidad de campos que componen la clave primaria (cantidad mínima,
suficiente y necesaria), se justifica con el siguiente ejemplo: suponga que en una tabla
desea almacenar los registros de las licencias de manejo; suponga que los campos son
los siguientes:
Licencia = NumeroLicencia + NombreConductor +
ApellidoPaterno + ApellidoMaterno +
FechaNacimiento + TipoLicencia.
Por ejemplo, no podría escoger como clave primaria los campos de
NombreConductor + ApellidoPaterno + ApellidoMaterno, en virtud
de que es posible, aunque remotamente, que los nombres de dos personas coincidan de
manera exacta; por tanto la clave primaria ya no cumpliría con su función de
identificar de manera única a los registros en todos los casos.
Otra posibilidad equivocada sería NumeroLicencia + FechaNacimiento.
Es equivocada debido a que no es la cantidad mínima de campos, ya que el
NumeroLicencia sólo cumple adecuadamente como clave primaria, sin embargo,
la presencia de FechaNacimiento es excesiva.
La clave primaria, compuesta por el campo NumeroLicencia, es la más adecuada
para este ejemplo: