Guia de Visual Basic by Nelson Alcázar

Contenido Unidad 1 ............................................................................................................ 12 Introducción a Visual Basic ............................................................................... 12 1.1. Nociones básicas .................................................................................... 12 1.1.1. Historia ....................................................................................................... 12 1.1.2. Concepto .................................................................................................... 14 1.1.3. Ventajas ..................................................................................................... 14 1.1.4. Requerimientos ........................................................................................... 15 1.1.5. Compilación ................................................................................................ 15 1.1.6. Modos de operación .................................................................................... 16 1.1.7. Reglas de Visual Basic ................................................................................. 16 1.2. Teoría de Objetos ................................................................................... 18 1.2.1. Clase .......................................................................................................... 18 1.2.2. Objeto ........................................................................................................ 18 1.2.3. Propiedades ................................................................................................ 19 1.2.4. Métodos...................................................................................................... 20 1.2.5. Evento ........................................................................................................ 20 1.2.6. Procedimientos de evento ............................................................................ 21 1.2.7. Encapsulación ............................................................................................. 22 1.2.8. Polimorfismo ............................................................................................... 22

Unidad 2 ............................................................................................................ 23 Trabajar con Visual Basic .................................................................................. 23 2.1. Estructura de proyecto ........................................................................... 23 2.1.1. Proyecto ..................................................................................................... 23 2.1.2. Módulos ...................................................................................................... 23 2.1.3. Procedimientos ............................................................................................ 24 2.1.4. Declaraciones .............................................................................................. 24 2.2. IDE de Visual Basic................................................................................. 25 2.2.1. Entorno de Desarrollo Integrado (IDE).......................................................... 25 2.2.2. Ventana Explorador de Proyecto ................................................................... 25 2.2.3. Ventana Diseñador de Formularios ............................................................... 26 2.2.4. Ventana de código....................................................................................... 26 2.2.5. Caja de herramientas................................................................................... 27 2.2.6. Ventana de propiedades .............................................................................. 27 2.2.7. Funciones básicas del IDE ............................................................................ 28 2.3. Crear una aplicación............................................................................... 32 2.3.1. Pasos básicos .............................................................................................. 32 2.3.2. Colocar los objetos ...................................................................................... 32 2.3.3. Establecer las propiedades ........................................................................... 33 2.3.4. Escribir el código ......................................................................................... 34

Unidad 3 ............................................................................................................ 36 Objetos de Visual Basic ..................................................................................... 36 3.1. El formulario .......................................................................................... 36 3.1.1. Formulario (Clase: Form) ............................................................................. 36 3.1.2. Propiedades de formularios .......................................................................... 37 3.1.3. Métodos de formularios ............................................................................... 38 3.1.4. Eventos de formularios ................................................................................ 38

3.2. Los controles .......................................................................................... 39 3.2.1. Etiqueta (Clase: Label) ................................................................................ 39 3.2.2. Botón de comando (Clase: CommandButton) ................................................ 40 3.2.3. Caja de texto (Clase: TextBox) ..................................................................... 41 3.2.4. Marco (Clase: Frame) .................................................................................. 43 3.2.5. Caja de imagen (Clase: PictureBox) .............................................................. 43 3.2.6. Botón de opción (Clase: OptionButton) ......................................................... 44 3.2.7. Caja de verificación (Clase: CheckBox) ......................................................... 44 3.2.8. Caja de lista (Clase: ListBox) ........................................................................ 44 3.2.9. Caja combinada (Clase: ComboBox) ............................................................. 45 3.2.10. Barra de desplazamiento (Clase: HScrollBar, VScrollBar) ................................ 46 3.2.11. Temporizador (Clase: Timer)........................................................................ 46 3.2.12. Imagen (Clase: Image) ................................................................................ 46 3.2.13. Figura (Clase: Shape) .................................................................................. 47 3.2.14. Línea (Clase: Line) ...................................................................................... 47 3.2.15. Ubicación de los controles básicos ................................................................ 47 3.2.16. Ejemplo de los controles básicos .................................................................. 48

Unidad 4 ............................................................................................................ 50 Código en Visual Basic ....................................................................................... 50 4.1. Espacios de memoria .............................................................................. 50 4.1.1. Identificadores ............................................................................................ 50 4.1.2. Tipos de datos ............................................................................................ 50 4.1.3. Declaración de espacios de memoria ............................................................ 52 4.1.4. Alcance de variables y constantes................................................................. 53 4.1.5. Declaración de variables .............................................................................. 53 4.1.6. Declaración de constantes (simbólicas) ......................................................... 54 4.1.7. Constantes intrínsecas ................................................................................. 54 4.1.8. Arreglos ...................................................................................................... 55 4.1.9. Objetos y espacios de memoria .................................................................... 56 4.2. Operadores ............................................................................................. 57 4.2.1. Aritméticos.................................................................................................. 57 4.2.2. Lógicos ....................................................................................................... 58 4.2.3. Relacionales ................................................................................................ 58 4.2.4. Operadores especiales ................................................................................. 59 4.2.5. Precedencia de los operadores ..................................................................... 59 4.3. Estructuras de control ............................................................................ 60 4.3.1. Programación estructurada .......................................................................... 60 4.3.2. Tipos de estructuras .................................................................................... 60 4.3.3. Estructura bifurcativa If-Then-ElseIf-Else ...................................................... 60 4.3.4. Estructura bifurcativa Select-Case................................................................. 61 4.3.5. Estructura repetitiva For-Next ...................................................................... 62 4.3.6. Estructura repetitiva Do-Loop ....................................................................... 63 4.4. Procedimientos....................................................................................... 64 4.4.1. Procedimientos y subrutinas ......................................................................... 64 4.4.2. Ventajas de los procedimientos .................................................................... 65 4.4.3. Clasificación de procedimientos .................................................................... 66 4.4.4. Alcance de procedimientos ........................................................................... 67 4.4.5. Trabajar con procedimientos ........................................................................ 67 4.4.6. Transferencia de parámetros........................................................................ 69 4.4.7. Ejemplo completo de la unidad .................................................................... 70

Unidad 5 ............................................................................................................ 71 Funciones intrínsecas ........................................................................................ 71 5.1. Funciones en general ............................................................................. 71 5.1.1. Expresiones ................................................................................................ 71 5.1.2. Funciones ................................................................................................... 71 5.1.3. Instrucciones .............................................................................................. 72 5.2. Funciones de cadena .............................................................................. 72 5.2.1. Tratamiento de cadenas .............................................................................. 72 5.2.2. Cambiar a mayúsculas y minúsculas ............................................................. 73 5.2.3. Determinar la longitud de una cadena .......................................................... 73 5.2.4. Buscar caracteres dentro de una cadena ....................................................... 73 5.2.5. Extraer e insertar caracteres a una cadena ................................................... 74 5.2.6. Tratamiento de espacios en blanco ............................................................... 74 5.2.7. Convertir a número y a cadena .................................................................... 75 5.2.8. Obtener cadenas de caracteres con formato ................................................. 75 5.2.9. Mapa de caracteres ..................................................................................... 77 5.3. Funciones numéricas.............................................................................. 78 5.3.1. Funciones matemáticas ................................................................................ 78 5.3.2. Funciones de ajuste decimal ........................................................................ 78 5.3.3. Función de número aleatorio ........................................................................ 79 5.4. Funciones de fecha y hora...................................................................... 79 5.4.1. Obtener la fecha y hora del sistema.............................................................. 79 5.4.2. Establecer la fecha y hora del sistema .......................................................... 79 5.4.3. Realizar cálculos con fechas y horas ............................................................. 79 5.4.4. Devolver fechas y horas ............................................................................... 82 5.4.5. Cronometrar procesos ................................................................................. 82 5.5. Funciones de Objetos ............................................................................. 82 5.5.1. Cuadro de diálogo de entrada InputBox ........................................................ 82 5.5.2. Cuadro de diálogo de mensajes MsgBox ....................................................... 83

Unidad 6 ............................................................................................................ 87 Archivos............................................................................................................. 87 6.1. Nociones básicas .................................................................................... 87 6.1.1. Unidades .................................................................................................... 87 6.1.2. Archivos ...................................................................................................... 88 6.1.3. Directorios .................................................................................................. 88 6.2. Instrucciones de archivos ...................................................................... 89 6.2.1. Instrucciones para manipular directorios ....................................................... 89 6.2.2. Instrucciones para manipular archivos .......................................................... 89 6.3. Funciones de archivos ............................................................................ 91 6.3.1. Funciones para manipular directorios ............................................................ 91 6.3.2. Funciones de archivos cerrados .................................................................... 92 6.3.3. Funciones de archivos abiertos ..................................................................... 92 6.4. Objetos de archivos................................................................................ 93 6.4.1. Caja de lista de archivos (Clase: FileListBox) ................................................. 93 6.4.2. Caja de lista de directorio (Clase: DirListBox) ................................................ 93 6.4.3. Caja de lista de unidades (Clase: DriveListBox) ............................................. 93 6.4.4. Cuadro de diálogo común (Clase: CommonDialog) ........................................ 94

6.5. Archivos secuenciales............................................................................. 97 6.5.1. Abrir archivos secuenciales .......................................................................... 97 6.5.2. Leer archivos secuenciales ........................................................................... 97 6.5.3. Escribir en archivos secuenciales .................................................................. 97 6.6. Archivos aleatorios ................................................................................. 98 6.6.1. Abrir archivos aleatorios............................................................................... 98 6.6.2. Leer registros de archivos aleatorios ............................................................. 99 6.6.3. Escribir registros en archivos directos ..........................................................100 6.6.4. Localizar una posición de registro ................................................................100 6.6.5. Tareas comunes de archivos aleatorios ........................................................100

Unidad 7 .......................................................................................................... 103 Bases de Datos ................................................................................................ 103 7.1. Introducción a Bases de Datos ............................................................. 103 7.1.1. Nociones básicas ........................................................................................103 7.1.2. Arquitectura de bases de datos ...................................................................104 7.1.3. Tecnologías de bases de datos ....................................................................104 7.1.4. Proveedores OLE DB...................................................................................105 7.1.5. Lenguajes de bases de datos ......................................................................106 7.1.6. Modos de manipulación de registros ............................................................107 7.2. Objetos de acceso a datos ADO ............................................................ 107 7.2.1. Modelo de objetos de ADO..........................................................................107 7.2.2. El objeto Connection...................................................................................108 7.2.3. El objeto Recordset ....................................................................................110 7.2.4. Procedimiento para utilizar el modelo ADO ...................................................112 7.3. Acceso a datos mediante Visual Basic y ADO ....................................... 113 7.3.1. Métodos para utilizar ADO...........................................................................113 7.3.2. Controles enlazados a datos ........................................................................114 7.3.3. El control de datos ADO ..............................................................................114 7.3.4. Creación de objetos ADO en código .............................................................118 7.3.5. El diseñador de entorno de datos ................................................................120 7.4. Lenguaje de consulta estructurado SQL ............................................... 122 7.4.1. Introducción a SQL .....................................................................................122 7.4.2. Elementos del lenguaje SQL ........................................................................123 7.4.3. Consultas de selección (SELECT) .................................................................124 7.4.4. Consultas de acción (DELETE, INSERT, UPDATE) .........................................125 7.5. Reportes de bases de datos.................................................................. 126 7.5.1. Introducción a reportes ..............................................................................126 7.5.2. Pasos para crear un reporte ........................................................................127 7.5.3. Partes del generador de reportes ................................................................131 7.5.4. Campos de un reporte ................................................................................132

Unidad 8 .......................................................................................................... 134 Tecnología OLE ................................................................................................ 134 8.1. Teoría de OLE ....................................................................................... 134 8.1.1. Estándar COM ............................................................................................134 8.1.2. Automatización ..........................................................................................134 8.1.3. Tecnología OLE y ActiveX ............................................................................135 8.1.4. Componentes ActiveX .................................................................................135 8.1.5. Componentes en proceso y fuera de proceso ...............................................136

8.2. Aplicaciones habilitadas para ActiveX .................................................. 137 8.2.1. Objetos insertables .....................................................................................137 8.2.2. Control contenedor OLE ..............................................................................137 8.2.3. Control de aplicación ActiveX.......................................................................140 8.3. Componentes de código ....................................................................... 141 8.3.1. Referencias a un objeto ..............................................................................141 8.3.2. Crear referencias a objetos .........................................................................142 8.3.3. Utilizar las propiedades y métodos de un objeto ...........................................142 8.3.4. Responder a los eventos de un objeto .........................................................143 8.3.5. Ejemplo completo usando componente de código .........................................144 8.4. Controles ActiveX ................................................................................. 145 8.4.1. Cargar controles ActiveX .............................................................................145 8.4.2. Archivos de controles ActiveX ......................................................................145 8.4.3. Control ActiveX Animation ...........................................................................146 8.4.4. Control ActiveX CoolBar ..............................................................................147 8.4.5. Control ActiveX DTPicker .............................................................................148 8.4.6. Control ActiveX ImageList ...........................................................................148 8.4.7. Control ActiveX TreeView ............................................................................149 8.4.8. Control ActiveX ListView..............................................................................151 8.4.9. Control ActiveX ToolBar ..............................................................................154 8.4.10. Control ActiveX TabStrip .............................................................................155 8.4.11. Conclusiones sobre ActiveX .........................................................................156

Unidad 9 .......................................................................................................... 157 Funciones API.................................................................................................. 157 9.1. Teoría de funciones API ....................................................................... 157 9.1.1. Funciones API ............................................................................................157 9.1.2. Las API de Windows ...................................................................................157 9.1.3. Declarar funciones API ................................................................................157 9.1.4. Utilizar funciones API ..................................................................................158 9.1.5. Visor de texto API ......................................................................................159 9.2. Técnicas para usar funciones API ........................................................ 160 9.2.1. Resolver conflictos de nombre de API ..........................................................160 9.2.2. Enviar cadenas a funciones API ...................................................................160 9.2.3. Recibir cadenas de funciones API ................................................................160 9.2.4. Utilizar procedimientos generales auxiliares ..................................................161 9.2.5. Utilizar funciones API sin parámetros ...........................................................162

Consideración final .......................................................................................... 163

Índice de figuras Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura

1.1.2.1.2.2.2.3.2.4.2.5.2.6.2.7.2.8.2.9.2.10.2.11.2.12.2.13.2.14.2.15.2.16.2.17.2.18.3.1.3.2.3.3.3.4.4.1.4.2.4.3.4.4.4.5.4.6.5.1.5.2.5.3.5.4.5.5.5.6.5.7.5.8.5.9.5.10.5.11.5.12.5.13.6.1.6.2.6.3.6.4.6.5.7.1.7.2.7.3.7.4.-

Evolución del Basic. ............................................................................... 13 Estructura de un proyecto ...................................................................... 24 Ventana Proyecto .................................................................................. 25 Ventana Diseñador de formulario ........................................................... 26 Ventana de código ................................................................................. 26 Cuadro de herramientas ......................................................................... 27 Ventana de propiedades. ....................................................................... 27 Diálogo Nuevo proyecto al iniciar Visual Basic ......................................... 28 Diálogo Nuevo proyecto estándar ........................................................... 28 Diálogo Agregar formulario .................................................................... 29 Menú emergente del explorador de proyecto ........................................... 29 Diálogo Agregar módulo ........................................................................ 30 Diálogo Propiedades del proyecto ........................................................... 31 Diálogo Opciones de editor .................................................................... 31 Agregar objetos a un formulario ............................................................. 33 Modificar las propiedades de objetos ...................................................... 33 Seleccionar objeto para procedimiento de evento .................................... 34 Seleccionar evento para procedimiento de evento ................................... 35 Escribir código en un procedimiento de evento ........................................ 35 Despliegue del operador punto. .............................................................. 37 Elementos básicos de una ventana. ........................................................ 38 Caja de herramientas (Clases). ............................................................... 47 Ejemplo de los controles básicos. ........................................................... 48 Diálogo Examinador de objetos. ............................................................. 55 Estructura If-Then-Else simple................................................................ 61 Estructura If-Then-Else completa............................................................ 61 Estructura Select Case ........................................................................... 62 Estructura For-Next. .............................................................................. 63 Estructuras Do-Loop. ............................................................................. 64 Función supuesta Licuar......................................................................... 71 Función en general ................................................................................ 72 Función Seno. ....................................................................................... 72 Posiciones de una cadena de caracteres ................................................. 73 Cuadro de diálogo InputBox ................................................................... 83 Cuadro de diálogo MsgBox ..................................................................... 83 Cuadro de mensaje de Información ........................................................ 84 Cuadro de mensaje de Crítico ................................................................. 84 Cuadro de mensaje de Exclamación ........................................................ 84 Cuadro de mensaje de Pregunta ............................................................. 85 Cuadro de mensaje Si y No .................................................................... 85 Cuadro de mensaje Aceptar y Cancelar ................................................... 85 Cuadro de mensaje Crítico Aceptar y Cancelar ......................................... 85 Memorias de un sistema de cómputo ...................................................... 88 Archivo de documento de Word .............................................................. 88 Estructura de directorios y archivos ........................................................ 89 Objetos de archivos. .............................................................................. 94 Diálogo Componentes (Control Diálogo Común) ...................................... 95 Tabla “Productos” de una base de datos. ...............................................104 Arquitectura de Bases de Datos .............................................................104 Acceso de Visual Basic a Bases de Datos ................................................105 Modelo de objetos ADO. .......................................................................107

Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura

7.5.7.6.7.7.7.8.7.9.7.10.7.11.7.12.7.13.7.14.7.15.7.16.7.17.7.18.7.19.7.20.7.21.7.22.7.23.8.1.8.2.8.3.8.4.8.5.8.6.8.7.8.8.8.9.8.10.8.11.8.12.8.13.8.14.8.15.8.16.9.1.-

Diálogo de componentes (Control de datos ADO) ...................................115 Ventana de la propiedad ConnectionString .............................................115 Asistente para crear una conexión a un origen de datos ADO ..................116 Diálogo de propiedades para establecer el origen de registros .................116 Ventana de referencias a librerías de objetos .........................................118 Diálogo Componentes (Diseñadores) .....................................................120 Diseñador del objeto Entorno de datos ..................................................121 Diálogo Crystal Report Gallery ...............................................................127 Diálogo de selección de Tablas para reportes .........................................128 Diálogo de selección de Campos para reportes .......................................128 Diálogo para agrupar los registros de un reporte ....................................129 Diálogo para filtrar los registros de un reporte........................................129 Diálogo para seleccionar la plantilla de diseño de un reporte ...................130 Diálogo de confirmación para crear un reporte .......................................130 Vista de diseño de un reporte de Crystal Report .....................................131 Vista preliminar de un reporte de Crystal Report ....................................131 Tipos de campos de Crystal Report ........................................................132 Editor de ecuaciones de Crystal Report ..................................................133 Campos especiales de Crystal Report .....................................................133 Diálogo Insertar objeto .........................................................................138 Diálogo Pegado especial .......................................................................138 Diálogo Componentes (Objetos insertables) ...........................................141 Cuadro de herramientas (Objetos insertables) ........................................141 Ventana de código con eventos de un objeto componente ......................143 Ejemplo del control ActiveX Animation ...................................................146 Ejemplo de control ActiveX CoolBar .......................................................147 Ejemplo del control ActiveX DTPicker .....................................................148 Propiedades del control ActiveX ImageList .............................................149 Ejemplo del control ActiveX TreeView ....................................................150 Ejemplo del control ActiveX ListView Vista Iconos grandes ......................152 Ejemplo del control ActiveX ListView Vista Iconos pequeños....................152 Ejemplo del control ActiveX ListView Vista Lista ......................................152 Ejemplo del control ActiveX ListView Vista Reporte .................................153 Ejemplo del control ActiveX ToolBar.......................................................154 Ejemplo del control ActiveX TabStrip .....................................................155 Visor de texto API ................................................................................159

Índice de tablas Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla Tabla

1.1.3.1.3.2.3.3.3.4.3.5.3.6.3.7.3.8.3.9.4.1.4.2.4.3.4.4.4.5.5.1.5.2.5.3.5.4.5.5.5.6.5.7.5.8.5.9.5.10.5.11.6.1.6.2.6.3.6.4.7.1.7.2.7.3.7.4.7.5.7.6.7.7.7.8.7.9.7.10.7.11.7.12.7.13.8.1.8.2.8.3.8.4.8.5.9.1.-

Lista de prefijos de objetos de Visual Basic. ............................................ 17 Propiedades más importantes del formulario. .......................................... 38 Métodos más importantes del formulario ................................................. 38 Eventos más importantes del formulario. ................................................ 39 Algunas propiedades de la etiqueta. ....................................................... 39 Algunas propiedades del botón de comando............................................ 40 Algunas propiedades de la caja de texto. ................................................ 41 Propiedades más importantes de listas. .................................................. 45 Métodos más importantes de las cajas de lista ........................................ 45 Propiedades más importantes de la barra de desplazamiento. .................. 46 Tipos de datos provistos por Visual Basic. ............................................... 51 Operadores aritméticos de Visual Basic ................................................... 57 Resultados de operaciones lógicas. ......................................................... 58 Operadores relacionales de Visual Basic. ................................................. 58 Precedencia de operadores .................................................................... 59 Constantes de formato para números ..................................................... 76 Símbolos especiales de formato para números ........................................ 76 Constantes de formato para fechas y horas ............................................. 76 Símbolos para crear formatos de fecha y hora ......................................... 77 Juego de caracteres ASCII de 0 a 127 .................................................... 78 Funciones matemáticas .......................................................................... 78 Funciones de ajuste numérico ................................................................ 78 Valores del parámetro Intervalo de funciones de fecha y hora .................. 80 Funciones que devuelven parte de una fecha .......................................... 81 Estilos de cajas de mensajes MsgBox ...................................................... 84 Valores devueltos por MsgBox ................................................................ 86 Especificaciones del parámetro “Tipo” de la instrucción Open ................... 90 Propiedades del objeto Diálogo Común ................................................... 95 Valores de la propiedad Flags. ................................................................ 96 Métodos del objeto Diálogo Común......................................................... 96 Propiedades del objeto Connection de ADO ............................................109 Opciones de la propiedad CursorLocation. ..............................................109 Métodos del objeto Connection de ADO .................................................109 Propiedades del objeto Recordset de ADO..............................................110 Opciones de la propiedad CursorType ....................................................110 Opciones de la propiedad LockType .......................................................111 Valores que devuelve la propiedad EditMode ..........................................111 Métodos del objeto Recordset de ADO ...................................................112 Eventos del objeto Recordset de ADO ....................................................112 Algunos comandos de SQL ....................................................................123 Algunas cláusulas de SQL......................................................................124 Operadores de comparación SQL ...........................................................124 Funciones de agregado SQL ..................................................................124 Propiedades del control contenedor OLE ................................................139 Métodos del control contenedor OLE ......................................................139 Archivos de controles ActiveX ................................................................146 Constantes del argumento relationship ..................................................151 Estilos del objeto Button de ToolBar ......................................................155 Archivos contenedores de funciones API ................................................157

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

Unidad 1 Introducción a Visual Basic “La manera de lograr las cosas es empezándolas” . – Horace Greeley

1.1. Nociones básicas 1.1.1. Historia Los lenguajes de programación han surgido como consecuencia de la necesidad de hacer que los sistemas de cálculo y almacenamiento electrónicos sean útiles al hombre. De esta manera han marchado Hardware y Software, hardware requiriendo software y software requiriendo hardware. El primer sistema electrónico de cálculo data de 1946 y se llamaba ENIAC, un sistema que efectuaba ciertas operaciones, ocupaba el tamaño de una habitación y utilizaba 18.000 válvulas de vacío. Al año siguiente, 1947, Laboratorios Bell crea el transistor, tres capas de silicio polarizadas; y luego Texas Instrument en 1959 logra aumentar el nivel de densidad de capas para obtener el primer circuito integrado de seis transistores. El circuito integrado es el corazón de los sistemas de cálculo moderno y los más recientes albergan a casi 1,5 millones de transistores. Los primeros lenguajes de programación, como el lenguaje máquina y ensamblador, requerían que el programador fuera experto y conociera fielmente el hardware. Es así como comienzan a aparecer los lenguajes de programación de alto nivel, tales como COBOL, ADA, FORTRAN y BASIC. La versión original del lenguaje Basic fue creada en 1964 por John G. Kemeny (Budapest, 1926 – USA 1992) y Thomas E. Kurtz (Illinois 1928), y estaba dirigido fundamentalmente a principiantes, es decir, para todo aquel que se iniciara como programador; de ahí su nombre BASIC o “Código de Instrucción Simbólico para todo Propósito de principiantes (Beginner’s All purpose Symbolic Instruction Code), aunque su nombre original fue True BASIC. Para 1978, cuando los microprocesadores comienzan a hacerse populares y surgen los primeros PC (computadores personales), el lenguaje Basic se establece como un estándar y se crea la normativa BASIC STANDAR. La tecnología continuó su avance, y con ella los requerimientos de software más veloces y eficientes. En el año de 1983 aparece el procesador 80286 y los conceptos de programación estructurada y compilación del código fuente; y Basic comienza a ser despreciado, pues era visto para novatos, su característica de lenguaje secuencial era ineficiente, carecía de herramientas de compilación confiables, no disponía de librerías y era imposible intercambiar información y acceder al interior de las máquinas con él; mientras tanto se hacían muy populares los lenguajes C y 12

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

PASCAL. Basic debía evolucionar y la IBM crea una versión modificada de Basic llamaba BASICA, la cual fracasó. Paralelamente, la empresa Microsoft saca al mercado la versión estructurada de Basic denominada GWBASIC para DOS. Posteriormente otra empresa, Borland, crea su propia versión de Basic estructurado, pero agrega mejoras de velocidad optimizando la compilación en su producto TURBO BASIC. Microsoft compite con Borland optimizando también la compilación y corrigiendo casi todos los defectos de las versiones anteriores, para finalmente obtener Quick-BASIC. Las últimas versiones del sistema operativo MSDOS incluían una versión algo recortada de Quick-BASIC llamada QBASIC. En 1985 aparece Windows, la Interfaz de Usuario Gráfica (GUI) de Microsoft para su sistema operativo MS-DOS; y comienzan a aparecer conceptos tales como multitarea, multiprocesamiento y objetos de programación. El programa Windows permitía administrar casi la totalidad de servicios de usuario del sistema con procesadores de texto, hojas de cálculo, programas de dibujo y diseño, antivirus y hasta una calculadora. Era necesario crear aplicaciones que se ejecutaran utilizando esta GUI. Es así como los diseñadores de Microsoft combinan, convenientemente, la interfaz gráfica con su lenguaje de programación por excelencia, QBASIC; obteniéndose una de las primeras versiones visuales de lenguajes de programación, la cual recibió el nombre Visual Basic. Desde que apareció Visual Basic, ya Basic no es sólo para novatos, sino que representa una alternativa para programadores de todos los niveles, quienes estimulados por su gran versatilidad y potencia, comienzan a utilizarlo. Para los años de 1993 y 1994, Visual Basic comienza a hacerse muy popular con su versión 3.0 de 16 bits. La versión 4.0 estuvo lista para 1995, casi paralelo con la aparición del primer sistema operativo de Microsoft con ambiente gráfico: Windows 95. Este era el momento de transición de los buses de datos de los microprocesadores de 16 a 32 bits; hecho determinante para que Visual Basic 4.0 estuviera disponible para ambos buses de datos, por lo que la instalación era opcional para 16 ó 32 bits. No tardó mucho en evolucionar un poco más con su versión 5.0 exclusivamente para 32 bits. A mediados de 1998, Visual Basic adopta su versión 6.0, la cual viene como parte de un paquete de lenguajes de programación visual para desarrollar aplicaciones Windows llamado Visual Studio 6.0, el cual incluye: Visual C++ 6.0, Visual FoxPro 6.0, Visual J++ 6.0, Visual InterDev 6.0 y Visual Basic 6.0. A partir del año 2000 surge la plataforma de Microsoft para servicios Web (o cualquier servicio basado en red) conocida como framework.NET, la cual incluye las herramientas para el desarrollo de aplicaciones Visual Studio .NET, entre ellas se encuentra Visual Basic .NET. True BASIC

Visual Basic .NET

BASIC STANDAR

Visual Basic 6.0

GWBASIC

Visual Basic 5.0

Quick BASIC

Visual Basic 4.0

QBasic

Visual Basic 3.0 Figura 1.1.- Evolución del Basic.

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

1.1.2. Concepto de Visual Basic Visual Basic es un sistema de desarrollo o lenguaje de programación visual destinado a crear aplicaciones para el entorno Windows de una manera rápida y sencilla combinando herramientas de diseño gráfico y un lenguaje de programación de alto nivel. El término Visual involucra las herramientas gráficas (GUI) y Basic es el lenguaje de programación, lo que le confiere a Visual Basic la característica de potencia gráfica y sencillez. El código intrínseco de los objetos básicos (ventanas y controles) está prediseñado, por lo que no se considera a Visual Basic como un lenguaje de Programación Orientado a Objeto (OOP), ya que carece de los mecanismos de herencia y polimorfismo; más bien se considera basado en objetos, aunque en cierta forma, de las características de la OOP, Visual Basic conserva algo de Polimorfismo y Encapsulación que veremos mas adelante en el capítulo Teoría de Objetos. 1.1.3. Ventajas a) Objetos prediseñados Visual Basic permite utilizar objetos planos y 3D (ventanas, botones, cajas de texto, etc.) sin necesidad de crearlos, ya que provee una interfaz gráfica muy completa y amigable. b) MDI (Multiple Document Interface) Esta opción, en contraste con SDI (Single Document Interface), permite crear una ventana con múltiples ventanas hijas o documentos dependientes. Aplica tanto para el entorno de desarrollo como para las aplicaciones. Para el entorno de desarrollo se habilita o deshabilita en el menú “Herramientas | Opciones”, pestaña “Avanzado”. c) DDE (Dynamic Data Exchange) Es un protocolo establecido para intercambiar datos a través de vínculos activos entre aplicaciones que se ejecutan bajo Microsoft Windows. Por ejemplo, es posible, desde Visual Basic, leer las celdas de una hoja de calculo de Excel. d) DLL (Dynamic Link Libraries) Las bibliotecas de vínculos dinámicos son archivos con extensión DLL que contienen rutinas desarrolladas en otros lenguajes como C y FORTRAN, y que pueden ser accedidas o llamadas desde Visual Basic. El entorno Windows utiliza estas rutinas para mostrar ventanas y gráficos, administrar la memoria, controlar puertos, etc. Múltiples aplicaciones pueden acceder a una misma DLL simultáneamente. La ventaja radica en que se pueden usar las funciones predefinidas de Windows en tiempo de ejecución de la aplicación, en lugar de vincular estáticamente en tiempo de diseño o de compilación. e) OLE (Object Linking  Embedding) Se define como una tecnología que permite a las aplicaciones compartir objetos de una forma coherente con otras aplicaciones, herramientas de programación y lenguajes de macros. OLE forma parte de toda una filosofía de interoperabilidad entre objetos conocida como ActiveX. Resulta ventajoso usar una aplicación tratada como objeto de la aplicación desarrollada en Visual Basic, ya que la aplicación objeto conserva sus propiedades y métodos, y no es necesario escribir código adicional. Por ejemplo, se puede agregar un 14

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

documento de Excel, como objeto, a una aplicación Visual Basic, para efectuar las operaciones normales de una hoja de cálculo, pudiendo modificar datos de las celdas del documento original si está vinculado, o sólo visualizar y manipular celdas si está incrustado. f)

ADO (ActiveX Data Object) Visual Basic provee tres modelos de objetos para acceso a datos: Objetos de Datos ActiveX (ADO), Objetos de Datos Remotos (RDO) y Objetos de Acceso a Datos (DAO). La tecnología más reciente es ADO, con un modelo de objetos más sencillo (y aún más flexible) que RDO o DAO. Un modelo de objetos de acceso a datos es una colección de objetos que permite la manipulación y definición de bases de datos diversas sin tener que conocer las directivas intrínsecas de cada base de datos. Con esta ventaja se puede controlar en forma gráfica o codificada la conexión, los generadores de instrucciones y los datos devueltos de bases de datos, que se usarán en cualquier aplicación de Visual Basic.

g) Otras ventajas Compilador de archivos de ayuda para añadir ayuda personalizada a las aplicaciones, biblioteca de iconos e imágenes, asistente de empaquetado y distribución para crear los discos de la aplicación terminada, ayuda completa en línea, y un editor de código con menús emergentes e interpretador del código. 1.1.4. Requerimientos Los requerimientos de instalación que aquí se tratan se refieren a la versión de Visual Basic 6.0. Para versiones anteriores refiérase a los manuales correspondientes. a) Requerimientos de software:  Sistema operativo de red: Microsoft Windows NT 3.51 o posterior.  Sistema operativo cliente: Microsoft Windows 95 o posterior. b) Requerimientos de hardware:  Microprocesador: Pentium® 90MHz o superior.  Vídeo: Pantalla VGA de 640x480 o de resolución superior.  Memoria RAM: 24 MB para Windows 95, 32 MB para Windows NT.  Espacio en disco duro Edición Estándar: de 48MB a 80 MB.  Espacio en disco duro Edición Empresarial: de 128MB a 147 MB.  Espacio en disco duro para MSDN (Documentación multimedia): 67MB.  CD-ROM (no se supone soporte para MS-DOS). 1.1.5. Compilación La compilación es el proceso mediante el cual cualquier lenguaje de programación convierte su seudo lenguaje al código máquina o código binario para su procesamiento y ejecución según el sistema operativo instalado. Se dice que el código máquina (unos y ceros) es el lenguaje de mas bajo nivel, ya que posee las directivas que interactúan directamente e internamente con el microprocesador.

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

1.1.6. Modos de operación La aplicación Visual Basic puede trabajar en dos modos distintos: Modo de Diseño y Modo de Ejecución. A menudo se dice que cuando se trabaja en modo de diseño o ejecución se esta en Tiempo de Diseño o en Tiempo de Ejecución. En modo de diseño el usuario construye interactivamente la aplicación colocando controles en el formulario, definiendo sus propiedades, y desarrollando funciones para gestionar los eventos. En modo de ejecución el programador prueba la aplicación. En este caso la aplicación se compila, se carga en memoria RAM para producir las directivas necesarias al microprocesador, así el usuario actúa sobre el programa y prueba como responde este. 1.1.7. Reglas de Visual Basic Las reglas o convenciones de Visual Basic para codificación y configuración son pautas que no están enfocadas a la lógica del programa, sino a su estructura y apariencia física. ¿Por qué existen las convenciones de codificación? La razón principal de usar un conjunto coherente de convenciones de codificación es estandarizar la estructura y el estilo de codificación de una aplicación de forma que el autor y otras personas puedan leer y entender el código fácilmente. Las convenciones de codificación correctas dan como resultado un código fuente preciso, legible y sin ambigüedad, que es coherente con otras convenciones del lenguaje y lo más intuitivo posible. Un conjunto de convenciones de codificación de propósito general debe definir los requisitos mínimos necesarios para conseguir los objetivos explicados anteriormente, dejando libertad al programador para crear la lógica y el flujo funcional del programa. El objetivo es hacer que el programa sea fácil de leer y de entender sin obstruir la creatividad natural del programador con imposiciones excesivas y restricciones arbitrarias. Por tanto, las convenciones sugeridas serán breves y sugerentes; no muestran todos los objetos y controles posibles, ni especifican todos los tipos de comentarios informativos que podrían ser útiles. Las convenciones de codificación pueden incluir los siguientes puntos. a) Convenciones de nombres para objetos, variables y procedimientos El cuerpo de un nombre de variable, constante, procedimiento, función u objeto se debe escribir en mayúsculas y/o minúsculas según el caso, y debe tener la longitud necesaria para describir su funcionalidad. Hay que utilizar nombres mnemónicos; es decir, el nombre debe reflejar correctamente la función del elemento que identifica. Además, los nombres de funciones deben empezar con un verbo, como IniciarNombreMatriz o CerrarDiálogo. Para nombres que se usen con frecuencia o para términos largos, se recomienda usar abreviaturas estándar para que los nombres tengan una longitud razonable. Cuando se usen abreviaturas, hay que asegurarse de que sean coherentes en toda la aplicación. Por otra parte, debe cuidar que todas las variables sean declaradas explícitamente. Mediante la instrucción Option Explicit detectará las variables no declaradas durante la compilación. Los archivos generados por Visual Basic se deben guardar con el mismo nombre usado para identificarlo a nivel de objeto. Esta práctica resulta muy útil a la hora de transportar el código fuente de una máquina a otra, pues el programador conoce exactamente los archivos a copiar. 16

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

b) Comentarios para documentar el código Todos los procedimientos, funciones y variables deben poseer un comentario breve que describa las características funcionales de los mismos (qué hace). Esta descripción no debe describir los detalles de implementación (cómo lo hace), porque cambian con el tiempo y pueden resultar en comentarios erróneos. Los argumentos que se pasan a un procedimiento se deben describir cuando sus funciones no sean obvias o cuando se espera que los argumentos estén en un intervalo específico. También hay que describir, al principio de cada procedimiento, los valores devueltos de funciones y las variables globales que se modifican en el procedimiento. No debe exagerar en los comentarios. Los comentarios de líneas se inician con el símbolo apóstrofe (‘). El texto que coloque a la derecha de apóstrofe no será considerado por Visual Basic al momento de la compilación. c) Formatos estandarizados para etiquetar Los nombres de los objetos deben llevar un prefijo de tres letras en minúsculas coherente que facilite la identificación del tipo de objeto rápidamente (ver Tabla 1.1). Tipo de control Barra de desplazamiento horizontal Barra de desplazamiento vertical Barra de estado Barra de herramientas Barra de progreso Botón animado Botón de opción Botones de comando Casilla de verificación Comunicaciones Contenedor OLE Cronómetro o temporizador Cuadrícula o grid Cuadrícula de datos Cuadro combinado de datos Cuadro combinado Cuadro de imagen Cuadro de lista Cuadro de lista de archivos Cuadro de lista de directorios Cuadro de lista de unidades Cuadro de texto Datos Control de Datos ADO Diálogo común Etiqueta Fichas Forma o figura Formulario Imagen Información del sistema Línea Marco Menú

Prefijo hsb vsb sta tlb prg ani opt cmd chk com ole tmr grd dgd dbc cbo pic lst fil dir drv txt dat ado dlg lbl tab shp frm img sys lin fra mnu

Ejemplo hsbVolumen vsbIndice staFechaHora tlbAcciones prgCargarArchivo aniBuzon optGenero cmdSalir chkSoloLectura comFax oleHojaCalculo tmrAlarma grdPrecios dgdTitulos dbcAutor cboIngles picVGA lstCodigos filOrigen dirSource drvDestino txtApellido datBiblio adoBiblio dlgAbrirArchivo lblMensajeAyuda tabOpciones shpCirculo frmEntrada imgIcono sysMonitor linVertical fraIdioma mnuAbrirArchivo

Tabla 1.1.- Lista de prefijos de objetos de Visual Basic.

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

d) Instrucciones de espaciado, formato y sangría. Normalmente hay una instrucción por línea; sin embargo, se pueden colocar dos o más instrucciones en una misma línea utilizando dos puntos (:) para separarlas. Para hacer el código más legible, es mejor colocar cada instrucción en una línea. Por otra parte se puede dividir una instrucción larga en varias líneas de código utilizando un espacio en blanco seguido de un guión bajo “_”. Esta técnica puede hacer que sea más fácil leer el código, tanto en la pantalla como impreso en papel. No se puede poner un comentario después de partir una instrucción. La mayoría de los números utilizados son decimales (base 10). En ocasiones es conveniente o necesario usar números hexadecimales (base 16) u octales (base 8). Con el prefijo &H delante de un número se especifica que el número es hexadecimal. Para especificar que un número es octal, este se debe preceder con &O. Por ejemplo: &H10 y &O20 equivalen a 16 en decimal. Los bloques anidados, deben llevar una sangría de cuatro espacios o un espacio de tabulador cada vez que se efectúe anidamiento. El comentario del esquema funcional de un procedimiento debe llevar una sangría de un espacio. 1.2. Teoría de Objetos 1.2.1. Clase La Clase es un patrón (horma, molde, plantilla) que define las características de un objeto y describe qué apariencia y comportamiento debe tener el objeto. La clase define las propiedades del objeto y los métodos utilizados para controlar el comportamiento del objeto. Podríamos decir que existe la clase mamíferos, la clase estudiantes o la clase profesor. Como ejemplos de Visual Basic se tiene la clase Form, la clase CommandButton, la clase PictureBox o la clase TextBox. 1.2.2. Objeto Cuando crea una aplicación en Visual Basic trabaja con objetos. Puede usar los objetos que proporciona Visual Basic como controles, formularios y objetos de acceso a datos. También puede controlar objetos de otras aplicaciones desde su aplicación de Visual Basic. Puede incluso crear sus propios objetos y definir propiedades y métodos adicionales para ellos. El objeto se define como la instancia de una clase que combina datos (propiedades) y procedimientos (métodos) que pueden ser tratados como una unidad, por ejemplo un control, formulario, o aplicación. Cada objeto está definido por una clase. Para comprender la relación entre un objeto y su clase, piense en el molde de las galletas y las galletas. El molde es la clase que define las características de cada galleta, como por ejemplo el tamaño y la forma. Se utiliza la clase para crear objetos. Los objetos son las galletas. En el caso de Visual Basic los controles del cuadro de herramientas representan clases. El objeto conocido como control no existe hasta que se coloca en un formulario. Cuando crea un control, está creando una copia o instancia de la clase del control. Se crean todos los objetos como copias idénticas de sus clases. Una vez que existen como objetos individuales, es posible modificar sus propiedades. Por ejemplo, si coloca dos botones de comando en un formulario, cada objeto botón de comando es una instancia de la clase CommandButton. Cada objeto comparte un conjunto de 18

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

características y capacidades comunes (propiedades, métodos y eventos), definidos por su clase. Sin embargo, cada uno tiene su propio nombre, se puede activar y desactivar por separado, se puede colocar en una ubicación distinta del formulario, etc. Son objetos distintos con distinto valor para la propiedad Name. Por ejemplo los botones de comando Command1, Command2, Command3 y Command4 comparten (provienen de) la misma clase, CommandButton. 1.2.3.

Propiedades

En Visual Basic, los datos de un objeto (características, datos o atributos) se llaman propiedades. Puede cambiar las características de un objeto si modifica sus propiedades. Piense en la clase “Automóvil”, y en el objeto “MiCarro” como instancia de la clase Automóvil. Una propiedad de MiCarro es su Velocidad. En Visual Basic, se diría que MiCarro tiene la propiedad Velocidad, la cual se puede graduar modificando su valor. Suponga que el rango de velocidad de MiCarro es de 0 a 140 Km/h, y desea establecerlo a 20. En Visual Basic se escribiría mediante la siguiente sintaxis: MiCarro.Velocidad = 20 En el ejemplo anterior se estableció el valor de una propiedad. Las propiedades también pueden devolver sus valores de la siguiente manera: Tacómetro = MiCarro.Velocidad En los ejemplos anteriores y en adelante el signo igual “=” se lee como “se le asigna”. Este signo se usa en BASIC para asignar el valor de la parte izquierda a la parte derecha del signo. De esta manera, el primer ejemplo se lee “Propiedad Velocidad de MiCarro se le asigna 20”. Se pueden establecer casi todas las propiedades en tiempo de diseño usando una ventana del IDE de Visual Basic conocida como Propiedades sin tener que escribir código alguno. Otras propiedades no están disponibles en tiempo de diseño, ya que no aparecen en la ventana de propiedades, por lo que se necesitará escribir código para establecer u obtener esas propiedades en tiempo de ejecución. Por otra parte, es posible que durante la ejecución del programa ciertas propiedades no puedan ser modificadas, mientras que otras sí. En este sentido se tienen los siguientes tipos de propiedades: a) Propiedades de lectura y escritura Las propiedades cuyo valor se puede establecer y obtener en tiempo de ejecución se llaman propiedades de lectura y escritura. b) Propiedades de sólo lectura Las propiedades que sólo se pueden leer (obtener su valor), pero que no se pueden cambiar (establecer) en tiempo de ejecución se conocen como propiedades de sólo lectura. Estas propiedades sólo se pueden cambiar en tiempo de diseño. Por ejemplo, la propiedad Velocidad de MiCarro es de lectura y escritura, ya que puede ser leída y establecida en tiempo de ejecución (auto andando); pero la propiedad “NivelDeGasolina” de MiCarro es de sólo lectura, ya que no se puede cambiar en tiempo de ejecución (auto andando), y se debe detener la aplicación 19

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

para que en tiempo de diseño (auto detenido) se reabastezca el nivel de combustible. En general, para cambiar (establecer) el valor de la propiedad de un objeto en tiempo de ejecución, se utiliza la sintaxis siguiente: NombreDeObjeto.Propiedad = Valor También para leer (obtener) el valor de la propiedad de un objeto en tiempo de ejecución se utiliza la sintaxis siguiente: Variable = NombreDeObjeto.Propiedad Sugerencia: Si va a usar el valor de una propiedad más de una vez, el código se ejecutará más rápidamente si almacena el valor en una variable.

1.2.4.

Métodos

Corresponden a los diversos procedimientos que pueden operar sobre el objeto. Los métodos son parte de los objetos del mismo modo que las propiedades. Generalmente, los métodos son acciones que desea o está posibilitado a realizar el objeto, mientras que las propiedades son los atributos que puede establecer o recuperar. Se podría decir que MiCarro tiene un método "Acelerar" y podría usar la siguiente sintaxis para cambiar la velocidad: MiCarro.Acelerar 20 Los métodos pueden afectar a los valores de las propiedades e inclusive activar procedimientos de evento que veremos mas adelante. En el ejemplo de MiCarro, el método Acelerar cambia la propiedad Velocidad. Cuando utiliza un método en el código, la sintaxis depende de los argumentos que necesite el método y de si el método devuelve o no un valor. En general se utiliza la sintaxis siguiente: NombreDeObjeto.Método [Arg1, Arg2,...] De ahora en adelante, en las sintaxis generales, los elementos que aparezcan entre corchetes [ ] son opcionales de la sintaxis. En este caso Arg1, Arg2,… son opcionales, de tal manera que si el método no requiere argumentos, la sintaxis sería: NombreDeObjeto.Método Si el método devuelve un valor útil, debe asignar el valor a una variable y utilizar paréntesis con o sin argumentos como se muestra a continuación: Variable = NombreDeObjeto.Método([Arg1, Arg2,...]) 1.2.5.

Evento

Un evento es una acción reconocida por un objeto, como cuando el usuario hace clic con el Mouse o presiona una tecla. Los eventos no sólo son producidos por el usuario, también pueden ser ocasionados por el sistema, por aplicaciones externas, e inclusive por la misma aplicación. Por ejemplo, MiCarro podría tener los eventos "CambioDeVelocidad”, “Estacionarse”, Encendido”, “GiroIzquierdo”, etc. La sintaxis para alguno de estos eventos de MiCarro sería: MiCarro_CambioDeVelocidad 20

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

MiCarro_Encendido MiCarro_Estacionarse En Visual Basic la sintaxis general para el evento de un objeto es: NombreDeObjeto_NombreDeEvento 1.2.6.

Procedimientos de evento

Un procedimiento de evento es una sección de código que se ejecuta cuando se produce el evento sobre un objeto determinado. Las aplicaciones controladas por eventos ejecutan código Basic como respuesta a un evento. Cada objeto de Visual Basic tiene un conjunto de eventos predefinidos. Si se produce uno de esos eventos, y su procedimiento de evento tiene código asociado, Visual Basic ejecuta ese código. A cada evento le corresponde una sección de código que es lo que se conoce como un procedimiento de evento. Cuando se desea que un control responda a un evento, se escribe código en el procedimiento de ese evento. El objeto MiCarro tiene un código en el procedimiento de evento CambioDeVelocidad, el cual define los pasos para mostrar la velocidad actual en el tacómetro, por ejemplo; y su estructura sería: Private Sub MiCarro_CambioDeVelocidad() {Área de código para mostrar velocidad} End Sub De modo que un procedimiento de evento en Visual Basic, es de la forma: Private Sub NombreDeObjeto_NombreDeEvento() {Área de código} End Sub Distintos tipos de eventos pueden ser reconocidos por un mismo objeto; por ejemplo, el objeto Form es susceptible al evento Click, y también al evento DblClick. El código de respuesta a los eventos, en cada caso, será como sigue: Private Sub Form_Click() {Área de código para un clic sobre el Form} End Sub Private Sub Form_DblClick() {Área de código para un doble clic sobre el Form} End Sub Por otra parte, distintos tipos de objetos pueden ser susceptibles a un mismo evento. Por ejemplo, la mayoría de los objetos reconocen el evento Click. Si el usuario hace clic sobre el cuerpo del formulario, o sobre el área de un botón de comando, se ejecutan códigos diferentes: Private Sub Form_Click() {Área de código para un clic sobre el formulario} End Sub Private Sub cmdBotón_Click() {Área de código para un clic sobre el botón} End Sub 21

Visual Basic 6.0

Unidad 1.- Introducción a Visual Basic

1.2.7. Encapsulación Esta característica de la OOP es la facultad de unificar el código y los datos que la clase u objeto contiene, así como ocultar el código que maneja dicha información. La encapsulación nos ayuda a olvidarnos de cual es la implementación realizada en los procedimientos y datos (métodos y propiedades) de una clase, para que sólo nos preocupemos de cómo usarlos. La encapsulación es la característica que permite ocultar cómo están codificados los métodos y propiedades de las clases. El mero hecho de crear un método o una propiedad en una clase ya implica que estamos usando la característica de la encapsulación en Visual Basic. 1.2.8. Polimorfismo Muchas clases pueden proporcionar la misma propiedad o el mismo método y el que llama no tiene por qué saber la clase a la que pertenece el objeto antes de llamar a la propiedad o al método. Por ejemplo, una clase Automóvil y una clase Avión podrían tener la misma propiedad Velocidad o el mismo método Acelerar. El polimorfismo significa que puede establecer la Velocidad o invocar Acelerar sin saber si el objeto es MiCarro o MiAvión. Todos los métodos implementados en las clases deben tener una forma única de comportarse, y las propiedades de las clases deben ser consistentes con la información que corresponde tratar. El polimorfismo sería el contrato firmado para que esos procedimientos y datos se utilicen de forma adecuada. Se dice que una clase es polimórfica cuando podemos usar sus métodos y propiedades sin importarnos qué objeto los implementa. El Polimorfismo en Visual Basic se puede usar de dos formas diferentes, según se compruebe si el miembro de una clase (propiedad o método) pertenece al objeto que lo utiliza, en tiempo de diseño o en tiempo de ejecución.

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

Unidad 2 Trabajar con Visual Basic “Cualquier obra grande al principio es imposible” . - Carlyle

2.1. Estructura de proyecto 2.1.1. Proyecto El proyecto se define como el grupo archivos asociados necesarios para desarrollar una aplicación o componente software. En el caso de Visual Basic, el proyecto es un archivo de texto con extensión .vbp (Visual Basic Project) que contiene información sobre los archivos que componen la aplicación. Específicamente, podríamos decir que el proyecto es la aplicación en sí, pero en tiempo de diseño en el argot de Visual Basic. Los proyectos están conformados por Módulos, dentro de cada uno de los cuales se encuentran Declaraciones y Procedimientos. 2.1.2. Módulos El código en Visual Basic se almacena en módulos. Hay tres tipos de módulos: de formulario, estándar y de clase. Los módulos estándar y de clase carecen de representación gráfica, mientras que los módulos de formulario poseen la representación gráfica correspondiente a la interfaz de usuario. Un proyecto puede contener varios módulos de distintos tipos y cada uno se guarda en archivos por separado; lo que permite crear código reutilizable por otros proyectos. Cada módulo estándar, de clase y de formulario posee una sección de Declaraciones y un conjunto de Procedimientos que veremos más adelante. a) Módulos de formulario Los formularios son las ventanas mediante las cuales los usuarios interactúan con la aplicación. Cada formulario del proyecto tiene asociado un archivo con extensión .frm, el cual contiene las definiciones de objeto y su código. b) Módulos estándar Los módulos estándar son archivos de texto que almacenan código fuente dividido en procedimientos, a los que pueden tener acceso otros módulos de la aplicación. Su implementación es obligatoria en el caso de incluir variables globales al proyecto. La extensión de estos archivos es .bas. c) Módulos de clase Los módulos de clase (archivo de extensión .cls) son la base para la creación de objetos en Visual Basic. Puede escribir código en módulos de clase para ensamblar nuevos objetos. Estos objetos nuevos pueden incluir propiedades y métodos personalizados. 23

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

2.1.3. Procedimientos Cada módulo se divide en procedimientos. Los procedimientos son estructuras que delimitan un conjunto de instrucciones. Los procedimientos pueden tener alcance público o privado. Los procedimientos privados sólo se pueden acceder desde el módulo en el cual están creados, mientras que los procedimientos públicos se pueden acceder desde cualquier módulo del proyecto. También los procedimientos existen en tres tipos: Sub, Function, y Property que se estudiarán en detalle en la unidad 4; por lo pronto sólo es necesario conocer su estructura, la cual según el alcance y el tipo se pueden ver de la siguiente manera: Private Sub NombreDeProcedimientoSub() {Código de instrucciones} End Sub Private Function NombreDeProcedimientoFunction() {Código de instrucciones} End Function Los procedimientos se inician con la sentencia Sub y termina con End Sub. De esta misma manera las funciones comienzan con la sentencia Function y terminan con End Function. En general, todas las estructuras de Visual Basic se inician con NombreDeEstructuta y terminan con End NombreDeEstructura. No está permitido escribir código que no sea dentro de la estructura de procedimientos. 2.1.4. Declaraciones Independientemente del tipo de módulo, todos poseen un área especial fuera de la estructura de los procedimientos al inicio del módulo conocida como Sección de Declaraciones. En esta sección del módulo no se pueden escribir instrucciones, sólo declaraciones. Las declaraciones consisten en especificar localidades de memoria o funciones externas (API) mediante un nombre o identificador. En la figura 2.1 se puede apreciar una aproximación gráfica de la estructura completa de un proyecto, con dos módulos de formulario, un formulario estándar y la estructura interna de cada módulo en declaraciones y procedimientos. Proyecto.vbp Formulario1.frm

Formulario2.frm

Módulo.bas

‘Declaraciones

Private Sub

Public Sub

Private Sub

End Sub Private Function

End Sub Private Sub

End Sub Public Function

End Function Private Sub

End Sub Private Sub

End Function Public Sub

End Sub

Figura 2.1.- Estructura de un proyecto

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

2.2. IDE de Visual Basic 2.2.1. Entorno de Desarrollo Integrado (IDE) El área de trabajo que interactúa con el usuario en cualquier programa se conoce como Entorno de Desarrollo Integrado o IDE (Integrated Development Environment). El entorno de trabajo de Visual Basic integra funciones de diseño, edición, compilación y depuración de proyectos mediante el uso de una interfaz gráfica compuesta por ventanas, cuadros de diálogo y herramientas. Todas las ventanas de Visual Basic se pueden acceder desde el menú Ver. Muchas de las ventanas del IDE se pueden acoplar o conectar a otra o al borde de la pantalla, esto con el objeto de organizar el entorno y mejorar la visualización de las herramientas. Para activar o desactivar el acople de una ventana se debe mostrar el menú emergente de la ventana (clic derecho sobre la ventana). El entorno permite MDI (Interfaz de Múltiples Documentos) para manipular varios proyectos al mismo tiempo. Las funciones integradas son: a) DISEÑO b) EDICIÓN c) COMPILACIÓN d) DEPURACIÓN 2.2.2. Ventana Explorador de Proyecto La ventana explorador de proyecto muestra todos los módulos que conforman al proyecto permitiendo al programador navegar entre los distintos módulos. En la figura 2.2 se muestran los rasgos más significativos de esta ventana. a) Botón “Ver código”: muestra la ventana de código del módulo seleccionado. b) Botón “Ver objeto”: muestra el diseñador de formulario del formulario seleccionado. c) Botón “Alternar carpetas”: cambia la vista de árbol, agrupando por tipo de módulo. d) Nombre del proyecto y del archivo de proyecto (.vbp) entre paréntesis. e) Nombre de un módulo de formulario y su archivo asociado (.frm) entre paréntesis. f)

Nombre de un módulo estándar y su archivo asociado (.bas) entre paréntesis. a

d e

Figura 2.2.- Ventana Proyecto

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

Para gestionar cada módulo o proyecto individualmente (agregar, quitar, guardar), se hace clic derecho sobre el módulo deseado para desplegar su menú emergente. Este menú emergente también permite elegir el objeto inicial cuando se manipulan varios proyectos en una misma sesión. 2.2.3. Ventana Diseñador de Formularios Esta ventana permite construir la aplicación en forma gráfica mediante el formulario y el dibujo de los objetos dentro del formulario. Los objetos se pueden inmovilizar mediante la opción “Bloquear controles” del menú Formato. El grid o rejilla se puede ocultar y volver a mostrar en el menú “Herramientas | Opciones”, pestaña “General”. A continuación, la figura 2.3 es un ejemplo del Diseñador de Formularios “”

Figura 2.3.- Ventana Diseñador de formulario

2.2.4. Ventana de código La ventana de código es un editor de texto que permite crear, visualizar y modificar todo el código de Visual Basic. Existe una ventana de código por cada módulo, ya sea de formulario, estándar o de clase. Vea en la figura 2.4 las partes de la ventana editora de código para un módulo de formulario llamado frmForm1. a) Lista de Objetos del formulario frmForm1, incluyendo al mismo formulario. b) Lista de eventos provistos por el objeto seleccionado en la Lista de Objetos. c) Sección de declaraciones d) Área de procedimientos

a c

Figura 2.4.- Ventana de código

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

2.2.5. Caja de herramientas Esta ventana contiene las clases de los objetos o controles. Con doble clic se selecciona y se inserta un control en el Centro del formulario activo o con un clic se selecciona el objeto y luego se puede dibujar en el formulario (ver Figura 2.5).

Puntero

Pictute

Label

TextBox

Frame

CommandButton

CheckBox

OptionButton

ComboBox

ListBox

HScrollBar

VScrollBar

Timer

DriveListBox

DirListBox

FileListBox

Shape

Line

Image

Data

OLE

Figura 2.5.- Cuadro de herramientas

2.2.6. Ventana de propiedades Mediante esta ventana es posible ver o establecer las propiedades de los objetos. Cada vez que selecciona un objeto, la ventana de propiedades se actualiza para ese objeto. Las partes de la ventana de propiedades (ver Figura 2.6) son: a) Lista de todos los Objetos. b) Descripci贸n de la propiedad. c) Valor de la propiedad. d) Descripci贸n r谩pida de la propiedad seleccionada.

Figura 2.6.- Ventana de propiedades.

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

2.2.7. Funciones básicas del IDE a) Crear un nuevo proyecto:  Según su configuración, al iniciar Visual Basic aparece automáticamente el cuadro de diálogo “Nuevo proyecto” (ver Figura 2.7), el cual presenta tres pestañas: “Nuevo”, “Existente” y “Recientes”. La pestaña “Nuevo” permite crear un nuevo proyecto. La pestaña “Existente” es para cargar un proyecto guardado. Y la pestaña “Recientes” carga los últimos proyectos abiertos previamente con Visual Basic.

Figura 2.7.- Diálogo Nuevo proyecto al iniciar Visual Basic

 El menú “Archivo | Nuevo proyecto” accede al diálogo de la figura 2.8.

Figura 2.8.- Diálogo Nuevo proyecto estándar

Sugerencia: Seleccione EXE estándar en cualquiera de los casos para aplicaciones sencillas. Mediante el teclado: “CTRL+N” tiene el mismo efecto. 28

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

b) Agregar o quitar módulos de formulario del proyecto:  En el menú “Proyecto | Agregar formulario” aparece el diálogo de la figura 2.9, el cual presenta dos pestañas “Nuevo” y “Existente”. Mediante la pestaña “Existente”, en el proyecto actual se pueden utilizar o importar formularios creados previamente en otros proyectos.

Figura 2.9.- Diálogo Agregar formulario

 Otra forma de acceder al diálogo de la figura 2.9 es mediante el menú emergente de la ventana Explorador de proyectos (ver Figura 2.10). Este menú permite agregar, guardar o remover formularios y módulos.

Figura 2.10.-Menú emergente del explorador de proyecto

Recuerde:

Los menús emergentes de un objeto o ventana se activan haciendo un clic derecho sobre el objeto o ventana. 29

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

c) Agregar o quitar módulos estándar del proyecto:  Haciendo clic en el menú “Proyecto | Agregar módulo” se accede al cuadro de dialogo que se muestra en la figura 2.11 en la que se puede observar, al igual que para agregar formulario, las pestañas “Nuevo” y “Existente”.

Figura 2.11.-Diálogo Agregar módulo

 También puede activar el menú emergente de la ventana Explorador de proyecto, con el fin de agregar módulos estándar. d) Cambiar los modos de operación del proyecto (tiempo de diseño y ejecución):  Utilizando el menú “Ejecutar | Iniciar” o “Ejecutar | Terminar” se puede pasar a tiempo de ejecución o a tiempo de diseño respectivamente.  Mediante la barra de herramientas, haciendo clic en el botón “Iniciar” o en el botón “Terminar” tiempo de diseño. Facilidad:

se puede pasar a tiempo de ejecución o a

Presionar la tecla F5 del teclado es equivalente a Iniciar.

e) Guardar los archivos del proyecto:  Menú “Archivo | Guardar proyecto” o “Archivo | Guardar proyecto como”  Mediante la barra de herramientas, haciendo clic en el botón “Guardar”  Se pueden guardar individualmente cada uno de los módulos mediante el menú “Archivo” o desplegando el menú emergente de la ventana explorador de proyecto (ver Figura 2.10). f)

Configurar el proyecto:  Para acceder a las Propiedades del proyecto (ver Figura 2.12) se usa el menú “Proyecto | Propiedades de NombreProyecto”. La sección “Objeto 30

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

inicial” permite al programador elegir al formulario que se cargará en forma predeterminada al iniciarse la aplicación.

Figura 2.12.-Diálogo Propiedades del proyecto

g) Configurar el entorno: Para configurar el IDE se hace clic en el menú “Herramientas | Opciones” y aparece el diálogo que se muestra en la figura 2.13, en la se pueden apreciar las pestañas Editor, Formato del editor, General, Acople, Entorno y Avanzado.

Figura 2.13.-Diálogo Opciones de editor

 Editor: permite configurar a la ventana de código.  Formato del editor: define el tipo, tamaño y color como se mostrarán las fuentes tipográficas según su uso dentro del código. Esta característica es para facilitar la visualización del código de parte del usuario. 31

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

 General: escoge si mostrar o no la cuadricula, y si forzar o no la posición de los controles a la cuadrícula.  Acople: permite elegir las ventanas del IDE que se podrán acoplar o no.  Entorno: escoge la forma de guardar los cambios, Automática sin preguntar, Preguntar antes de guardar o Guardado manual  Avanzado: establece si el entorno soporta o no MDI. 2.3. Crear una aplicación 2.3.1. Pasos básicos Para crear una aplicación (programa) en Visual Basic o cualquier otro lenguaje de programación visual, existen unos pasos bien definidos, aunque no estrictos, que ayudan o facilitan el proceso de diseño. Se recomienda inicialmente hacer un dibujo de la apariencia que tendrá la interfaz de usuario (el formulario), esto con el fin de ilustrar la ubicación relativa de los objetos que contendrá el formulario. Los pasos básicos son: a) Colocar los objetos b) Establecer las propiedades c) Escribir el código 2.3.2. Colocar los objetos El primer paso consiste en la creación de los objetos estableciendo su ubicación, y tamaño inicial en forma gráfica dentro de un formulario. Cuando se crea un nuevo proyecto, según el punto 2.2.7(a), automáticamente se crea el primer objeto de la aplicación, y este es el formulario, incluyendo su módulo de código. En esta primera parte, el programador debe seleccionar la clase (modelo de objeto) en el cuadro de herramientas y luego dibujar el objeto en su contenedor respectivo. Los contenedores son objetos que agrupan a otros objetos, y el único visto hasta el momento es el formulario.

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

Figura 2.14.-Agregar objetos a un formulario

2.3.3. Establecer las propiedades Una vez que se han colocado los objetos, se procede a establecer o modificar las propiedades de los mismos, tales como: color de fondo (BackColor), valor inicial (Text), rótulo o título (Caption) y la propiedad que nunca se debe dejar de establecer en esta parte, la propiedad Nombre (Name). Las propiedades se cambian en la Ventana de propiedades. No debe escribir código sin establecer la propiedad Nombre previamente, ya que en el paso siguiente de construcción del código, los procedimientos de evento se crean automáticamente y estos incluyen el nombre del objeto seleccionado. Si el programador cambia el nombre del objeto, después de haber escrito el código del mismo, entonces deberá corregir los nombres de todos los procedimientos de evento del objeto.

Figura 2.15.-Modificar las propiedades de objetos

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

2.3.4. Escribir el código Finalmente se procede a escribir el código en la Ventana de código. Tal como vimos en el punto 2.1.3, el código se escribe dentro de un procedimiento; es decir, entre las sentencias Private Sub y End Sub. Ahora la pregunta es ¿En qué procedimiento de evento se debe escribir el código? En los lenguajes de programación visual, a la hora de escribir el código, se deben tener en cuenta dos elementos: el objeto y el evento. Es relevante entender que un objeto puede responder a múltiples eventos, y que un mismo tipo de evento puede afectar a múltiples objetos. Así, el código se divide en procedimientos y cada procedimiento se corresponde con un objeto específico y a un evento específico de este objeto. En este sentido, dividimos este paso en tres tareas básicas. a) Seleccionar el objeto: Se debe analizar cuales de los objetos se han dispuesto para recibir las acciones del usuario, del sistema, o de una aplicación externa. Las aplicaciones orientadas a eventos, cuando se ejecutan, sólo muestran la interfaz y se quedan a la espera de la intervención del usuario (teclado, ratón), del sistema (reloj del PC), o de una aplicación externa (peticiones); es decir, la aplicación espera a que ocurra algo, espera los Eventos; y estos tienen lugar sobre un objeto. En esta primera tarea, el programador debe determinar cuales de sus objetos recibirá esas acciones. En nuestro ejemplo, tenemos tres objetos: el formulario, la caja de texto y el botón de comando. El botón de comando será el que recibirá el evento.

Seleccionar el objeto Command1 Figura 2.16.-Seleccionar objeto para procedimiento de evento

b) Seleccionar el evento: Especificar, para el objeto seleccionado, el evento mediante el cual la aplicación efectuará algún proceso. El editor crea automáticamente el procedimiento de evento. Para nuestro ejemplo escogeremos el evento Click.

Visual Basic 6.0

Unidad 2.- Trabajar con Visual Basic

Seleccionar el evento Click Figura 2.17.-Seleccionar evento para procedimiento de evento

c) Escribir el código: “Rellenar” el procedimiento de evento creado previamente. Se escriben las instrucciones necesarias para que, cuando se produzca el evento sobre el objeto seleccionado, se ejecute el proceso deseado. Objeto seleccionado

Evento seleccionado

Procedimiento de evento

Código Basic

Figura 2.18.-Escribir código en un procedimiento de evento

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

Unidad 3 Objetos de Visual Basic “La manera más segura de no fracasar es decidirse a tener éxito” .- Sheridan.

3.1. El formulario 3.1.1. Formulario (Clase: Form) Un objeto formulario es una ventana o un cuadro de diálogo que forma parte de la interfaz de usuario de una aplicación cuando esta se ejecuta. Los formularios pertenecen a la clase “Form”, a la vez que “Form” también es un objeto. Los formularios son objetos contenedores. Los contenedores son objetos diseñados para albergar o agrupar a otros objetos, de tal manera que si se mueve o se elimina al contenedor, también se mueven o eliminan a los objetos contenidos en él. Para hacer referencia a un objeto contenido dentro de un formulario, se debe especificar el nombre del formulario seguido de un punto y luego el nombre del objeto. NombreForm.NombreObjeto.Propiedad = Valor NombreForm.NombreObjeto.Método [Parámetro1, Parámetro2,…] En el caso que el objeto este contenido en el mismo formulario desde el que se hace referencia, se sustituye el nombre del formulario por la palabra reservada “Me”. La palabra “Me” es equivalente al nombre del formulario en cuyo módulo se escribe el código. En otras palabras, para el ejemplo “Me” reemplaza a “NombreForm”, siempre que la ventana de código pertenezca al formulario llamado “NombreForm”. Me.NombreObjeto.Propiedad = Valor Me.NombreObjeto.Método [Parámetro1, Parámetro2,…] De esta misma manera, para acceder a propiedades y métodos del formulario actual, no es necesario escribir su nombre completo como se muestra a continuación. NombreForm.Propiedad = Valor NombreForm.Método [Parámetro1, Parámetro2,…] En su lugar, se hace referencia al formulario actual la palabra reservada “Me”. Me.Propiedad = Valor Me.Método [Parámetro1, Parámetro2,…]

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

La palabra “Me”, más que sintaxis, es una gran ayuda a la hora de escribir código, ya que al colocar el punto justo después de “Me” se despliegan, no sólo las propiedades y métodos del formulario, sino también los objetos que este contiene (ver Figura 3.1), facilitándose la escritura y verificándose si existe o no el objeto.

Propiedad Método Objeto

Figura 3.1.- Despliegue del operador punto.

Esta funcionalidad es gracias al operador punto del editor de código, y aplica para todos los objetos del sistema, instancias de objetos y estructuras. Observe que se presentan iconos diferentes para distinguir entre propiedades, métodos y objetos. Regla de Visual Basic de prefijo para nombre de objeto Formulario: frm.

3.1.2. Propiedades de formularios A continuación se muestra una tabla con la mayoría de las propiedades de los formularios con su descripción (ver Tabla 3.1), la cual se ha redactado en forma general ya que existen propiedades que pueden aplicar para otros objetos. Propiedad Appearence AutoRedraw BackColor BorderStyle Caption ControlBox DrawStyle DrawWidth Enabled FillColor FillStyle Font ForeColor Height Icon Left MaxButton MinButton MouseIcon MousePointer Moveable Name Picture ScaleHeight ScaleLeft ScaleMode ScaleTop

Descripción Si el objeto es 3D o plano. Si re-dibuja o no los resultados de métodos gráficos. Color de fondo del objeto. Estilo del borde del formulario. Puede ser sin borde, borde fijo, borde ajustable, etc. Título o rótulo del objeto. Para formularios, aparece en la barra de título. Si muestra o no el cuadro de control del formulario. Estilo de línea de los resultados de métodos gráficos. Grueso de línea de los resultados de métodos gráficos. Si permite o no los eventos del ratón. Color de relleno de formas, círculos y cuadros. Estilo de relleno de formas, círculos y cuadros. Nombre y estilo de la fuente tipográfica para el objeto. Color de la fuente tipográfica. Altura del objeto. Según ScaleMode. Imagen del cuadro de control del formulario. Distancia del lado izquierdo del objeto al borde de su contenedor. Según ScaleMode. Si muestra o no el botón maximizar del formulario. Si muestra o no el botón minimizar del formulario. Imagen personal del apuntador de ratón. MousePointer debe establecerse en 99-Custom. Tipo de imagen del apuntado de ratón sobre el objeto. Si se puede mover o no el formulario en tiempo de ejecución. Identificador o nombre del objeto. No acepta espacios ni caracteres especiales. Imagen de fondo. Cualquier archivo gráfico del entorno de Windows. Altura interior del objeto. Según ScaleMode. Coordenada del lado izquierdo interno del objeto. Según ScaleMode. Unidad de medida de las coordenadas. Puede ser Twip, Centímetro, Pulgada, etc. Coordenada del lado superior interno del objeto. Según ScaleMode. 37

Visual Basic 6.0

Propiedad ScaleWidth ShowInTaskBar StarUpPosition Tag Top Visible Width WindowState

Unidad 3.- Objetos de Visual Basic

Descripción Ancho interior del objeto. Según ScaleMode. Si muestra o no la aplicación en la barra de tareas de Windows. Posición inicial del formulario cuando se carga o se ejecuta la aplicación. Información adicional del objeto. Distancia del lado superior del objeto al borde de su contenedor. Según ScaleMode. Si se muestra o no en la pantalla. Ancho del objeto. Según ScaleMode. Modo del formulario “Normal”, “Maximizado” o “Minimizado” Tabla 3.1.- Propiedades más importantes del formulario.

En la figura siguiente se muestra un formulario (ventana) donde se indican sus elementos básicos. Barra de título

Botón minimizar

Botón maximizar

Botón cerrar

Caja de control Barra de menú

Height

Borde

Fondo

Width Figura 3.2.- Elementos básicos de una ventana.

3.1.3. Métodos de formularios Método

Sintaxis

Show

Objeto.Show [Estilo]

Hide

Objeto.Hide

Circle

Objeto.Circle (x , y), r [, Color]

Line

Objeto.Line (x1, y1) - (x2, y2)

Cls

Objeto.Cls

Move

Objeto.Move x, y, Ancho, Alto

PSet

Objeto.Pset (x, y) [,Color]

SetFocus

Objeto.SetFocus

Acción Mostrar un formulario en forma modal si Estilo = 1. De lo contrario es no modal. Ocultar un formulario. El formulario no se descarga de la memoria. Dibujar un círculo sobre el objeto. El centro está en x, y. El radio es r. Dibujar una línea sobre el objeto. La línea va desde x1, y1, hasta x2, y2. Borrar los resultados de métodos gráficos. Métodos como Line y Circle son métodos gráficos. Mover y cambiar tamaño del objeto. Alternativamente dispone las propiedades Top, Left, Height y Width Dibujar un punto sobre el objeto. El tamaño del punto depende del valor de la propiedad DrawWidth. Enfocar al objeto. Los objetos deshabilitados o no visibles, no pueden ser enfocados. Tabla 3.2.- Métodos más importantes del formulario

3.1.4. Eventos de formularios Evento Click DblClick MouseDown MouseUp MouseMove

Ocurre cuando… El usuario presiona y suelta un botón del Mouse (ratón) en un objeto. El usuario presiona y suelta un botón del Mouse (ratón) en un objeto dos veces. El usuario presiona un botón del Mouse (ratón) en un objeto. El usuario suelta un botón del Mouse (ratón) en un objeto. El usuario mueve el puntero del Mouse (ratón) en un objeto. 38

Visual Basic 6.0

Evento KeyDown KeyUp KeyPress DragDrop DragOver Activate Deactivate GotFocus LostFocus Load Unload QueryUnload Paint Resize

Unidad 3.- Objetos de Visual Basic

Ocurre cuando… El usuario presiona una tecla en un objeto que tiene el enfoque. El usuario suelta una tecla en un objeto que tiene el enfoque. El usuario presiona y suelta una tecla en un objeto que tiene el enfoque. El usuario termina una operación de arrastrar y colocar sobre un objeto. El usuario ejecuta una operación de arrastrar y colocar sobre un objeto. Un formulario se convierte en la ventana activa. Un formulario deja de ser la ventana activa. Un objeto recibe el enfoque. Un objeto pierde el enfoque. Un formulario se abre o se carga. Un formulario se cierra o descarga. Un formulario se intenta cerrar o descargar. Un objeto o parte de él se expone si estaba cubierto por otro. Un formulario cambia de tamaño. Tabla 3.3.- Eventos más importantes del formulario.

3.2. Los controles 3.2.1. Etiqueta (Clase: Label) Un control etiqueta es un control gráfico de la clase “Label” que se puede usar para mostrar algún texto o mensaje que el usuario no podrá cambiar directamente. Se puede escribir código para cambiar el texto mostrado por un control Label como respuesta a eventos en tiempo de ejecución, manipulando la propiedad Caption. Por lo general las etiquetas se usan para rotular otros controles. Regla de Visual Basic de prefijo para nombre del objeto Etiqueta: lbl.

Veremos sólo las propiedades, métodos y eventos específicos que no hayan sido tratados anteriormente para cada objeto. a) Propiedades de etiquetas Propiedad Alignment AutoSize BackColor BackStyle BorderStyle Caption DragIcon DragMode ToolTipText WordWrap

Descripción Justificación de texto centrada, derecha o izquierda. Si ajusta o no su tamaño al contenido. Color de fondo. No tiene efecto si la propiedad BackStyle = 0-Transparent Estilo de fondo de etiquetas (Label) y figuras (Shape). Estilo del borde del objeto. Puede ser con o sin borde. Título o rótulo del objeto. Icono que se muestra durante la operación arrastrar y colocar del objeto. Modo de la operación arrastrar y colocar del objeto. Mensaje de la etiqueta de ratón cuando se señaliza al objeto. Si ajusta o no su tamaño en altura al contenido (Caption). Tabla 3.4.- Algunas propiedades de la etiqueta.

Se pueden establecer las propiedades AutoSize y WordWrap en forma combinada si desea que el Label muestre líneas de longitud variable o números variables de líneas. Las etiquetas pueden contener múltiples líneas, para lo cual se debe insertar en la cadena los caracteres de retorno de carro y línea nueva (ASCII 13 y 10), que se pueden implementar mediante la constante vbCrLf. lblLabel.Caption= “Line1” & vbCrLf & “Line2” 39

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

La operación de arrastrar y colocar está disponible para la mayoría de los objetos, siempre y cuando la propiedad DragMode se establezca a 0-Manual. Una vez iniciada una operación de este tipo, la imagen del icono del puntero de Mouse (ratón) cambia según la imagen establecida mediante la propiedad DragIcon. La operación de arrastrar y colocar se inicia mediante el método Drag del objeto en su evento MouseDown. b) Métodos de etiquetas Uno de los métodos más importantes es Drag o arrastrar y colocar, como se le conoce. Se utilizan los siguientes argumentos: 0-Cancelar, 1-Iniciar, y 2Terminar. También es interesante el método Refresh, el cual fuerza al sistema para volver a dibujar un formulario o un control completo. c) Eventos de etiquetas Los eventos más importantes que afectan a una etiqueta son Change, KeyDown y KeyUp. El evento Change ocurre cuando el valor de la propiedad Caption se modifica. Como se explicó anteriormente, los eventos KeyDown y KeyUp son útiles para detectar el inicio y fin de una operación de arrastrar y colocar. 3.2.2. Botón de comando (Clase: CommandButton) Se utiliza un control de la clase CommandButton para comenzar, interrumpir o terminar un proceso, por lo general mediante su evento Click. Regla de Visual Basic de prefijo para nombre del objeto Botón de comando: cmd.

a) Propiedades de botones de comando Propiedad BackColor Cancel Default DisabledPicture DownPicture Picture Style TabIndex TabStop

Descripción Color de fondo. No tiene efecto si la propiedad Style = 0-Estándar. Si ejecuta o no el clic de un Botón presionando ESC. Si ejecuta o no el clic de un Botón presionando ENTER. Imagen cuando se deshabilita el objeto. No tiene efecto si la propiedad Style = 0-Estándar. Imagen cuando se hace clic en el objeto. No tiene efecto si la propiedad Style = 0-Estándar. Imagen de fondo. No tiene efecto si la propiedad Style = 0-Estándar. Estilo gráfico de objetos. Orden para el enfoque mediante la tecla TAB. Si se enfoca o no mediante la tecla TAB. Tabla 3.5.- Algunas propiedades del botón de comando

Los botones de comando pueden contener una imagen mediante la propiedad Picture, siempre que la propiedad Style se establezca a 1-Graphical. Se puede definir el gráfico que muestra el botón en estado deshabilitado, según la propiedad DisabledPicture. También se puede mostrar una imagen determinada por la propiedad DownPicture en el botón de comando cuando se mantiene presionado el botón derecho del Mouse (ratón). TabIndex define el orden de selección de enfoque de los objetos en la medida que se presiona la tecla TAB, y no aplica en el caso de los objetos cuya la propiedad TabStop o Enabled se ha establecido a False (False es equivalente a cero) 40

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

b) Métodos de botones de comando El método más importante es SetFocus. De esta manera se puede enfocar cualquier objeto mediante código, siempre que el objeto incluya este método y esté habilitado. El siguiente ejemplo enfoca al botón de comando “cmdMiBotón”. cmdMiBotón.SetFocus c) Eventos de botones de comando Los eventos más importantes son Click y MouseMove. Se puede ejecutar el evento clic de un botón de comando de múltiples maneras además de simplemente haciendo clic en él. El evento clic se puede activar presionando la tecla ENTRAR siempre que el botón tenga el enfoque o la propiedad Default esté establecida a True (True es equivalente a cualquier valor distinto de cero). También presionando la tecla ESC, y habiendo establecido la propiedad Cancel True. De todos los botones de comando de un formulario, sólo uno tiene establecido a True la propiedad Default o Cancel. 3.2.3. Caja de texto (Clase: TextBox) El control de la clase TextBox, también denominado control de campo de edición o control de edición, permite mostrar, editar e introducir información en tiempo de ejecución. La clase TextBox esta provista de la propiedad Text, la cual se modifica por teclado y está disponible por código tanto para lectura como para escritura. Regla de Visual Basic de prefijo para nombre del objeto Caja de texto: txt.

a) Propiedades de cajas de texto Propiedad CausesValidation Enabled HideSelection Locked MaxLength MultiLine PasswordChar ScrollBars SelLength SelStart SelText Text

Descripción Si ejecuta o no el evento Validate del objeto si pierde el enfoque. Si permite o no los eventos del ratón. Si oculta o no la selección del objeto cuando pierde el enfoque. Si bloquea o no la escritura en cajas de texto. Cantidad de caracteres admisibles en una caja de texto. Si permite o no varias líneas de escritura en una caja de texto. Carácter para enmascarar la escritura en cajas de texto. Tipo de barra de desplazamiento para cajas de texto. Cantidad de caracteres seleccionados en una caja de texto. Posición del cursor dentro de una caja de texto. Posición del cursor dentro de una caja de texto. Contenido alfanumérico de una caja de texto o combinada. Tabla 3.6.- Algunas propiedades de la caja de texto.

Para escribir en varias líneas de texto en un control de la clase TextBox, establezca la propiedad MultiLine a True. Para personalizar la combinación de barra de desplazamiento en un TextBox, establezca la propiedad ScrollBars. Las barras de desplazamiento siempre aparecerán en el TextBox cuando su propiedad MultiLine se haya establecido a True y su propiedad ScrollBars a cualquier valor excepto a 0-None. Si una caja de texto de múltiples líneas tiene una barra de desplazamiento horizontal, el texto se no ajustará automáticamente a la siguiente línea cuando la cantidad de caracteres abarque el tamaño de la caja de texto. 41

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

Se puede bloquear contra escritura un control TextBox para evitar que el usuario cambie su información con la propiedad Locked a True. Y si desea evitar que el usuario seleccione o enfoque a la caja de texto, coloque a False la propiedad Enabled. El número de caracteres, que el usuario puede introducir, también se puede limitar mediante la propiedad MaxLength. Otra restricción útil para las cajas de texto consiste en enmascarar los caracteres introducidos para evitar su visualización (contraseñas), así en la propiedad PasswordChar se define el carácter de máscara. Con las propiedades SelStart, SelLength y SelText se puede seleccionar parte del texto de una caja de texto. SelStart define la posición inicial, SelLength la longitud de la selección en cantidad de caracteres, y SelText devuelve la cadena seleccionada. Por ejemplo, suponga una caja de texto “txtMiCaja” contiene el texto “Todos los perros van al cielo”. Al ejecutar esta sección de código (Click en el botón de comando cmdSeleccionar), en la caja de texto txtSelección aparece la siguiente cadena de caracteres: “los perros”. Private Sub cmdSeleccionar_Click() txtMiCaja.SelStart = 7 txtMiCaja.SelLength = 10 txtSelección = txtMiCaja.SelText End Sub b) Métodos de cajas de texto Se puede controlar el enfoque de una caja de texto mediante el método SetFocus. Recuerde que no se pueden enfocar objetos deshabilitados (Enabled en False). txtMiCaja.SetFocus c) Eventos de cajas de texto Las cajas de texto responden a los siguientes eventos principalmente: Change, KeyDown, KeyPress, KeyUp, GotFocus, LostFocus y Validate. Se puede aprovechar el evento Change para deshabilitar un botón de comando si el contenido de una caja de texto (propiedad Text) es vacío. De esta manera se inhabilita un proceso hasta que el usuario introduzca datos al programa. Private Sub txtMiCaja_Change() Me.cmdBotón.Enabled = Len(Me.txtMiCaja.Text) End Sub Len: Es una función que devuelve el número de caracteres de una cadena de texto

Resulta conveniente que al enfocar una caja de texto, el contenido de esta se seleccione para su fácil modificación. Private Sub txtMiCaja_GotFocus() Me.txtMiCaja.SelStart = 0 Me.txtMiCaja.SelLength = Len(Me.txtMiCaja.Text) End Sub El evento KeyPress incluye el argumento “KeyAscii As Integer” que representa el código ASCII de la tecla que el usuario presiona dentro de la caja de texto. 42

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

Así podrá validar cada carácter introducido. En el ejemplo siguiente, se limita al usuario a escribir sólo caracteres numéricos. Private Sub txtMiCaja_KeyPress(KeyAscii As Integer) If (KeyAscii > 47) And (KeyAscii < 58) Then Exit Sub KeyAscii = 0 End Sub El código ASCII del caracter “0” es 48 y el del “9” es 57.

La primera instrucción indica que si el caracter está entre “0” y “9”, debe salir del procedimiento (Exit Sub), de lo contrario continúa con la siguiente instrucción, la cual convierte en caracter nulo a la tecla presionada, lo que es equivalente a bloquear el teclado para ese caracter. También, conociendo que el código ASCII de la tecla ENTER es 13, se puede seleccionar la siguiente caja de texto utilizando el método SetFocus. Private Sub txtMiCaja_KeyPress(KeyAscii As Integer) If (KeyAscii = 13) Then txtSelección.SetFocus End Sub Finalmente, la propiedad CauseValidation del objeto caja de texto activa o desactiva la sensibilidad del objeto ante el evento Validation. El evento Validation se ejecuta justo antes de desenfocar al objeto, lo que permite validar el contenido de la caja de texto y evitar su desenfoque si el valor no es válido, asignándole al parámetro Cancel True. Suponga que el valor a introducir debe ser menor o igual que 20; así que se cancelará el desenfoque para valores mayores a 20 Private Sub txtMiCaja_Validate(Cancel As Boolean) Cancel = (Me.txtMiCaja.Text > 20) End Sub 3.2.4. Marco (Clase: Frame) El objeto de la clase Frame es un contenedor. Este control proporciona un agrupamiento identificable para controles. También se puede usar un control Frame para subdividir un formulario funcionalmente. Para agrupar controles, dibuje primero el control Frame y, a continuación, dibuje los controles dentro de Frame. De este modo podrá mover (propiedades Top y Left), ocultar (propiedad Visible) o desactivar (propiedad Enabled) al mismo tiempo tanto al marco como a los controles contenidos en él. La propiedad BorderStyle establecida a 0-None oculta la etiqueta del marco. La propiedad TabStop no puede ser negada, ya que está establecida a True por defecto. Regla de Visual Basic de prefijo para nombre del objeto Marco: fra.

3.2.5. Caja de imagen (Clase: PictureBox) La caja de imagen, también como los marcos, actúa como contenedor. Puede emplear el control caja de imagen para agrupar controles en la parte superior o inferior del área interna del formulario o para crear una barra de herramientas o de estado. El tipo de alineación en el interior del formulario se establece mediante la propiedad Align. Al igual que con el marco, para agrupar objetos se debe dibujar primero la caja de imagen y luego los objetos dentro del contenedor. Este tipo de 43

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

control permite mostrar imágenes o gráficos de mapa de bits, iconos o meta archivos, así como también, archivos mejorados JPEG y GIF, mediante la propiedad Picture. Para hacer que un control PictureBox ajuste su tamaño automáticamente para mostrar un gráfico completo, establezca su propiedad AutoSize a True. Por otra parte, Visual Basic provee una función para cargar una imagen en tiempo de ejecución desde una unidad de disco, denominada LoadPicture. picMiDib.Picture = LoadPicture(“A:\Nubes.bmp”) Regla de Visual Basic de prefijo para nombre del objeto Caja de imagen: pic.

3.2.6. Botón de opción (Clase: OptionButton) Generalmente, los controles de la clase OptionButton se utilizan en un grupo de opciones para mostrar opciones entre las cuales el usuario sólo puede seleccionar una. Los controles OptionButton se agrupan si los dibuja dentro de un contenedor como un control Frame, un control PictureBox o un formulario. Todos los botones de opción que están dentro del mismo contenedor actúan como un único grupo. La propiedad más importante es la propiedad Value la cual puede ser True o False. El evento clic se ejecuta automáticamente con el enfoque del objeto. Regla de Visual Basic de prefijo para nombre del objeto Botón de opción: opt.

3.2.7. Caja de verificación (Clase: CheckBox) Se utiliza este control para ofrecer al usuario una opción de tipo Verdadero o Falso, o Sí o No; o para ofrecer múltiples opciones entre las cuales el usuario puede seleccionar una o más. La propiedad Value determina el estado del control: 0-Desactivado, 1-Activado, o 2-No disponible. Aunque puede parecer que los controles Botón de Opción y Caja de Verificación funcionan de forma similar, hay una diferencia importante: cuando un usuario selecciona un OptionButton, los otros controles OptionButton del mismo grupo dejan de estar disponibles automáticamente. Por el contrario, es posible seleccionar cualquier número de controles de la clase CheckBox. Regla de Visual Basic de prefijo para nombre del objeto Caja de verificación: chk.

3.2.8. Caja de lista (Clase: ListBox) La caja de lista muestra un conjunto de elementos entre los cuales el usuario puede seleccionar uno o más. Si el número de elementos supera al número de filas que pueden mostrarse, el control agregará automáticamente una barra de desplazamiento. Regla de Visual Basic de prefijo para nombre del objeto Caja de lista: lst.

a) Propiedades de cajas de lista Propiedad Columns ItemData List ListCount ListIndex MultiSelect

Descripción Número de columnas de una lista. Número específico para cada elemento de una lista. Elemento específico de una lista. Cantidad de elementos dentro de una lista. Número del elemento seleccionado de una lista. Modalidad de selección de una lista. 44

Visual Basic 6.0

Propiedad NewListIndex Selected Sorted Style

Unidad 3.- Objetos de Visual Basic

Descripción Número del elemento agregado nuevo a una caja de lista. Si está o no seleccionado un elemento de una lista. Si ordena o no los elementos de una lista. Estilo gráfico de objetos. Tabla 3.7.- Propiedades más importantes de listas.

ItemData es un vector que permite almacenar un número entero por cada elemento de la lista. Se utiliza como campo de información adicional para referencia o valor del un elemento de la lista. La propiedad ListIndex devuelve la posición del elemento seleccionado dentro de una caja de lista, y tiene valores desde -1 hasta ListCount-1. Si no se encuentra seleccionado ningún elemento de la lista, el valor de la propiedad ListIndex será automáticamente -1. Si el usuario selecciona el primer elemento de la lista, ListIndex tiene valor 0, y para el último elemento ListIndex es igual a ListCount-1. La propiedad List devuelve o establece los elementos contenidos en la caja de lista en una posición específica. Por ejemplo, considere la caja de lista lstMiLista, en la que se quiere escribir su primer y segundo elemento: lstMiLista.List(0) = ”Primer elemento de lista” lstMiLista.List(1) = ”Segundo elemento de lista” Se pueden definir dos estilos de cajas de lista mediante la propiedad Style: 0Normal o 1-Verificación. La propiedad MultiSelect acepta tres valores: 0-None (no permite selección múltiple), 1-Single y 2-Extended. La propiedad Selected devuelve o establece el estado de selección de un elemento de la lista. Por ejemplo, para seleccionar el primer elemento de lstMiLista en tiempo de ejecución: lstMiLista.Selected(0) = True b) Métodos de cajas de lista Método

Sintaxis

AddItem

Objeto.AddItem Elemento

RemoveItem

Objeto.RemoveItem Posición

Clear

Objeto.Clear

Acción Agregar el Elemento a un control caja de lista o caja combinada. NewListIndex tiene la posición. Eliminar el elemento que se encuentra en la Posición de una caja de lista o caja combinada Eliminar todos los elementos de una caja de lista o caja combinada. Tabla 3.8.- Métodos más importantes de las cajas de lista

3.2.9. Caja combinada (Clase: ComboBox) El objeto de la clase ComboBox se conoce como caja combinada porque está constituido por los objetos caja de texto y caja de lista; por lo tanto, incluye las propiedades, métodos y eventos de ambos. La diferencia del ComboBox respecto al ListBox es que las cajas combinadas no permiten selección múltiple, y obligan al usuario a que escoja uno de los elementos de la lista. Una vez seleccionado el ítem, se puede usar la propiedad Text y SelText para devolver el valor contenido en el control. Para las cajas combinadas aplican los métodos AddItem, RemoveItem y Clear de las cajas de lista. Es conveniente utilizar cajas combinadas en lugar de cajas de lista cuando sea requerido ahorrar área del formulario. Regla de Visual Basic de prefijo para nombre del objeto Caja combinada: cbo. 45

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

3.2.10. Barra de desplazamiento (Clase: HScrollBar, VScrollBar) Visual Basic provee tanto la barra de desplazamiento horizontal (HScrollBar) como vertical (VScrollBar), con el objeto de generar un valor entero limitado entre un mínimo y un máximo. Regla de Visual Basic de prefijo para nombre del objeto Barra de desplazamiento: hsb, vsb.

a) Propiedades de barras de desplazamiento Propiedad LargeChange Max Min SmallChange Value

Descripción Variación del valor de una barra de desplazamiento largo. Valor máximo de una barra de desplazamiento. Valor mínimo de una barra de desplazamiento. Variación del valor de una barra de desplazamiento en corto. Valor del objeto. Tabla 3.9.- Propiedades más importantes de la barra de desplazamiento.

El valor numérico de la barra se puede leer o establecer mediante su propiedad Value, la cual varía desde el valor de la propiedad Min hasta el valor de la propiedad Max. La propiedad Value cambia automáticamente cuando el usuario manipula la barra de desplazamiento en ejecución. Cuando el usuario usa las flechas, la variación de la propiedad Value depende de la propiedad SmallChange; y cuando hace clic en la barra, la variación depende de la propiedad LargeChange. Las propiedades Min, Max y Value aceptan valores enteros desde –32768 hasta 32767. Otra forma de modificar el valor de la barra de desplazamiento es moviendo directamente el bloque de desplazamiento, lo que produce el evento Scroll. Tanto el evento Scroll como el evento Change se pueden usar para actualizar los controles que utilizan el valor de la barra de desplazamiento. 3.2.11. Temporizador (Clase: Timer) No todos los eventos son producidos externamente por el usuario. El control temporizador posee sólo un evento, el evento Timer, el cual se activa automáticamente a intervalos periódicos. El control Timer es invisible para el usuario en tiempo de ejecución ya que no tiene representación gráfica. Este objeto resulta útil para el procesamiento de fondo, especialmente para las animaciones y monitoreo automático de procesos. La propiedad Interval devuelve o establece el tiempo en milisegundos en que se produce el evento Timer. La propiedad Enabled activa (True) o detiene (False) el reloj del control. No existe ningún límite práctico en cuanto al número de controles Timer activos (Enabled = True) ejecutándose simultáneamente. Regla de Visual Basic de prefijo para nombre del objeto Temporizador: tmr.

3.2.12. Imagen (Clase: Image) Utilice el control Image para mostrar un gráfico o imagen. Un control Image puede mostrar un gráfico desde un mapa de bits, un icono o un metarchivo, así como un metarchivo mejorado, un archivo JPEG o archivos GIF. La gran diferencia con el control caja de imagen es que el control imagen no es un contenedor, además posee la propiedad Stretch, la cual permite ajustar la imagen al tamaño del control, y no es el control el que se ajusta al tamaño de la imagen como ocurre en el PictureBox. Por otra parte, el control de la clase Image utiliza menos recursos del sistema y se actualiza con más rapidez, por lo que se recomienda para animaciones o funciones decorativas. 46

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

Para crear una animación o simulación, puede manipular las propiedades y métodos gráficos en el código de un control Temporizador. Puede rellenar un control imagen (propiedad Picture) con distintas imágenes donde cada una muestre un estado consecutivo. Private Sub tmrMiTimer_Timer() If imgImagen.Picture = imgImagen2.Picture Then imgImagen.Picture = imgImagen1.Picture Else imgImagen.Picture = imgImagen2.Picture End If End Sub La imagen imgImagen cambiará su gráfico de fondo (propiedad Picture) cada cierto tiempo, según el valor establecido en la propiedad Interval del objeto Timer. La velocidad de cambio se establece mediante la propiedad Interval del Timer. Regla de Visual Basic de prefijo para nombre del objeto Imagen: img

3.2.13. Figura (Clase: Shape) El objeto Shape es un control gráfico que se muestra como un rectángulo, un cuadrado, una elipse, un círculo, un rectángulo redondeado o un cuadrado redondeado. Su función es decorativa es decorativa, para enmarcar otros objetos o para dividir el formulario en varios sectores. Este tipo de objeto carece de eventos. Se usa el control de la clase Shape en lugar de usar los métodos gráficos Line o Circle para dibujar formas básicas sobre un formulario. Regla de Visual Basic de prefijo para nombre del objeto Figura: shp.

3.2.14. Línea (Clase: Line) Line es un control gráfico que se muestra como una línea horizontal, vertical o diagonal, según sus propiedades X1, Y1, X2 y Y2. Permite reemplazar el uso del método Line de los formularios y las cajas de imagen. Regla de Visual Basic de prefijo para nombre del objeto Línea: lin.

3.2.15. Ubicación de los controles básicos PictureBox

Label

TextBox

Frame

CommandButton

CheckBox

OptionButton

ComboBox

ListBox

HScrollBar

VScrollBar

Timer

DriveListBox

DirListBox

FileListBox

Shape

Line

Image

Data

OLE

Figura 3.3.- Caja de herramientas (Clases).

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

3.2.16. Ejemplo de los controles bรกsicos

Figura 3.4.- Ejemplo de los controles bรกsicos.

Visual Basic 6.0

Unidad 3.- Objetos de Visual Basic

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

Unidad 4 Código en Visual Basic “La confusión es parte del proceso de aprendizaje” .- Dr. Lair Ribeiro

4.1. Espacios de memoria 4.1.1. Identificadores A menudo necesitará almacenar valores temporalmente en memoria cuando esté realizando cálculos con Visual Basic. Por ejemplo, puede que desee calcular diversos valores, compararlos y realizar distintas operaciones con ellos, dependiendo de los resultados de la comparación. La manera de referir a esos espacios de memoria donde se encuentran los valores es mediante identificadores. Los identificadores son los nombres que se utilizan para referir en el programa a espacios de memoria (variables, constantes, procedimientos y objetos). Estos permiten identificar unívocamente cualquier elemento del programa. En Visual Basic tienen las siguientes características: a) Deben comenzar con caracter alfabético (una letra) b) No deben contener caracteres especiales (guiones, espacios, puntos, etc.) c) No pueden ser palabras reservadas (Private, End, Click, Sub, etc.) d) Debería ser lo más mnemotécnicos posible, y no más de 25 caracteres. 4.1.2. Tipos de datos Los tipos de datos especifican las características de la información que se almacenará en memoria. De esta manera, cada tipo de datos requiere un espacio de memoria determinado y una forma de manipulación específica. Una suma de números es distinta a una suma de caracteres o de fechas. También, requeriría menos espacio de memoria la edad de una persona que las distancias interestelares. Por esta razón, es imprescindible que el programador conozca los tipos de datos disponibles en Visual Basic, para que utilice el que menos requerimientos de memoria posea, y el más apropiado para que cumpla su cometido. Aunque el lenguaje provee muchos tipos de datos, estos también pueden ser definidos por el usuario. También existen otros tipos de datos provistos por objetos específicos. En esta parte trataremos los tipos de datos predefinidos en Visual Basic (ver Tabla 4.1) agrupados como sigue: a) Tipos de datos numéricos (Byte, Integer, Long, Single, Double y Currency): Permiten efectuar operaciones aritméticas como suma, resta, multiplicación, etc. Los tipos de datos numéricos pueden ser enteros o fraccionarios. Si se asigna a un tipo de dato entero números con decimales, este se redondea al 50

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

entero inmediato superior. Se producirá un error de desbordamiento al intentar cargar un tipo de dato numérico con valores superiores a su espacio disponible (ver la columna Intervalo en la Tabla 4.1). Por ejemplo, el tipo de datos Byte permite valores hasta 255. Si intentara asignar valores superiores a 255 para un dato tipo Byte, se producirá un error. Por otra parte, si la intención del espacio de memoria es almacenar números con decimales, es conveniente especificar los tipos de datos Single, Double o Currency. Se recomienda utilizar el tipo de dato Currency para manipular cantidades monetarias o cualesquiera otras que requieran cierto grado de precisión. b) Tipo de dato lógico (Boolean): Este tipo de dato se establece a True (True equivale a -1) cuando se le asigna cantidades distintas de cero; y, se establece a False (False equivale a 0) cuando se le asigna cero. c) Tipo de dato de cadenas de caracteres (String): Los espacios reservados para cadenas de caracteres pueden ser de longitud fija o variable. Se escoge el tipo de dato de cadena fija, sólo cuando se conoce con antelación y seguridad la cantidad de caracteres que desea guardar. Si se asigna una cadena con más caracteres que los admitidos por el tipo de dato de longitud fija, los caracteres a la derecha de la cadena son truncados. La cantidad de caracteres para cadenas fijas se especifica mediante el valor de L (ver Tabla 4.1). Las cadenas se delimitan mediante comillas dobles, al principio y al final de la cadena. Tipo Byte (entero positivo) Integer (entero corto) Long (entero largo) Single (coma flotante) Double (coma flotante) Currency (coma fija)

Para

Bytes 1

Números enteros

2 4 4

Números con decimales

8 8

Boolean

Valores lógicos

Date

Fechas y horas

Object

Instancias de objetos

String (longitud variable) String * L (longitud fija) Variant (con números) Variant (con caracteres)

Cadenas de caracteres de longitud variable Cadenas de caracteres de longitud fija

10 + L L 16

Datos variables 22 + L

Intervalo Desde 0 Hasta 255 -32.768 hasta +32.767 -2.147.483.648 a +2.147.483.647 -3,4028E38 a –1,4013E-45 (negativos) +1,4013E-45 a +3,4028E38 (positivos)) -1,7977E308 a -4,9407E-324 (negativos) +4,9407E-324 a +1,7977E308 (positivos) -922.337.203.685.477,5808 a +922.337.203.685.477,5807 True ó False 1 de enero de 100 a 31 de diciembre de 9999 Cualquier referencia a tipo Object No importa la clase del objeto. Desde 0 hasta 2.000 millones de caracteres (L: Cantidad de caracteres) Desde 1 a 65.400 caracteres aprox. (L: Cantidad de caracteres) Cualquier valor numérico hasta el intervalo de un tipo Double Desde 0 hasta 2.000 millones (L: Cantidad de caracteres) Tabla 4.1.- Tipos de datos provistos por Visual Basic.

d) Tipo de datos para fecha y hora (Date): Permite efectuar cálculos de fecha y hora. El valor de una fecha u hora se delimita mediante los caracteres numerales (#), y se utilizan los caracteres barra (/) o guión (-) para separar día, mes y año, y el caracter dos puntos (:) para separar hora, minuto y segundo. 51

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

e) Tipo de dato para instancias de objetos (Object): Es posible crear un identificador distinto al nombre de un objeto, pero que hace referencia a ese objeto. Este un buen ejemplo de polimorfismo en Visual Basic. f)

Tipo de dato variable (Variant): Es el tipo de dato que más consume recursos de memoria, ya que tiene la posibilidad de adaptarse o convertirse automáticamente en cualquiera de los otros tipos de dato.

4.1.3. Declaración de espacios de memoria Los espacios de memoria pueden estar sujetos a cambio, o estar protegidos para que no puedan ser modificados. En cualquiera de los casos se debe crear un apuntador (identificador) y especificar las características (tipo de dato) del espacio de memoria. Los espacios de memoria temporales, con nombre y tipo de dato, se conocen como Variables. Por otra parte, los espacios protegidos de memoria, identificados y configurados a un tipo de dato, reciben el nombre de Constantes. En la mayoría de los lenguajes de programación, el uso de un espacio de memoria debe ser informado al sistema operativo de la computadora; es decir, debe ser declarado. La declaración consiste en indicar el tipo de protección (variable o constante), el identificador, y el tipo de dato de un espacio de memoria, teniendo así declaración de variables y declaración de constantes. a) Variables Puede considerar una variable como un marcador de posición en memoria de un valor desconocido. Por ejemplo, suponga que está creando un programa de ventas. Aunque conociera el producto y el precio, no sabe la cantidad que se ha vendido hasta que no se produce realmente la venta. En este caso debe usar variables para almacenar los valores desconocidos: cantidad de producto y precio total. Visual Basic permite utilizar las variables sin ser previamente declaradas, lo que se conoce como declaración implícita, y es una práctica indebida. Siempre se deben declarar las variables mediante instrucciones adecuadas de manera explícita. Se recomienda utilizar la sentencia siguiente en la sección declaraciones de cada módulo para detectar, durante la compilación, aquellas variables que no hayan sido declaradas explícitamente. Option Explicit b) Constantes Las constante generalmente se utilizan para presentar valores que aparecen en muchas partes del código o para presentar valores numéricos difíciles de recordar; de tal manera, que una modificación de la cadena o del número se pueda efectuar en una sola parte del código del programa, y no sea necesario navegar toda la aplicación efectuando la misma modificación. Por ejemplo, el mensaje de error: “Ha ocurrido un error irrecuperable, debe abortar la operación”, es una gran cantidad de caracteres que resultaría tedioso escribir cada vez que se requiera para mostrar al usuario que ha ocurrido un error; y también si el programador decide escribir este texto en varias zonas del programa y desea cambiar el mensaje de error, tendrá que efectuar el cambio en todas las secciones del código donde se encuentre el texto. Visual Basic provee un conjunto de constantes denominadas constantes intrínsecas. Las constantes creadas por el usuario se conocen como constantes simbólicas.

Visual Basic 6.0

Unidad 4.- Cรณdigo de Visual Basic

4.1.4. Alcance de variables y constantes En esta parte conoceremos donde se deben efectuar las declaraciones. Las declaraciones de variables y constantes pueden efectuarse en cualquier mรณdulo y en cualquier parte del mรณdulo. La escogencia estรก sujeta al รกrea del cรณdigo, en el cual, el analista desea que la variable o constante tenga vigencia; es decir, exista. Una variable o constante comienza a existir en el momento de su declaraciรณn, y estarรก disponible, existirรก y conservarรก su valor sรณlo en las รกreas del cรณdigo que abarque el sitio de su declaraciรณn. Por eso es importante conocer en que parte del cรณdigo declarar. De esta manera, se tienen tres tipos de variables y constantes, segรบn su alcance o vigencia. a) Vigencia Local: La variable o constante que se declara dentro de un procedimiento, existe sรณlo dentro de ese procedimiento. Cuando el procedimiento termina, la variable o constante deja de existir, y no puede utilizarse nuevamente en otros procedimientos. La vigencia de variables locales puede ser volรกtil o estรกtica, segรบn la variable pierda o conserve su valor al terminar el procedimiento. Aunque la variable estรกtica conserva su valor al terminar el procedimiento, esta no puede utilizarse en otros procedimientos. b) Vigencia Limitada: La variable o constante se declara en la secciรณn declaraciones de cualquier mรณdulo y se puede utilizar en cualquiera de los procedimientos que se encuentran dentro del mรณdulo donde se creรณ el espacio de memoria. Una variable o constante de alcance limitado creada en el mรณdulo 1, no se puede usar en el mรณdulo2; pero si en cualquier procedimiento del mรณdulo 1. c) Vigencia Pรบblica (Global): Este tipo de variable o constante se puede acceder desde cualquier mรณdulo en cualquiera de sus procedimientos. Se dice que es una variable o constante del proyecto en general, disponible para todos los mรณdulos. En este caso, la declaraciรณn se debe efectuar en la secciรณn declaraciones de un mรณdulo estรกndar y con una sintaxis particular que veremos mas adelante. 4.1.5. Declaraciรณn de variables Ahora veremos la sintaxis y las sentencias establecidas para efectuar los distintos tipos de declaraciones de variables. a) Variable local volรกtil: Se utiliza la sentencia Dim dentro de un procedimiento. Private Sub Procedimiento() Dim Edad As Byte {Instrucciones} End Sub b) Variable local estรกtica: Se utiliza la sentencia Static dentro de un procedimiento. Private Sub Procedimiento() Static Edad As Byte {Instrucciones} End Sub

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

c) Variable limitada: Se utiliza la sentencia Private en la sección declaraciones de cualquier módulo. Private Edad As Byte Private Sub Procedimiento() Dim VariableLocal As Tipo {Instrucciones} End Sub d) Variable pública: Se utiliza la sentencia Public en la sección declaraciones, pero de un módulo estándar. Public Edad As Byte Private Sub Procedimiento() Dim VariableLocal As Tipo {Instrucciones} End Sub 4.1.6. Declaración de constantes (simbólicas) Para la declaración de constantes simbólicas (de usuario) se utiliza la sentencia Const en todos los casos precedida del tipo de alcance si es limitada o pública. a) Constante local: (dentro de un procedimiento) Const PI As Currency = 3.1416 b) Constante limitada: (en la sección declaraciones de cualquier módulo) Private Const PI As Currency = 3.1416 c) Constante pública: (en la sección declaraciones de un módulo estándar) Public Const PI As Currency = 3.1416 4.1.7. Constantes intrínsecas Las constantes intrínsecas se conocen también como constantes definidas por el sistema y son proporcionadas por aplicaciones y controles de Visual Basic. Ejemplo de estas constantes son las de color: vbBlack, vbBlue, vbCyan, vbGreen, vbMagenta, vbRed, vbWhite y vbYellow. Las constantes intrínsecas no requieren ningún tipo de declaración. Para localizar, visualizar o copiar las constantes incorporadas en Visual Basic, se puede acceder a la ventana “Examinador de objetos” presionando F2 o mediante el menú “Ver | Examinador de objetos”. Otras aplicaciones que proporcionan bibliotecas de objetos, como Microsoft Excel y Microsoft Project, también proporcionan una lista de constantes que se puede usar con sus objetos, métodos y propiedades. También se definen constantes en la biblioteca de objetos de cada control ActiveX. ActiveX™:

Es un conjunto de tecnologías que habilitan componentes de software para interactuar en un ambiente de red, sin tener en cuenta el lenguaje en que fueron creados. En el capítulo 8, se verá con más detalle.

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

Figura 4.1.- Diálogo Examinador de objetos.

4.1.8. Arreglos Los arreglos permiten definir varios espacios de memoria del mismo tipo con un solo identificador, pudiendo diferenciar cada espacio de memoria mediante apuntadores o marcadores que se conocen como índices. Los arreglos pueden ser de una dimensión (vectores), cuando utilizan un solo índice; o de varias dimensiones (matrices), cuando utilizan varios índices. Mediante los índices se puede acceder directamente a cada uno de los elementos de un arreglo. Para declarar arreglos de una dimensión se usa: Dim MiVector(Máximo) As tipo Máximo es un valor que determina el máximo índice del vector, y tomando en cuenta que el índice mínimo es cero, el número de elementos del vector será igual a Máximo + 1. Por ejemplo, suponga la siguiente declaración: Dim MiVector(4) As Long De esta manera se han creado 5 espacios de memoria tipo Long identificados por: Mivector (0), Mivector (1), Mivector (2), Mivector (3) y Mivector (4). También se puede especificar un rango de índices que inicie distinto de cero: Dim MiArreglo (Mínimo To Máximo) As tipo Mínimo determina en índice inferior e inicio del rango. Por ejemplo: Dim Estudiantes (1 To 7) As String Para declarar matrices, los rangos de cada dimensión se separan mediante comas: Dim Nota (1 To 7, 1 To 5) As Single Finalmente, para usar la variable de un arreglo, se debe especificar el índice correspondiente, tal como se muestra a continuación, donde se asigna la nota de la tercera evaluación al quinto alumno: 55

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

Alumno = 5 Evaluación = 3 Nota(Alumno, Evaluación) = 20.5 4.1.9. Objetos y espacios de memoria Cada uno de los objetos requiere espacios de memoria para variables y constantes. Estos espacios de memoria no requieren declaración, ya que los mismos se crean automáticamente con la creación del objeto. Se puede decir que estos espacios de memoria son de alcance público, ya que están disponibles en toda la aplicación. a) Identificadores: Los espacios de memoria requeridos por un objeto se identifican mediante el nombre del contenedor, el nombre del objeto y el nombre de la propiedad separados por el operador punto. b) Variables: Cada propiedad del tipo lectura-escritura de un objeto se almacena en un espacio de memoria variable. Por ejemplo la propiedad Enabled se almacena en un espacio de memoria que se puede cambiar durante la ejecución y su tipo de dato Boolean. c) Constantes: Las propiedades de solo lectura son constantes, como la propiedad Moveable que se puede leer pero no cambiar durante la ejecución. También, los valores de ciertas propiedades son constantes del objeto. Por ejemplo, los valores de la propiedad BorderStyle de un formulario pueden ser 0-None, 1-FixedSingle, 2-Sizable, etc. d) Arreglos: Distintos espacios de memoria, pero bajo un mismo nombre de objeto, es posible mediante los arreglos de objetos. Las colecciones son parecidas a los arreglos de objetos, las cuales se basan en crear varios objetos con el mismo identificador. La manera de diferenciar un objeto de otro es mediante su propiedad Index, ya que cada objeto dentro del arreglo posee propiedades individuales. Los arreglos de objetos son unidimensionales y muchas veces se tratan como vectores de objetos. Para referirse a la propiedad de un objeto específico, se hace referencia tanto al nombre del objeto como a su índice. En un arreglo de 3 botones de comando se desea deshabilitar sólo al segundo botón, y habilitar los otros dos botones: Me.cmdBotón(0).Enabled = True Me.cmdBotón(1).Enabled = False Me.cmdBotón(2).Enabled = True Utilizando colecciones o arreglos se optimiza el uso del sistema, ya que consumen menos recursos que los controles creados independientemente. Los objetos de un arreglo comparten el mismo procedimiento de evento, por lo tanto no es necesario escribir código separado por cada objeto del vector. Los procedimientos de evento de un objeto en un arreglo, incluyen el argumento “Index”, el cual permite identificar o diferenciar al objeto causante del evento. 56

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

Private Sub cmdBotón_Click(Index As Integer) {Instrucciones} End Sub Como se puede observar, el evento clic incluye la variable Index. Si el usuario hace clic en el primer, segundo o tercer botón, se ejecuta siempre este mismo procedimiento de evento, pero la variable Index se carga con el valor de la propiedad Index del objeto que desató el evento. Por ejemplo, si el usuario hizo clic el cmdBotón (1), la variable Index se carga con el valor 1. Puede crear un arreglo de controles estableciendo la propiedad Index del objeto. Alternativamente, en forma gráfica, puede seleccionar, copiar y pegar el objeto, y el sistema solicitará si desea crear un arreglo de controles. Seleccionando “Sí”, el control original adopta índice 0, y el control copia se crea con las mismas propiedades del control original y adopta índice 1. En adelante se pueden seguir copiando otros controles sin que el sistema solicite confirmación, y se incrementará automáticamente el valor de la propiedad Index. El número de elementos de una colección o arreglo, se invoca mediante su propiedad Count. Por ejemplo, a continuación se escribe en una caja de lista el rótulo de todos los botones de comando de la colección cmdBotón. Dim i As Integer For i = 0 To Me.cmdBotón.Count - 1 Me.lstObjetos.AddItem Me.cmdBotón(i).Caption Next i En el ejemplo siguiente, se utilizan 15 botones de opción para establecer el color de fondo del formulario mediante la función de color QBColor. Private Sub optColor_Click(Index As Integer) Me.BackColor = QBColor(Index) End Sub 4.2. Operadores 4.2.1. Aritméticos Los operadores aritméticos permiten efectuar los cálculos matemáticos mostrados a continuación (ver Tabla 4.2). Operación Suma o adición Resta o sustracción, e Inversión de signo Multiplicación o producto División o fraccionamiento División entera Módulo o resto Elevación a potencia

Operador + * / \ Mod ^ Tabla 4.2.- Operadores aritméticos de Visual Basic

La división entera (\) devuelve el valor de la parte entera del resultado de una división. Por ejemplo, 5\2 es igual a 2, ya que 5/2 es igual a 2,5. Por otra parte, el operador Mod permite obtener el resto o residuo de una división. Para el caso 5 Mod 2, el resultado es igual a 1, ya que 2x2 es igual a 4 y falta 1 para 5. 57

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

4.2.2. Lógicos Los operadores lógicos permiten obtener resultados lógicos (True o False) mediante una comparación bit a bit de dos expresiones. En Visual Basic, False representa al número 0, y True a cualquier otro valor distinto de 0 (cero). La tabla 4.3 muestra los operadores lógicos de Visual Basic y sus resultados según las expresiones A y B. A

True False True False

True True False False

A And B True False False False

A Or B

Not(A)

Not(B)

True True True False

False True False True

False False True True

A Xor B False True True False

A Eqv B True False False True

A Imp B True True False True

Tabla 4.3.- Resultados de operaciones lógicas.

4.2.3. Relacionales Los operadores relacionales se utilizan para comparar dos condiciones lógicas de una expresión. Por lo general se utilizan en las estructuras de control que veremos más adelante. A continuación (ver Tabla 4.4) se muestra los operadores relacionales. Operación Es igual a Es distinto de Es menor que Es mayor que Es menor o igual que Es mayor o igual que Es como (el patrón de cadena)

Operador = <> < > <= >= Like Tabla 4.4.- Operadores relacionales de Visual Basic.

El operador relacional “igual a” utiliza el mismo signo que el operador de asignación (=), y no se deben confundir. Considere el siguiente ejemplo, donde se declara la variable Booleana “EsDivisorCero”, y se colocan las cajas de texto txtDiv, txtDivisor y txtCoc, para el dividendo, divisor y cociente respectivamente de una división en un formulario. Al hacer clic en el botón de comando cmdDividir, se efectúa el cálculo. Después de declarar la variable se asigna a la variable EsDivisorCero el resultado de comparar el contenido de la caja de texto del divisor con cero. Si se cumple que el divisor es igual a cero; a la variable se le asigna True, de lo contrario se le asigna False. Luego en la estructura If, se evalúa el valor de la variable EsDivisorCero, la cual, si es verdadera se ejecuta la sentencia Exit Sub y termina el procedimiento. En este mismo punto, si la variable EsDivisorCero es falso, se continúa con la siguiente línea que finalmente calcula la división y se la asigna a la caja de texto cociente. Private Sub cmdDividir_Click() Dim EsDivisorCero As Boolean EsDivisorCero = Me.txtDivisor.Text = 0 If EsDivisorCero Then Exit Sub Me.txtCoc.Text = Me.txtDiv.Text / Me.txtDivisor.Text End Sub El operador Like compara una cadena de caracteres con un patrón, el cual incluye los siguientes caracteres comodines: 58

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

a) ¿: para representar un único caracter alfanumérico, b) *: para representar un conjunto de caracteres alfanuméricos, c) #: para representar un caracter numérico o dígito, d) [A-Z]: para representar un rango de caracteres coincidentes e) [¡A-Z]. para representar un rango de caracteres no coincidentes Por ejemplo la variable P (de parecido) es tipo Boolean: 'Las siguentes P son True: P = “aAGVFa” Like “a*a” P = “F” Like “[B-N]” P = “F” Like “[¡A-D]” P = "BAT123" Like "B?T123" 'Las siguientes P son False: P = “aAAjFas” Like “*a” P = “BT123” Like “B?T123”

'Comienza y termina con a 'La F está entre B y N 'La F no está entre A y D 'Entre B y T hay un caracter 'No termina con a sino con s 'No hay caracter entre B y T

4.2.4. Operadores especiales a) Operador de asignación (=): Se utiliza el signo “igual a“ (=) para transferir un Valor desde el lado derecho del signo, hasta el Identificador del lado izquierdo. Identificador = Valor Nota: No confundir la asignación con la comparación

b) Operador de concatenación (&): Para unir dos cadena de texto en una sola, se acostumbra a utilizar el operador &, aunque también se puede usar el operador +. En el ejemplo siguiente, el título de un formulario es el resultado de una concatenación. Si en la caja de texto se escribe el caracter “5”, el título del formulario será “Ventana 5”. Observe que si no se dejara el espacio antes de la comilla de cierre, el título resultante sería: “Ventana5” Me.Caption = “Ventana ” & Me.txtNumero.Text c) Operador punto (.): Este operador se usa para relacionar un objeto con su propiedad, método u objeto dependiente. También aplica para hacer referencia a variables de tipo de datos definidos por el usuario. Cada vez que se escribe un punto después de la variable de objeto, se despliegan todos sus miembros, permitiendo al usuario buscar y seleccionar el miembro requerido. 4.2.5. Precedencia de los operadores La precedencia de los operadores se refiere al orden en que las operaciones matemáticas se efectúan. En la tabla siguiente (ver Tabla 4.5) se muestra el orden de precedencia de los operadores aritméticos, lógicos y relacionales. Orden 1 2 3 4 5 6

Aritméticos Potencia (^) Inversión de signo (-) Multiplicación (*) y división (/) División entera (\) Módulo (Mod) Suma (+) y Resta(–)

Lógicos Igual a (=) Distinto de (<>) Menor que (<) Mayor que (>) Menor o igual a (<=) Mayor o igual a (=>)

Relacionales Negación (Not) Conjunción (And) Disyunción (Or) Exclusión (Xor) Equivalencia (Eqv) Implicación (Imp) Tabla 4.5.- Precedencia de operadores

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

Los operadores que se encuentran en la misma línea, como suma y resta, y multiplicación y división, se ejecutan de izquierda a derecha. Para controlar la precedencia de manera adecuada se usan paréntesis. Por ejemplo: Num Num Num Num Num Num

= = = = = =

4 + 3 * 2 ^ 4 + 3 * 2 ^ (4 + 3) * 2 4 + (3 * 2) (4 + 3 * 2) (4 + 3 * 2)

2 - 1 (2 - 1) ^ 2 - 1 ^ 2 - 1 ^ 2 - 1 ^ (2 – 1)

'A 'A 'A 'A 'A 'A

Num Num Num Num Num Num

se se se se se se

le le le le le le

asigna asigna asigna asigna asigna asigna

15 10 27 39 99 100

4.3. Estructuras de control 4.3.1. Programación estructurada Los lenguajes de programación secuencial incluían un apuntador por cada línea de código, de tal manera que era posible saltar un conjunto de líneas hacia delante o hacia atrás indicándole al programa el número de línea de salto explícitamente. Los saltos de línea hacia delante evitaban que se ejecutaran las líneas intermedias (bifurcación). Y los saltos hacia atrás permitían que las líneas intermedias se ejecutaran varias veces (repetición). Con la aparición de los lenguajes estructurados, se evita en lo posible hacer referencia explícita a las líneas de código, y en su lugar existen sintaxis con inicio y fin de estructuras. Las estructuras de control proporcionan al programa la posibilidad de que sus líneas de instrucción no se ejecuten en forma secuencial. Para esto, las estructuras de control evalúan resultados lógicos y toman decisiones para la ejecución, o no ejecución, de las instrucciones controladas. Las estructuras de control permiten controlar el flujo de ejecución del programa. Si no se controla el flujo, las líneas de instrucción se leerán de arriba hacia abajo, y cada instrucción de izquierda a derecha. La mayor parte del poder y utilidad de un lenguaje deriva de su capacidad de cambiar el orden de las instrucciones mediante saltos y bucles. 4.3.2. Tipos de estructuras Según el tipo de salto de instrucciones, hacia delante o hacia atrás, se tienen estructuras bifurcativas o repetitivas respectivamente. a) Las estructuras bifurcativas: permiten agrupar conjuntos de instrucciones para activar selectivamente su ejecución. La selección de un conjunto de instrucciones depende del resultado verdadero (True) de una expresión lógica o relacional. b) Las estructuras repetitivas: por su parte agrupan sólo a un conjunto de instrucciones que se pueden ejecutar varias veces. La ejecución del conjunto de instrucciones también es controlada por expresiones lógicas o condiciones. 4.3.3. Estructura bifurcativa If-Then-ElseIf-Else La sentencia “If” permite crear una estructura de decisión que se cierra mediante la sentencia “End If”; sin embargo, cuando se trata de sólo una instrucción a ejecutar, se puede obviar la sentencia de cierre “End If” y se escribe en una sola línea. Se pueden tomar decisiones múltiples mediante “ElseIf” que evalúa una expresión por cada instrucción o conjunto de instrucciones que se desea ejecutar. A continuación se muestran algunos casos y sus diagramas de flujo. 60

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

a) Una sola línea de instrucción por una expresión: If expresión Then UnaInstrucción1 Else UnaInstrucción2 If False

Expresión

Else

True Then

End If Figura 4.2.- Estructura If-Then-Else simple.

b) Varias líneas de instrucción para varias expresiones lógicas: If expresión1 Then Instrucciones si expresión1 es True ElseIf expresión2 Then Instrucciones si expresión2 es True Else Instrucciones si expresión1 y expresión2 son False End If If False

Expresión 1

ElseIf

True Then

False

Expresión 2

True Then

ElseIf False

Expresión N

Else

True Then

End If Figura 4.3.- Estructura If-Then-Else completa.

Observación: En cada bloque de instrucciones tipo Then o Else se pueden anidar estructuras If – Then – Else.

4.3.4. Estructura bifurcativa Select-Case Para la bifurcación con Select Case, la variable se evalúa de distintas maneras en cada bloque Case, como se muestra en la figura 4.4. La expresión lógica (variables y operadores relacionales) se construye internamente a diferencia de la estructura If. Select Case se utiliza cuando la variable a evaluar es la misma en todos los puntos de bifurcación. La sintaxis es la siguiente, donde se evalúa a la variable A: Select Case A 61

Visual Basic 6.0

Case 0 'Instrucciones Case 3 'Instrucciones Case 4, 7 'Instrucciones Case 8 To 10 'Instrucciones Case Is > 10 'Instrucciones Case Else 'Instrucciones End Select

Unidad 4.- Código de Visual Basic

si A es 0 si A es 3 si A es 4 ó 7 si A es 8, 9 ó 10 si A es mayor a 10 para los otros casos

Select Case A A=v1 ó A=v2 False A >=v3 y A<=v4 False

False

A >vN

Case Else

True Case v1, v2 True Case v3 To v4

True Case Is > vN

End Select Figura 4.4.- Estructura Select Case

4.3.5. Estructura repetitiva For-Next Se utiliza para repetir un conjunto de instrucciones un número determinado de veces; es decir, cuando el usuario conoce exactamente cuantas veces repetir el conjunto de instrucciones. Para esto, la estructura requiere una variable de Control tipo entera que cambiará desde un valor de Inicio hasta un valor de Fin. La variación o Paso de un valor a otro se puede establecer como un número positivo o negativo, de tal manera que la variable cambie en forma ascendente o descendente con incrementos uniformes. La sintaxis para el bucle For-Next es la siguiente: For Control = Inicio To Fin Step Paso 'Instrucciones [Exit For] Next Control Cada vez que se ejecuta el ciclo For-Next, el sistema evalúa la relación entre el valor de la variable Control y Fin. Para valores positivos de Paso se tiene variación ascendente de Control, y siempre que Control sea menor o igual que Fin, el bucle se repite, de lo contrario termina. Para valores negativos de Paso, la variación es descendente y el bucle se mantiene mientras Control sea mayor que Fin. Para interrumpir un ciclo For-Next, independientemente del valor de Control, se puede usar la palabra Exit For. Los ciclos For-Next anidados están permitidos. 62

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

For Control Control = Inicio

False

Control < Fin*Paso True Instrucciones del Bucle

Next Control

Control = Control + Paso Figura 4.5.- Estructura For-Next.

4.3.6. Estructura repetitiva Do-Loop Esta estructura repetitiva ejecuta un conjunto de instrucciones mientras evalúa una condición como verdadera o falsa. La evaluación de la condición se puede efectuar al principio o al final de la estructura. Si la evaluación es al principio de la estructura, y no se cumple la condición predeterminada, el bloque de instrucciones no se ejecuta. Por otra parte, si la condición se evalúa al final de la estructura, el conjunto de instrucciones se ejecuta por lo menos una vez, aunque no se cumpla la condición. Existen dos tipos de sentencia Do-Loop, la sentencia While que mantiene el ciclo mientras una condición sea verdadera (True), y la sentencia Until que mantiene el ciclo mientras la condición es falsa (False). La sintaxis para cada uno de los casos se muestra a continuación: a) Do While-Loop: Se evalúa al principio con While Condición=True Do While Condición {Instrucciones} [Exit Do] Loop b) Do-Loop While: Se evalúa al final con While Condición=True Do {Instrucciones} [Exit Do] Loop While Condición c) Do Until-Loop: Se evalúa al principio con Until Condición=Flase Do Until Condición {Instrucciones} [Exit Do] Loop d) Do-Loop Until: Se evalúa al final con Until Condición=Flase Do {Instrucciones} [Exit Do] Loop Until Condición 63

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

Do While False

¿Condición?

Do Until True

Instrucciones

True Instrucciones Loop Loop

¿Condición?

Instrucciones

False Loop While

¿Condición?

Instrucciones True Loop

False Loop

Loop

Loop Until

¿Condición?

False

True Loop Figura 4.6.- Estructuras Do-Loop.

Salir del Do: Se puede terminar el bucle Do-Loop mediante la sentencia Exit Do.

4.4. Procedimientos 4.4.1. Procedimientos y subrutinas Una de las características que definen a un lenguaje de programación estructurado es que el código se encuentra agrupado en bloques de instrucciones con sentencias de inicio y final del bloque. Estos bloques de instrucciones reciben el nombre de procedimientos. Podríamos definir un procedimiento como una secuencia de instrucciones para efectuar tareas específicas que se ejecutan como una unidad que tiene nombre o identificador. La estructura básica del código de Visual Basic es el procedimiento, de hecho todo el código ejecutable esta contenido en procedimientos. A diferencia de las estructuras de control, los procedimientos no se pueden anidar dentro de otros procedimientos. Sin embargo, se pueden crear pequeñas secciones de código enmarcados dentro de un procedimiento. Estos pequeños bloques se conocen como Subrutinas, las cuales carecen de nombre o identificador, y en su lugar, se accede a ellos mediante etiquetas de código. Las etiquetas son marcadores de posición y están constituidas por un nombre seguido de dos puntos en una línea de código libre dentro de un procedimiento. Las subrutinas, en términos de lenguajes de programación en general, son porciones lógicas de código que se encargan de resolver un problema específico. La subrutina en términos de Visual Basic se aplica a la porción de código que se ejecuta dentro de un procedimiento mediante las sentencias GoTo, GoSub y Return. Por esta razón, no se deben confundir los “procedimientos” con las “subrutinas” en Visual Basic. Aunque las subrutinas están disponibles, el analista debe evitar al máximo su uso, ya que estas rompen con la definición de Lenguaje Estructurado. En su lugar, se debe procurar la creación de procedimientos para esas secciones de código necesarias por otros procedimientos. La sentencia GoTo produce un salto incondicional a una etiqueta de línea, a partir de la cual continúa el control del programa. Por su parte, la sentencia GoSub también lleva el control del programa a una etiqueta de línea, pero mediante la sentencia Return, el control del programa puede regresar a la línea siguiente desde la cual se efectuó el llamado de la subrutina. A continuación se muestra un ejemplo del uso de subrutinas. En el ejemplo la instrucción GoTo Terminar es imprescindible, ya que las etiquetas de línea sólo son marcadores de posición y no 64

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

ejercen ningún control de programa, es decir, de ninguna manera especifican el fin del procedimiento. Más adelante veremos que la etiqueta “Terminar” y la instrucción “GoTo Terminar” se pueden reemplazar por la sentencia Exit Sub ( Exit Function), para salir del procedimiento. Private Sub cmdBotón_Click() 'Instrucciones GoSub SubRutina1 'Aquí retorna el control del programa 'Instrucciones GoSub SubRutina2 'Aquí retorna de nuevo el control del programa 'Instrucciones GoTo Terminar 'El control de programa nunca pasa por aquí SubRutina1: 'Instrucciones de SubRutina1 Return SubRutina2: 'Instrucciones de SubRutina2 Return Terminar: End Sub 4.4.2. Ventajas de los procedimientos El desarrollo de una aplicación implica el diseño y la estructuración de las tareas que debe efectuar la aplicación. Los procedimientos constituyen una herramienta que facilita este proceso, ya que resultan muy útiles para condensar las tareas repetitivas o compartidas, como cálculos utilizados frecuentemente, manipulación de texto y controles, y operaciones con bases de datos. Básicamente, los procedimientos ofrecen cinco ventajas al programador, las cuales se exponen a continuación. a) Organización del código: al dividir el programa en pequeños módulos, una sola línea de código del procedimiento principal le permite al programador ejecutar un conjunto de líneas de código del procedimiento al que llama, sin necesidad de llenar el procedimiento principal de líneas de código difíciles de interpretar y manipular. b) Simplifica problemas: un problema grande difícil de resolver se convierte en varios problemas pequeños, pero fáciles de resolver. c) Detección de fallas: Los procedimientos le permiten dividir los programas en unidades lógicas discretas, cada una de las cuales se puede depurar más fácilmente que un programa entero sin procedimientos. Para efectos de pruebas, cada procedimiento se puede ejecutar por separado. d) Código unitario: para las tareas que son comunes en varias secciones del programa no es necesario repetir el código, pues basta con crear un procedimiento general para esas tareas y llamar al procedimiento desde las distintas secciones del programa cada vez que sea requerido. e) Reutilización del código: Los procedimientos que se utilizan en un programa pueden actuar como bloques de construcción de otros programas, normalmente con pocas o ninguna modificación. 65

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

4.4.3. Clasificación de procedimientos Visual Basic tiene tres tipos de procedimientos: a) Procedimientos Sub: Se caracterizan porque no devuelven un valor, y se conocen simplemente como procedimientos. Existen dos tipos de procedimientos Sub.  Los procedimientos de evento, que se ejecutan como respuesta a un evento y están asociados a un objeto.  Los procedimientos generales, que son creados por el usuario y se les debe llamar específicamente desde un procedimiento de evento para su ejecución. Los procedimientos generales se crean para proveer algún servicio común a otros procedimientos. Es una buena estrategia de programación colocar las instrucciones comunes en un procedimiento distinto (un procedimiento general) y hacer que los procedimientos de evento lo llamen. Esto elimina la necesidad de duplicar código y también hace que la aplicación sea más fácil de mantener. b) Procedimientos Function: A diferencia de los procedimientos Sub, los procedimientos Function devuelven un valor y se les conoce como funciones. Las funciones pueden ser de dos tipos:  Las funciones intrínsecas, que están prediseñadas o provistas por el lenguaje como Sqr(), Cos(), Asc(), etc., las cuales devuelven el valor de raíz cuadrada, coseno, código ASCII, etc., respectivamente.  Las funciones simbólicas, creadas por el usuario cuando el lenguaje no provea una función específica o especial. Por ejemplo, se puede crear una función que calcule la longitud del cateto opuesto, o hipotenusa, de un triángulo rectángulo, dado el cateto adyacente y el ángulo. c) Procedimientos Property: Son procedimientos que pueden devolver y asignar valores, así como establecer referencias a objetos. Se conocen como procedimientos de propiedad y permiten ejecutar código cuando se establece o se obtiene el valor de una propiedad. Los procedimientos de propiedad permiten que un objeto proteja y valide sus propios datos (propiedades), y se usan mayormente a nivel de módulos de clase. Visual Basic proporciona tres tipos de procedimientos de propiedad:  Property Get, que devuelve el valor de una propiedad.  Property Let, que establece el valor de una propiedad.  Property Set, que establece el valor de una propiedad de objeto, es decir, una propiedad que contiene una referencia a un objeto. Cada uno de estos procedimientos de propiedad desempeña un papel concreto en la definición de una propiedad. La propiedad típica estará compuesta por una pareja de procedimientos de propiedad: Property Get para obtener el valor de la propiedad, y Property Let o Property Set para asignar un nuevo valor. La razón por la que hay dos formas de procedimientos de propiedad (Let y Set) para asignar un valor, es que Visual Basic permite la asignación de 66

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

referencias de objeto a variables de objeto previamente declaradas con una sintaxis especial: Dim cmd As Object Set cmd = New CommandButton 4.4.4. Alcance de procedimientos El alcance se refiere al ámbito donde el procedimiento está disponible. En cuanto a su alcance, hay dos tipos de procedimientos a) Procedimientos públicos b) Procedimientos privados Los procedimientos públicos están disponibles desde cualquier parte del código del programa; es decir, se pueden llamar desde cualquier módulo del programa., aunque el consumo de recursos es mayor. En cambio, los procedimientos privados sólo se pueden acceder desde el módulo donde fueron creados. Para definir un procedimiento público se utiliza la palabra reservada Public y para definir un procedimiento privado se utiliza la palabra reservada Private. Observación: Si no se especifica la palabra reservada (Public o Private), los procedimientos son públicos de forma predeterminada, lo que significa que se les puede llamar desde cualquier parte de la aplicación.

4.4.5. Trabajar con procedimientos En esta parte trataremos la sintaxis requerida para manipular procedimientos Sub y Function, ya sean públicos o privados. Veremos sólo los procedimientos generales y las funciones simbólicas, ya que los procedimientos de evento fueron tratados en la unidad 2 y las funciones intrínsecas no requieren de creación, ya que están provistas por el sistema. En la unidad 5 veremos con detalle algunas de las funciones del sistema. Los procedimientos de propiedad no se tratarán en esta guía de estudio. a) Sintaxis para la creación de procedimientos  Procedimiento tipo Sub privado (Procedimiento general privado) Private Sub NombreProcedimiento([parámetros]) '{Instrucciones} End Sub  Procedimiento tipo Sub público (Procedimiento general público) Public Sub NombreProcedimiento([parámetros]) '{Instrucciones} End Sub  Procedimiento tipo Function privado (Función simbólica privada) Private Function NombreFunción([parámetros]) As TipoDeDato '{Instrucciones} NombreFunción = ValorDevuelto End Sub

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

 Procedimiento tipo Function público (Función simbólica pública) Public Function NombreFunción([parámetros]) As TipoDeDato '{Instrucciones} NombreFunción = ValorDevuelto End Sub Como se explicó anteriormente, los procedimientos tipo Function, a diferencia de los procedimientos tipo Sub, devuelven un valor. Observe que, justo antes de terminar los procedimientos Function, se le asigna al nombre de la función el valor que esta devuelve. b) Llamar a procedimientos Una vez que se han creado los procedimientos, estos se pueden invocar, ejecutar efectuando un llamado al procedimiento por su nombre. Los procedimientos Function se utilizan como se utilizaría cualquier función del sistema, por ejemplo la función QBColor, que es del sistema, se invoca de la siguiente manera: Me.BackColor = QBColor(7)  En forma general, las funciones simbólicas se invocan como sigue: Variable = NombreFunción([Parámetros]) Respecto a los procedimientos tipo Sub, existen dos maneras de llamarlos.  Una forma es mediante la instrucción Call y el nombre del procedimiento. Call NombreProcedimiento([Parámetros])  Y otra forma es directamente escribiendo el nombre del procedimiento. NombreProcedimiento [Parámetros] Observación: De la forma directa, los parámetros no se colocan entre paréntesis. Recuerde:

Una vez que termina el procedimiento, el control del programa continúa en la línea de código siguiente a la que llamó al procedimiento.

c) Salir de procedimientos Hemos visto en las estructuras de control repetitivas, que no es necesario esperar a que termine el ciclo para salir de la estructura, ya que esta puede ser interrumpida mediante la sentencia Exit seguida del nombre de la estructura. Para salir de un ciclo For se utiliza Exit For, por ejemplo. Los procedimientos, como estructuras, también permiten su terminación sin necesidad de esperar alcanzar la línea de código donde se encuentra la sentencia End Sub o End Function. Esto se logra mediante las sentencias Exit Sub o Exit Function, según sea el caso. Private Sub NombreProcedimiento([Parámetros]) '{Instrucciones que se ejecutan} Exit Sub 'Termina el procedimiento '{Instrucciones que no se ejecutarán} End Sub 68

Visual Basic 6.0

Unidad 4.- Código de Visual Basic

d) Conservar el valor de las variables Ya se ha dicho que las variables locales son las que se declaran dentro de un procedimiento y que estas pueden ser individualmente volátiles o estáticas. Se puede hacer que todas las variables, declaradas dentro de un procedimiento, sean estáticas, simplemente anteponiendo a la declaración del procedimiento la palabra reservada Static como se muestra a continuación para un procedimiento tipo Sub. Static Private Sub NombreProcedimiento([Parámetros]) 'Declaración de variables volátiles '{Instrucciones} End Sub Aunque la declaración de las variables sea volátil, estas se convierten en estáticas para el procedimiento de ejemplo anterior. 4.4.6. Transferencia de parámetros En los ejemplos de sintaxis anteriores, hemos visto que se incluyen paréntesis () en la declaración de los procedimientos. Opcionalmente dentro de estos paréntesis se pueden colocar parámetros. Los parámetros o argumentos son variables, separadas por coma, que se utilizan para pasar o transferir valores útiles a los procedimientos cuando estos son llamados. Los valores de estas variables se pueden pasar por valor o por referencia. a) Transferencia por valor Cuando la variable se pasa por valor, se envía al procedimiento una copia de la variable y el procedimiento reserva un espacio de memoria nuevo, de tal manera que los cambios en el valor de la variable nueva no afectan el valor de la variable original de la línea de código donde se efectuó la llamada. Para pasar variables por valor se utiliza la palabra reservada ByVal en la declaración de parámetros. Sub NombreProcedimiento (ByVal dato1 As tipo) '{Instrucciones} End Sub b) Transferencia por referencia Al pasar un argumento por referencia, tanto la variable del procedimiento, como la variable original, comparten el mismo espacio de memoria; por esta razón, al cambiar el valor de la variable dentro del procedimiento, la variable original de la línea de código desde donde se hizo el llamado, adopta el nuevo valor. Para pasar variables por valor se utiliza la palabra reservada ByRef. Sub NombreProcedimiento (ByRef dato2 As tipo) '{Instrucciones} End Sub En el ejemplo de sintaxis, “dato1” es el nombre de una variable nueva, y “dato2” es la misma variable de la instrucción llamadora, sólo que con otro nombre. Por defecto, si no se usa la palabra reservada (ByVal o ByRef), todos los datos se envían por referencia. En el siguiente ejemplo, “dato2” se transfiere por referencia. 69

Visual Basic 6.0

Unidad 4.- C贸digo de Visual Basic

Sub NombreProcedimiento (dato2 As tipo) '{Instrucciones} End Sub El siguiente ejemplo muestra como funciona la transferencia de par谩metros: Private Sub Dim X As X=5: Y=7 Duplicar 'X sigue End Sub

Bot贸n_Click() Integer, Dim Y As Integer X, Y 'Llama al procedimiento con 5 y 7 siendo igual a 5, pero Y cambia a 14

Sub Duplicar(ByVal D1 As Integer, ByRef D2 As Integer) 'D1 se carga con 5 y D2 con 7 D1 = D1 * 2 'D1 cambia a 10 de 5*2=10 D2 = D2 * 2 'D2 cambia a 14 de 7*2=14 End Sub 'Retorna a Bot贸n_Click 4.4.7. Ejemplo completo de la unidad

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

Unidad 5 Funciones intrínsecas “El entusiasmo es la madre del esfuerzo, y sin este nunca se logró nada importante” .- Emerson

5.1. Funciones en general 5.1.1. Expresiones La expresión se define como cualquier combinación de variables, constantes, operadores, funciones y nombres de campos, controles y propiedades que se evalúa como un único valor. La evaluación consiste en la asignación de un valor a un espacio de memoria, es decir a una variable. Así, una instrucción de asignación es una expresión. Me.txtPeso.Text = Me.txtMasa.Text * 10 5.1.2. Funciones Una función es un cálculo preprogramado que se puede realizar bajo petición desde cualquier lugar de un programa. Puesto que una función adopta uno o más argumentos y devuelve un único valor, esta se puede incluir en una expresión. Por ejemplo, se puede definir la función Licuar que permite el uso de una licuadora para múltiples aplicaciones. Para preparar una Merengada fría, se debe escribir la siguiente expresión: Merengada = Hielo + Licuar(Leche, Fruta, Azúcar, Vainilla) Leche Fruta Azúcar Vainilla

Licuar

Merengada caliente

Figura 5.1.- Función supuesta Licuar

Observe que la función Licuar no devuelve Merengada fría y se debe agregar Hielo en una expresión completa. La merengada obtenida dependerá del tipo e fruta, y cantidades de leche, azúcar y vainilla. Se dice que estos últimos son las variables independientes de la función, mientras que la merengada es la variable dependiente. En general todas las funciones se caracterizan por una serie de valores de entrada conocidos como argumentos o variables independientes, y sólo un valor de salida conocido como resultado o variable dependiente.

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

A B

Función

Y=Función(A, B, …, C)

C Figura 5.2.- Función en general

Por ejemplo, “y = Sin(x)” es una expresión formada por la función “Sin”, un argumento “x” como valor de un ángulo, y el resultado (cálculo del seno de “x”) es asignado a “y”. x

Sin

y Figura 5.3.- Función Seno.

Para facilitar el estudio de las funciones, estás se han clasificado según su relación con cadenas, números, fechas, objetos o archivos. 5.1.3. Instrucciones Mientras que las funciones son operaciones sobre ciertos argumentos para obtener o devolver un valor, las instrucciones consisten en órdenes para el sistema, y no devuelven valor alguno. Las instrucciones prescinden del par de paréntesis que caracterizan a todas las funciones. Podríamos comparar a las instrucciones con procedimientos Sub intrínsecos del sistema. Según el ejemplo, la función Licuar también podría utilizarse como una instrucción, en lugar que como una función, y en este caso no existe devolución de un valor, sino que se ejecuta una orden y se prescinde del par de paréntesis como se muestra a continuación: Reunir ingredientes Licuar Leche, Fruta, Azúcar, Vainilla Agregar Hielo En Visual Basic existen muchas funciones que se pueden utilizar como instrucciones. El término “instrucciones” ha sido utilizado en capítulos anteriores para hacer referencia a líneas de código, y en su lugar se ha utilizado el término “sentencias”. Las instrucciones también se conocen como sentencias o comandos. 5.2. Funciones de cadena 5.2.1. Tratamiento de cadenas Para el estudio de las funciones que admiten como argumento, o devuelven como valor, cadenas de caracteres, es necesario conocer lo siguiente: a) Las cadenas de caracteres se declaran tipo String. Por ejemplo, declaremos la variable Cadena como una cadena de longitud variable. Dim Cadena As String b) Los valores de cadenas de caracteres se delimitan mediante “comillas dobles”. Por ejemplo, asignemos a la variable Cadena el valor “Visual Basic”. Cadena = “Visual Basic”

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

c) Cada caracter ocupa una posición comenzando desde la izquierda de la cadena. Por ejemplo, en la posición 8 de la variable Cadena se encuentra el caracter “B”. V

9 10 11 12

Figura 5.4.- Posiciones de una cadena de caracteres

d) La longitud de una cadena es la cantidad de caracteres de la cadena. Por ejemplo, la variable Cadena tiene una longitud de 12 caracteres. Observe que el “espacio” entre las palabras, se cuenta como un caracter que ocupa la posición 7. e) Las variables declaradas como cadenas de longitud fija truncan los caracteres sobrantes a la derecha, o rellenan con espacios en blanco, para completar la cantidad de caracteres especificados. Dim K As String * 5 K = “Visual Basic” K = “Pan”

'K se carga con “Visua” (5 caract.) 'K rellena con 2 espacios “Pan ”

5.2.2. Cambiar a mayúsculas y minúsculas Para convertir todos los caracteres de una cadena a mayúsculas o minúsculas se usa UCase o LCase respectivamente. Por ejemplo, la siguiente instrucción presenta en la caja de texto txtCadena la palabra “VISUAL BASIC” Me.txtCadena.Text = UCase(Cadena) Mientras que la siguiente instrucción presenta la palabra “visual basic” Me.txtCadena.Text = LCase(Cadena) 5.2.3. Determinar la longitud de una cadena Se puede determinar la cantidad de caracteres contenidos en una cadena, incluyendo los espacios, mediante la función Len. La siguiente instrucción presenta en la caja de texto txtCadena el valor 8. Me.txtNúmero.Text = Len(Cadena) 5.2.4. Buscar caracteres dentro de una cadena Para determinar la posición de caracteres dentro de una cadena se usa InStr. La sintaxis general se muestra a continuación. InStr([Inicio, ]Cadena, Buscado) “Inicio” es un entero opcional que representa la posición inicial de búsqueda, y si se obvia la búsqueda comienza desde la posición 1. “Cadena” es la cadena examinada, y “Buscado” son los caracteres buscados. Si los caracteres buscados no se encuentran en la cadena, InStr devuelve el valor 0. Vea los ejemplos siguientes: Buscar la posición de “Ba” en la variable Cadena. Recuerde que Cadena = “Visual Basic”. Se presenta el valor 8 en la caja de texto. 73

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

Me.txtNúmero.Text = InStr(Cadena, “Ba”) Buscar la posición de “es” en Cadena. Se presenta el valor 0 en la caja de texto, indicando que no encontró la secuencia “es”. Me.txtNúmero.Text = InStr(Cadena, “es”) Buscar la posición de “a” en Cadena. Devuelve el valor 5 en la caja de texto. Me.txtNúmero.Text = InStr(Cadena, “a”) Buscar la posición de “a” en Cadena, pero desde la posición 6. En este caso, devuelve el valor 9 en la caja de texto. Me.txtNúmero.Text = InStr(6, Cadena, “a”) 5.2.5. Extraer e insertar caracteres a una cadena Se pueden extraer tantos caracteres como desee del principio de la cadena, del final de la cadena o de cualquier parte de la cadena, utilizando respectivamente las funciones: Left, Right y Mid. La sintaxis general se muestra a continuación. Left(Cadena, Longitud) Right(Cadena, Longitud) Mid(Cadena, Inicio, Longitud) “Longitud” es un entero que define el número de caracteres que se extraerán, e “Inicio” es la posición inicial de extracción dentro de la cadena. Veamos los siguientes ejemplos: Extraer los primeros seis caracteres a la izquierda de Cadena. Me.txtCadena.Text = Left(Cadena, 6)

'Devuelve “Visual”

Extraer los últimos cinco caracteres a la derecha de Cadena. Me.txtCadena.Text = Right(Cadena, 5) 'Devuelve “Basic” Extraer los siete caracteres centrales de Cadena desde la posición 3. Me.txtCadena.Text = Mid(Cadena, 3, 7)'Devuelve “sual Ba” Para insertar caracteres en una cadena se usa la función Mid de la siguiente manera: Mid(Cadena, 8, 6) = “Studio” Me.txtCadena.Text = Cadena 'Devuelve “Visual Studio” Se lee como asignar a la variable Cadena los 6 caracteres de “Studio” desde la posición 8. Así, la variable Cadena que contenía el valor “Visual Basic”, adopta como nuevo valor “Visual Studio”, debido a la inserción, desde la posición ocho, de los seis caracteres “Studio”. 5.2.6. Tratamiento de espacios en blanco En algunos casos, nos podemos encontrar con cadenas que contienen espacios en blanco innecesarios. Para eliminar los espacios al principio de la una cadena, se 74

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

usa Ltrim, para eliminar al final de la cadena se usa Rtrim, y para eliminar cualquier espacio al principio y al final de la cadena, se usa simplemente Trim. En el siguiente ejemplo se muestran estos tres casos: Cadena = “ Visual Basic ” txtCadena.Text = Ltrim(Cadena) 'Devuelve “Visual Basic ” txtCadena.Text = Rtrim(Cadena) 'Devuelve “ Visual Basic” txtCadena.Text = Trim(Cadena) 'Devuelve “Visual Basic” Observe:

No se eliminan los espacios intermedios; es decir, la separación entre palabras de una frase.

Respecto a espacios en blanco, también existe la función Space, la cual permite crear cadenas de caracteres con sólo espacios en blanco. En el siguiente ejemplo se crea una cadena de 7 espacios en blanco: txtCadena.Text = Space(7) 5.2.7. Convertir a número y a cadena Una cadena se puede convertir a número usando Val, y un número se puede convertir a cadena de caracteres usando Str. La función Str agrega un espacio en blanco al principio de la cadena. La función Val devuelve cero si su argumento es no numérico. Dim Número As Single Dim Cadena As String Número = 10.24 Cadena = Str(Número) Número = Val(Cadena) Cadena = “A” Número = Val(Cadena)

'Devuelve la cadena “ 10.24” 'Devuelve el número 10,24 'Devuelve el número 0

5.2.8. Obtener cadenas de caracteres con formato La función Format permite controlar la forma en que aparecerán los resultados numéricos, de fecha o de carácter. La sintaxis general es la siguiente: Format(Número|Fecha|Cadena, Formato) Esta función acepta números, fechas o cadenas de caracteres. El parámetro “Formato” permite definir la forma en que se devuelve el resultado de texto, y puede ser una constante de Visual Basic o un conjunto de caracteres especiales. a) Formatos numéricos: para la presentación de valores numéricos se pueden utilizar constantes intrínsecas (ver Tabla 5.1) o símbolos especiales (ver Tabla 5.2) para definir el formato. Constante General Number Currency Fixed Standard Percent

Descripción del formato El número tal y como es, sin separadores de millar. Separador de millar; muestra dos dígitos a la derecha del separador decimal. Al menos un dígito a la izquierda y dos dígitos a la derecha del separador decimal. Separador de millar, al menos un dígito a la izquierda y dos a la derecha del separador decimal. El número multiplicado por 100 con un signo de porcentaje (%) a la derecha. 75

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

Constante Scientific Yes/No True/False On/Off

Descripción del formato Utiliza la notación científica estándar. Muestra No si el número es 0; de lo contrario, muestra Yes. Muestra False si el número es 0; de lo contrario, muestra True. Muestra Off si el número es 0; de lo contrario, muestra On.

Símbolo

Descripción del formato Muestra 0 así no exista dígito en esa posición Muestra el dígito sólo si existe en una posición Lugar donde aparecerá coma decimal. Lugar donde aparecerá separado de miles. Multiplica por 100 el número y muestra el símbolo %. Muestra el número en notación científica.

Tabla 5.1.- Constantes de formato para números

0 # , . % E-,E+

Tabla 5.2.- Símbolos especiales de formato para números

Veamos los siguientes ejemplos: Cadena Cadena Cadena Cadena Cadena Cadena Cadena Cadena

= = = = = = = =

Format(1980.326, Format(1980.326, Format(1980.326, Format(1980.326, Format(1980.326, Format(1980.326, Format(1980.326, Format(1980.326,

“Fixed”) “Standar”) “Percent”) “Yes/No”) “00000”) “#.000.#”) “#.0”) “#%”)

'Devuelve 'Devuelve 'Devuelve 'Devuelve 'Devuelve 'Devuelve 'Devuelve 'Devuelve

“1980,33” “1.980,33” “198032,6%” “Sí” “01980” “1.980,3” “980,3” “198033%”

b) Formatos de fecha: al igual que para valores numéricos, Visual Basic provee constantes intrínsecas (ver Tabla 5.3) y símbolos especiales (ver Tabla 5.4) para la presentación de valores de fecha y hora. Constante General Date Long Date Médium Date Short Date Long Time Médium Time Short Time

Descripción Muestra la fecha y hora si están disponibles en la expresión. Muestra día de la semana, día del mes, el mes y el año. Muestra día del mes, el mes en tres letras y el año. Muestra día del mes, el mes y el año Muestra la hora, minutos y segundos con indicación AM/PM Muestra la hora y minutos con indicación AM/PM Sólo muestra hora y minutos Tabla 5.3.- Constantes de formato para fechas y horas

Símbolo : / “d” “dd” “ddd” “dddd” “w” “ww” “m” “mm” “mmm” “mmmm” “q” “y” “yy” “yyyy”

Descripción Separador de hora, minutos y segundos Separador de día, mes y año. Día del mes 1-31 Día del mes 01-31 Día de la semana Dom-Sáb Día de la semana Domingo-Sábado Día de la semana 1-7 (Dom = 1) Semana del año 1-54 Mes del año 1-12 Mes del año 01-12 Mes del año Ene-Dic Mes del año Enero-Diciembre Cuatrimestre del año 1-4 Día del año 1-366 Año en dos dígitos 00-99 Año en cuatro dígitos 0100-9999 76

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

Símbolo “h” “hh” “n” “nn” “s” “ss” “AM/PM” “am/pm”

Descripción Hora del día 0-23 Hora del día 00-23 Minuto de la hora 0-59 Minuto de la hora 00-59 Segundo transcurrido 0-59 Segundo transcurrido 00-59 Muestra AM o PM según corresponda Muestra am o pm según corresponda Tabla 5.4.- Símbolos para crear formatos de fecha y hora

Veamos los ejemplos siguientes: Cadena Cadena Cadena Cadena Cadena Cadena Cadena Cadena

= = = = = = = =

Format(#7/5/00#, “Médium Date”) Format(#7/5/00#, “Short Date”) Format(#7/5/72#, “ddd/mm/yyyy”) Format(#20:05:12#, “Médium Time”) Format(#20:05:12#, “Long Time”) Format(#20:05:12#, “HH:nn”) Format(#20:05:12#, “HH:n”) Format(#20:05:12#, “HH:n:s”)

'“07/May/2003” '“07/05/03” '“Dom/05/1972” '“08:05 PM” '“08:05:54 PM” '“20:05” '“20:5” '“20:5:12”

c) Formatos de cadena: mediante los cuales la función Format se puede usar para la presentación de mayúsculas y minúsculas según los caracteres especiales “>” y “<” sin necesidad de cambiar el valor de la cadena de caracteres mediante las funciones UCase y LCase. Format no tiene funciones de conversión, es sólo para presentación. Cadena = Format(“Simón Bolívar”, “>”) Cadena = Format(“Simón Bolívar”, “<”)

'“SIMÓN BOLÍVAR” '“simón bolívar”

5.2.9. Mapa de caracteres Para obtener el código ASCII de un carácter, se usa la función Asc. Para obtener el carácter dado un código ASCII se usa la función Chr. En el código ASCII (ver Tabla 5.5) a cada valor numérico le corresponde un caracter. El símbolo • indica que Windows no lo admite para la mayoría de las fuentes predefinidas. La función Chr de códigos ASCII 8, 9, 10 y 13 no devuelve caracter, sino que se traducen en borrado hacia atrás, tabulación, avance de línea y retorno de carro, respectivamente. Asc 0 1 2 3 4 5 6 7 8 9 10 11 12

Chr Nulo • • • • • • • [BACKSPAC E] [TAB] [AV. LINE] • •

Asc 32 33 34 35 36 37 38 39

Chr [SPACE] ! " # $ % & '

Asc 64 65 66 67 68 69 70 71

Chr @ A B C D E F G

Asc 96 97 98 99 100 101 102 103

Chr ` a b c d e f g

(

104

41 42 43 44

) * + ,

73 74 75 76

I J K L

105 106 107 108

i j k l

Visual Basic 6.0

Asc 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

Unidad 5.- Funciones del intrínseca

Chr [ENTER] • • • • • • • • • • • • • • • • • •

Asc 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

Chr . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?

Asc 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

Chr M N O P Q R S T U V W X Y Z [ \ ] ^ _

Asc 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

Chr m n o p q r s t u v w x y z { | } ~ •

Tabla 5.5.- Juego de caracteres ASCII de 0 a 127

5.3. Funciones numéricas 5.3.1. Funciones matemáticas Visual Basic provee todas las funciones necesarias para cálculos directos o para la construcción de otras funciones matemáticas (ver Tabla 5.6). Función Sgn(número) Log(número) Exp(número) Sqr(número) Atn(número) Cos(ángulo) Sin(ángulo) Tan(ángulo) Abs(número)

Descripción Signo de un número Logaritmo natural de un número Potencia neperiana “e” Raíz cuadrada de un número Trigonometría Arco tangente de un triángulo Trigonometría Coseno del un ángulo en radianes Trigonometría Seno de un ángulo en radianes Trigonometría Tangente de un ángulo en radianes Valor absoluto de un número Tabla 5.6.- Funciones matemáticas

5.3.2. Funciones de ajuste decimal Mientras que las funciones Fix e Int devuelven la parte entera de un número, la función Round redondea a una cantidad de decimales. La función Fix trunca la parte decimal de un número de manera indistinta. Para valores negativos la función Int ajusta al valor entero inmediato superior. Para valores positivos Fix e Int operan de la misma manera. Función Fix(número) Int(número) Round(número, n)

Devuelve Parte entera superior negativa de un número Parte entera inferior negativa de un número Número redondeado de un número con n decimales Tabla 5.7.- Funciones de ajuste numérico

Veamos los siguientes ejemplos: 78

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

Número Número Número Número Número Número Número Número Número Número Número Número Número

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

Fix(99,8) Fix(-99,8) Fix(-99,2) Int(99,8) Int(-99,8) Int(-99,2) Round(99.8,0) Round(-99.8,0) Round(-99.2,0) Round(99.56,0) Round(99.56,1) Round(99.56,2) Round(99.56,3)

'Devuelve 99 'Devuelve -99 'Devuelve -99 'Devuelve 99 'Devuelve -100 'Devuelve -100 'Devuelve 100 'Devuelve -100 'Devuelve -99 'Devuelve 100 'Devuelve 99.6 'Devuelve 99.56 'Devuelve 99.560

5.3.3. Función de número aleatorio La función Rnd devuelve un número aleatorio menor que 1, pero mayor o igual a cero. Rnd se usa en conjunción con la instrucción Randomize, la cual inicializa el generador de números aleatorios para devolver valores entre 0 y 1. Para obtener un rango de números aleatorios enteros entre un límite Inferior y Superior se puede aplicar la siguiente fórmula o procedimiento: Randomize 'Instrucción que inicializa Rnd Aleatorio = Int((Superior-Inferior + 1)*Rnd + Inferior) 5.4. Funciones de fecha y hora 5.4.1. Obtener la fecha y hora del sistema La función Date devuelve la fecha del sistema, Time devuelve la hora y Now devuelve tanto la fecha como la hora del sistema. A menudo se utiliza el evento del control Timer para mostrar fechas y horas. En el ejemplo siguiente suponga que la fecha del sistema es 12 de octubre del año 2000 y son las 6:45 pm. Private Sub Timer1_Timer() lblFecha.Caption = Date 'Devuelve #12/10/2000# lblHora.Caption = Time 'Devuelve #18:45:00# lblHoy.Caption = Now 'Devuelve #12/10/2000 18:45:00# End Sub En combinación con la función Format se pueden establecer los campos de fecha y hora que se desean visualizar. 5.4.2. Establecer la fecha y hora del sistema Para establecer la fecha y hora del sistema se utilizan Date y Time como instrucciones. Date = #12/10/2003# Time = #18:10:00# 5.4.3. Realizar cálculos con fechas y horas a) Calcular una fecha dado un intervalo de tiempo 79

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

Se pueden calcular fechas futuras o pasadas a una fecha de referencia, agregando o sustrayendo intervalos de tiempo en días, meses, años, horas, segundos, etc., a la fecha de referencia. Cuando utilizamos el término “fechas”, nos referimos a instantes de tiempo; o sea, pueden ser desde segundos hasta años. Para obtener una fecha dado un intervalo de tiempo, se usa la función DateAdd: FechaFutura = DateAdd(Intervalo, Número, FechaRef) FechaPasada = DateAdd(Intervalo,-Número, FechaRef) El argumento “Intervalo” es una cadena de caracteres que indica el tipo de intervalo de tiempo para el cálculo (ver Tabla 5.8); es decir, si el cálculo se efectúa en días, meses, horas, etc. Intervalo Yyyy Q M Y D W Ww H N S

Descripción Cálculo en Años Cálculo en Trimestres Cálculo en Meses Cálculo en Días Cálculo en Días Cálculo de Días de la semana Cálculo en Semanas Cálculo en Horas Cálculo en Minutos Cálculo en Segundos Tabla 5.8.- Valores del parámetro Intervalo de funciones de fecha y hora

El argumento “Número” es un número entero que representa el número de intervalos de tiempo seleccionado con “Intervalo”. Por ejemplo, para calcular la fecha de vencimiento de facturas a treinta días, se puede escribir el código: Dim Fecha As Date Fecha = FechaDeFactura FechaVencimineto = DateAdd(“d”, 30, Fecha) Para conocer fechas pasadas, suponga que desea conocer la fecha de una mercancía la cual tiene 10 meses en almacén: FechaArribo = DateAdd(“m”, -10, Date) Observe que se recurre a la función Date para obtener la fecha actual del sistema, y así utilizarla como argumento. b) Calcular el intervalo de tiempo entre dos fechas Este tipo de cálculo es muy útil para determinar la duración, el retardo o la cantidad de tiempo transcurrido entre dos fechas u horas. Para este efecto se usa la función DateDiff: Duración = DateDiff(Intervalo, Anterior, Posterior) El parámetro “Intervalo” se regirá por la tabla 5.8 ya que también es una cadena de caracteres que indica el tipo de intervalo de tiempo. El argumento “Anterior” es un literal de fecha correspondiente a un momento anterior al valor de fecha del argumento “Posterior”. Si el argumento “Anterior” corresponde a un momento posterior, la función DateDiff devuelve un número 80

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

negativo y no se produce error. Por ejemplo, para calcular la cantidad de días de vida, se puede usar la siguiente línea de código: Días = DateDiff(“d”, FechaNacimiento, Date) La variable “FechaNacimiento” contiene la fecha de nacimiento, y Date es la función vista anteriormente que devuelve la fecha actual del sistema. Veamos otros ejemplos, donde se define la variable D como entero y se aplica la función DateDiff a fechas establecidas: Dim D = D = D = D = D =

D As Integer DateDiff(“yyyy”, #31/12/1999#, #31/12/2000#) DateDiff(“m”, #31/12/1999#, #31/12/2000#) DateDiff(“w”, #31/12/1999#, #31/12/2000#) DateDiff(“ww”, #31/12/1999#, #31/12/2000#) DateDiff(“d”, #31/12/1999#, #31/12/2000#)

'1 año '12 meses '52 días '53 sem. '366 días

Observación: A diferencia de la función DateAdd, que devuelve una fecha, DateDiff devuelve un número entero.

c) Calcular parte de una fecha En algunos casos es necesario conocer el valor numérico de sólo parte de una fecha. Utilizando la función DatePart se puede calcular el número del día, mes, año, trimestre o semana de una fecha, según el valor del argumento “Intervalo”: ParteDeFecha = DatePart(Intervalo, Fecha) Veamos los siguientes ejemplos, donde una vez más se ha definido la variable D como entero para albergar el resultado de DatePart: Dim D = D = D = D = D =

D As Integer DatePart(“yyyy”, #31/12/1999#) DatePart(“m”, #31/12/1999#) DatePart(“w”, #31/12/1999#) DatePart(“ww”, #31/12/1999#) DatePart(“d”, #31/12/1999#)

'Devuelve 'Devuelve 'Devuelve 'Devuelve 'Devuelve

1999 12 6 (viernes) 53 31

Además de DatePart, Visual Basic dispone de un conjunto de funciones destinadas a obtener parte de una fecha u hora, sin necesidad del parámetro Intervalo. Estas funciones se detallan en la tabla siguiente: Función Year(fecha) Month(fecha) Day(fecha) WeekDay(fecha) Hour(hora) Minute(hora) Second(hora) WeekDayName(fecha)

Devuelve la parte de fecha Año de 100 a 9999 Mes de 1 a 12 Día de 1 a 31 Día de 1 a 7 Hora de 0 a 23 Minuto de 0 a 59 Segundo de 0 a 59 Día de Lunes a Domingo Tabla 5.9.- Funciones que devuelven parte de una fecha

Visual Basic 6.0

5.4.4.

Unidad 5.- Funciones del intrínseca

Devolver fechas y horas

Existen funciones para convertir números o cadenas en fechas. Las funciones DateSerial y TimeSerial conforman una fecha a partir de valores numéricos enteros correspondientes a día, mes, año, hora, minuto y segundo. Fecha = DateSerial(Día, Mes, Año) Hora = TimeSerial(Hora, Min, Seg) Por su parte, las funciones DateValue y TimeValue convierten una cadena con formato de fecha y hora a un tipo de dato Date. Fecha = DateValue(Cadena) Hora = TimeValue(Cadena) Veamos los ejemplos: Dim Fecha As Date, Hora As Date Fecha = DateSerial(12, 10, 3) Fecha = DateValue(“12/10/2003”) Hora = TimeSerial(12, 10, 3) Hora = TimeValue(“12:10:3”)

'Devuelve 'Devuelve 'Devuelve 'Devuelve

#12/10/2003# #12/10/2003# #12:10:03# #12:10:03#

5.4.5. Cronometrar procesos Los procesos en Visual Basic se pueden cronometrar utilizando una función que devuelve el número de segundos del sistema transcurridos desde la medianoche. Esta función se llama Timer y se utiliza según la siguiente estructura: Dim Inicio, Fin As Long Dim DuraciónDelProceso As Integer Inicio = Timer {Proceso} Fin = Timer DuraciónDelProceso = Fin – Inicio La función Timer también suele usarse para hacer una pausa temporal en la secuencia del programa. Para este caso es imperante utilizar la instrucción DoEvents, mediante la cual, durante la pausa causada en un ciclo, el programa no acapara los recursos del sistema. Veamos esto con un ejemplo donde se crea un retardo de 20 segundos. Dim Inicio As Long Inicio = Timer Do While Timer < (Inicio + 20) DoEvents Loop 5.5. Funciones de Objetos 5.5.1. Cuadro de diálogo de entrada InputBox La función InputBox presenta un cuadro de diálogo (ver Figura 5.5) con una leyenda, dos botones de comando (Aceptar, Cancelar) y una Caja de texto. Si el usuario hace clic en el botón Aceptar, la función devuelve el contenido de la Caja de Texto como un valor tipo cadena, y si el usuario hace clic sobre el botón 82

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

Cancelar, la función devuelve una cadena vacía (“”). La sintaxis general es la siguiente: InputBox(Leyenda, Título, Texto, X, Y)

Figura 5.5.- Cuadro de diálogo InputBox

Los argumentos “X” y “Y” especifican la posición en la que aparecerá el cuadro de diálogo. “X” y “Y” son opcionales, y si no se especifican, el cuadro de diálogo aparece en el centro de la pantalla. El parámetro “Texto” también es opcional y por lo general no se coloca, ya que se supone que la caja de texto es para que el usuario escriba los datos a procesar por la aplicación. 5.5.2. Cuadro de diálogo de mensajes MsgBox La función MsgBox permite mostrar un cuadro de diálogo con un mensaje específico y puede devolver valores tipo Integer de acuerdo a su configuración y al botón que reciba el clic del usuario. La sintaxis general es la siguiente: MsgBox(Mensaje, Botones, Título) Se puede utilizar MsgBox como instrucción cuando no se espera valor de retorno: MsgBox Mensaje, Botones, Título

Figura 5.6.- Cuadro de diálogo MsgBox

El argumento “Botones” es el resultado de una suma binaria de enteros que definen la cantidad y tipo de botones del cuadro de diálogo, así como también el icono a mostrar. Los posibles valores que se pueden asignar al parámetro “Botones”, están disponibles en forma de constantes intrínsecas (ver Tabla 5.10). Constante VbOKOnly VbOKCancel VbAbortRetryIgnore VbYesNoCancel VbYesNo VbRetryCancel VbCritical

Valor 0 1 2 3 4 5 16

Descripción Muestra solamente el botón Aceptar. Muestra los botones Aceptar y Cancelar. Botones Anular, Reintentar e Ignorar. Muestra a los botones Sí, No y Cancelar. Muestra a los botones Sí y No. Muestra a los botones Reintentar y Cancelar. Muestra el icono de mensaje crítico. 83

Visual Basic 6.0

Constante VbQuestion VbExclamation VbInformation

Unidad 5.- Funciones del intrínseca

Valor 32 48 64

Descripción Muestra el icono de pregunta de advertencia. Muestra el icono de mensaje de advertencia. Muestra el icono de mensaje de información. Tabla 5.10.- Estilos de cajas de mensajes MsgBox

A continuación veremos algunos ejemplos de cuadros de mensajes con diferentes estilos, como resultado de su respectiva línea de código. a) Mensaje de información para sólo aceptar MsgBox "Ejemplo 1", vbInformation, "Información..."

Figura 5.7.- Cuadro de mensaje de Información

b) Mensaje crítico para sólo aceptar MsgBox "Ejemplo 2", vbCritical, "Crítico..."

Figura 5.8.- Cuadro de mensaje de Crítico

c) Mensaje de exclamación para sólo aceptar MsgBox "Ejemplo 3", vbExclamation, "Exclamación..."

Figura 5.9.- Cuadro de mensaje de Exclamación

d) Mensaje de pregunta para sólo aceptar MsgBox "Ejemplo 4", vbQuestion, "Pregunta..."

Visual Basic 6.0

Unidad 5.- Funciones del intrínseca

Figura 5.10.-Cuadro de mensaje de Pregunta

e) Mensaje sin icono para Si o No MsgBox "Ejemplo 5", vbYesNo, "Si y No..."

Figura 5.11.-Cuadro de mensaje Si y No

Mensaje sin icono para Aceptar o Cancelar MsgBox "Ejemplo 6", vbOkCancel, "Aceptar y Cancelar..."

Figura 5.12.-Cuadro de mensaje Aceptar y Cancelar

g) Mensaje con icono para Aceptar o Cancelar MsgBox "Ejemplo 7", vbOkCancel + vbCritical, "Aceptar y_ Cancelar, Crítico..."

Figura 5.13.-Cuadro de mensaje Crítico Aceptar y Cancelar

Por otra parte, el cuadro de mensaje como toda función devuelve valores. Los valores devueltos por un cuadro de mensaje se detallan en la Tabla 5.11. Constante vbOK vbCancel vbAbort vbRetry

Valor 1 2 3 4

Si se hace clic en el botón Aceptar Cancelar Anular Reintentar 85

Visual Basic 6.0

Constante vbIgnore vbYes vbNo

Unidad 5.- Funciones del intrínseca

Valor 5 6 7

Si se hace clic en el botón Ignorar Sí No Tabla 5.11.- Valores devueltos por MsgBox

Por ejemplo, se puede preguntar al usuario, antes de cerrar una ventana, si realmente desea cerrar la ventana: Private Sub Form_QueryUnload(Cancel As Integer, UnloadM…) If MsgBox("Cerrar...?", vbYesNo)=vbNo Then Cancel=1 End Sub

Visual Basic 6.0

Unidad 6.- Archivos

Unidad 6 Archivos “El secreto del éxito es la constancia en el propósito” .- Disraeli

6.1. Nociones básicas 6.1.1. Unidades Como es de nuestro conocimiento, los sistemas de cómputo incluyen en su arquitectura unidades de almacenamiento o memorias donde se albergan los unos y ceros que representan instrucciones o datos para el microprocesador. Las memorias se clasifican en memorias primarias y memorias secundarias, de acuerdo a la forma de conexión con la unidad central de procesamiento (CPU) o microprocesador. Las memorias primarias corresponden a los circuitos integrados ROM y RAM en sus diferentes versiones que se conectan al CPU a través de los buses internos impresos en la placa o tarjeta madre. Las memorias ROM contienen programas y tablas de datos esenciales para la operación general del sistema, y no es posible escribir en ellas. A diferencia de las ROM, las memorias RAM permiten ser escritas de parte del usuario con la información que actualmente desea procese la CPU, pero con la gran desventaja que el almacenamiento es volátil; es decir, la información se pierde sino se mantiene energizado al equipo. De esta manera surgen las unidades de almacenamiento secundario, las cuales se encuentra fuera de la placa base, se pueden escribir de parte del usuario, y no requieren de energía para mantener la información. Dentro de esta categoría se encuentran la unidades de disco magnéticas, ya sean flexibles (por lo general las unidades A y B de 3½ pulgadas) o rígidas (por lo general el disco duro C). También se incluyen las unidades de disco lógicas o de red (H, J, K,…), las unidades de disco óptico (D, E) y las unidades de chip de memoria portátil. En la Unidad 4, objetivo 4.1 tratamos el tema de administración de la memoria primaria RAM; y a continuación conoceremos sobre la administración de la memoria secundaria para el almacenamiento de información permanente o no volátil; de allí su importancia.

Visual Basic 6.0

Unidad 6.- Archivos

Figura 6.1.- Memorias de un sistema de cómputo

6.1.2. Archivos Los archivos se pueden definir como un conjunto de bytes relacionados mediante un identificador y almacenados en una unidad de disco. El sistema operativo define la estructura mediante la cual los archivos son etiquetados, almacenados y organizados en el disco, para lo cual crea y mantiene en cada unidad de disco a su disposición, una tabla de asignación de archivos conocida como FAT (File Allocation Table), que actúa como un índice si la unidad fuera un libro. La FAT es una tabla que contiene el estatus de varios segmentos, de espacio de disco, usados para el almacenamiento de archivos. Cada vez que se copian, borran o modifican archivos, la FAT es actualizada automáticamente por el sistema operativo. En las nuevas versiones de Windows la FAT se ha reemplazado por estructuras más eficientes como FAT32 y NTSF. Los archivos son decodificados o interpretados por otros archivos con instrucciones llamados programas, para lo cual se requiere transferir o copiar la información del archivo desde la memoria secundaria hasta la memoria primaria RAM. La acción de abrir un archivo consiste en crear una copia del archivo en memoria RAM para su manipulación directa de parte del microprocesador. Al cerrar un archivo se libera toda traza del mismo de la memoria RAM, pero la memoria secundaria permanece intacta si no se guardan los cambios. Si se toma la previsión de guardar los cambios, los cuales se efectúan en memoria RAM, la información es actualizada, transferida o copiada a la unidad de disco correspondiente.

101111010 101111010 101000011 100110111 101111111 100111010 010011111

Visual Basic permite manipular tres tipos de archivos según el modo de acceso: secuencial, aleatorio y binario. Los archivos secuenciales, carecen de estructura y deben ser recorridos en su totalidad para acceder a un dato intermedio. Los archivos aleatorios se organizan en registros de longitud fija, por lo que se puede acceder directamente a cualquier dato intermedio. Los archivos binarios también permiten acceso directo, pero los registros son de longitud variable. En esta unidad sólo trataremos a los archivos de acceso secuencial y aleatorio.

Microsoft Word

La Coruña, 2003 Señores CompuSoft, S.A. Ciudad.Estimados señores Figura 6.2.- Archivo de documento de Word

6.1.3. Directorios Los directorios, o carpetas como también se les conocen, representan una estructura organizativa soportada por la mayoría de los sistemas operativos que 88

Visual Basic 6.0

Unidad 6.- Archivos

permite agrupar archivos en una unidad de disco. Windows, como sistema operativo, soporta esta facilidad. En lugar de almacenar todos los archivos en la raíz de la unidad, el usuario puede crear múltiples directorios para contener grupos de archivos, y en cada directorio puede crear otros subdirectorios para un agrupamiento interno, y así sucesivamente. Archivos Archivos

Archivos

Subdirectorio 1

Directorio 1

Archivos Subdirectorio 2 Archivos

Directorio 2 Unidad de disco

Raíz Figura 6.3.- Estructura de directorios y archivos

6.2. Instrucciones de archivos 6.2.1. Instrucciones para manipular directorios a) Establecer la unidad activa Cuando una computadora se enciende, esta ejecuta un programa primario almacenado en ROM o BIOS, el cual contiene las directivas básicas de inicialización. El proceso de inicialización incluye la búsqueda del programa del Sistema Operativo en una unidad de memoria secundaria, es decir, en un disco local o de red. Una vez detectado el sistema operativo, se procede a la carga o ejecución del mismo; y se establece inicialmente como unidad de disco activa, aquella donde se encuentra el sistema operativo. La unidad activa es donde se crean, borran, listan o modifican archivos y directorios. Para cambiar la unidad activa, Visual Basic cuenta con la instrucción ChDrive. Por ejemplo, suponga que desea cambiar a la unidad de disco “A”: ChDrive “A:\” b) Establecer el directorio activo También se puede establecer el directorio activo, con la instrucción ChDir: ChDir directorio

'cambia directorio

Por ejemplo, si desea establecer “Mis documentos” como directorio activo: ChDir “C:\Mis documentos” c) Crear y eliminar directorios Los directorios o carpetas pueden ser creados y borrados mediante las siguientes instrucciones. Para borrar un directorio, este debe ser previamente vaciado. MkDir directorio RmDir directorio

'crea directorio 'borra directorio

6.2.2. Instrucciones para manipular archivos a) Abrir o crear archivos

Visual Basic 6.0

Unidad 6.- Archivos

Para abrir o crear un archivo se utiliza la función Open con la sintaxis siguiente: Open archivo For tipo Access acceso As #NúmeroDeArchivo El parámetro “archivo” es una cadena que representa la ruta y el nombre de un archivo. “tipo” es una palabra reservada que indica el tipo de archivo a abrir o crear, y el modo de apertura, según la tabla siguiente. El “acceso” se refiere al tipo de acceso; es decir, el tipo de operaciones que se puede efectuar sobre el archivo: lectura (Read), escritura (Write), y lectura-escritura (ReadWrite). Cuando se abre o crea un archivo, este se identifica en el sistema mediante un número entero, este número es el parámetro “NúmeroDeArchivo” precedido por el signo #. Tipo Append Input Output Random Binary

Descripción Abre o crea un archivo de texto para agregarle información. Abre un archivo de texto para lectura. Si el archivo no existe, se produce un error. Crea un archivo de texto. Si el archivo existe, este se borra para dar lugar al nuevo. Abre o crea un archivo de acceso aleatorio. Archivo directo a registros de longitud fija. Abre o crea un archivo binario. Archivo de longitud variable por registro. Tabla 6.1.- Especificaciones del parámetro “Tipo” de la instrucción Open

b) Cerrar archivos abiertos Una vez que se han abierto archivos con la función Open, estos se pueden cerrar mediante la instrucción Close. Close #5 Close abiertos

'Cierra el archivo abierto número 5 'Cierra todos los archivos

c) Copiar archivos Para copiar un archivo, este debe estar cerrado. La instrucción es FileCopy: FileCopy archivo_origen, archivo_destino Para copiar el archivo “Carta.doc” desde la unidad “A:\” hasta “Mis documentos” en la unidad “C:\” con el nombre de “Pedido.doc”, se utilizaría el siguiente código: FileCopy “A:\Carta.doc”, “C:\Mis documentos\Pedido.doc” Los comodines dispuestos inicialmente por el sistema operativo MSDOS, como el asterisco y el signo de interrogación, mantienen vigencia en Microsoft Windows, y se pueden utilizar desde Visual Basic. Estos comodines definen un patrón de búsqueda que facilita la operación por lotes sobre un conjunto de archivos. El asterisco indica la presencia o no de cualquier cantidad de caracteres en el nombre de los archivos; y el signo de interrogación indica la presencia de un caracter cualquiera obligatorio en una posición específica en el nombre del archivo. Por ejemplo, suponga que desea copiar todos los archivos .doc que comiencen con las letras “Car” desde la unidad “A:\” hasta la carpeta ““C:\Mis documentos”: FileCopy “A:\Car*.doc”, “C:\Mis documentos\” 90

Visual Basic 6.0

Unidad 6.- Archivos

De esta manera se copiarán los archivos “Carta.doc”, “Carros.doc”, “Cariño.doc”,… FileCopy “A:\C?????.*”, “C:\Mis documentos\” Así sólo se copiarían los archivos “Carros.doc” y “Cariño.doc. Además podrían copiarse “Cremas.xls” o “Comida.ppt”, ya que la extensión es un asterisco. d) Renombrar archivos También es posible cambiar el nombre de un archivo utilizando el siguiente código: Name nombre_viejo As nombre_nuevo Por ejemplo, para cambiar el nombre de “Carta.doc” en la unidad “A:\” por “Pedido.doc”, la instrucción se utilizaría de la siguiente manera: Name “A:\Carta.doc” As “A:\Pedido.doc” e) Borrar archivos Finalmente, para eliminar o borrar un archivo existente del disco se utiliza Kill: Kill nombre_archivo Observación: Las instrucciones para copiar, renombrar y eliminar archivos, se deben aplicar solamente a archivos cerrados; de lo contrario, se produce un error.

6.3. Funciones de archivos 6.3.1. Funciones para manipular directorios a) Contenido de un directorio Para ver el primer archivo contenido en un directorio se puede usar la función Dir: Archivo = Dir(ruta) El parámetro “ruta” es una cadena que especifica la unidad y el directorio cuyo contenido desea listar o examinar. La función Dir devuelve una cadena con el nombre del archivo encontrado según la ruta especificada. Si en la ruta especificada no se encuentran archivos, la función Dir devuelve una cadena vacía. Para listar todo el contenido de un directorio, se utiliza la función Dir, pero sin el parámetro de “ruta”. Por ejemplo, si se desea listar los archivos con extensión .txt que se encuentran en el directorio “C:\Mis documentos” en una caja de lista lstArchivo, se pueden usar las siguientes líneas de código en algún procedimiento: Dim Archivo As String Archivo = Dir(“C:\Mis documentos\*.txt”) Do While Archivo <> “” Me.lstArchivo.AddItem Archivo Archivo = Dir Loop 91

Visual Basic 6.0

Unidad 6.- Archivos

Observación: La función Dir se usa sin argumentos para repetirse con la última ruta especificada.

b) Directorio activo Como vimos anteriormente, la unidad y el directorio activo se establecen mediante las instrucciones ChDrive y ChDir. Es posible visualizar el directorio activo de una unidad con la función CurDir según la siguiente sintaxis: Dim Directorio As String Directorio = CurDir(“D:\”) 6.3.2. Funciones de archivos cerrados a) Tamaño de un archivo cerrado La función FileLen devuelve el tamaño en bytes de un archivo. El valor devuelto es tipo Long. El nombre del archivo es un parámetro tipo cadena de caracteres que podría incluir la ruta del archivo. Por ejemplo se puede conocer el tamaño del archivo Win.ini mediante la siguiente instrucción: Tamaño = FileLen(archivo) Dim Tamaño As Long Tamaño = FileLen(“C:\Windows\Win.ini”) b) Número disponible de archivo Si se intenta abrir un archivo especificando un número ya utilizado por otro archivo abierto, se producirá un error. La función FreeFile permite obtener el próximo número de archivo disponible, y así se evita el error en tiempo de ejecución. Dim NúmeroDeArchivo As Integer NúmeroDeArchivo = FreeFile 6.3.3. Funciones de archivos abiertos a) Tamaño de un archivo abierto Una vez que se ha abierto un archivo, no es posible utilizar FileLen para determinar el tamaño del archivo, ya que sólo se puede hacer referencia a este mediante un número de archivo. Visual Basic proporciona la función LOF para determinar el tamaño de un archivo abierto y se usa de la siguiente manera: Dim Tamaño As Long Tamaño = LOF(NúmeroDeArchivo) En archivos de acceso aleatorio, donde la longitud de los registros es fija, la función LOF permite recalcular la cantidad de registros dentro del archivo cada vez que se agregan o eliminan registros. CantidadDeReg = LOF(NúmeroDeArchivo) / LongitudDeUnReg b) Indicador de final de archivo La función EOF devuelve un valor lógico True si el puntero se encuentra al final del archivo. El puntero es la posición de lectura o escritura dentro del archivo. Al abrir un archivo, el puntero se ubica al principio del archivo; luego, 92

Visual Basic 6.0

Unidad 6.- Archivos

debido a instrucciones de lectura o escritura, se desplaza a lo largo del mismo, y la función (EOF) nos indica si se ha alcanzado la posición del registro final. Esta función es muy útil para efectuar la lectura completa de un archivo, ya que es la condición que se evalúa para detener el ciclo de instrucciones de lectura. Dim FinDeArchivo As Boolean FinDeArchivo = EOF(NúmeroDeArchivo) 6.4. Objetos de archivos 6.4.1. Caja de lista de archivos (Clase: FileListBox) El control FileListBox encuentra y muestra los archivos contenidos en un directorio determinado en tiempo de ejecución, mediante una lista de los archivos seleccionados por atributo o patrón. Mencionaremos algunas de las propiedades y eventos más importantes de este objeto. La propiedad FileName devuelve el nombre del archivo seleccionado de la caja de lista de archivos. La propiedad Path determina la ruta (unidad y directorio) de los archivos que se muestran. Se dispone de las propiedades List, ListIndex, ListCount, etc., de las cajas de lista estudiadas anteriormente. Además se cuenta con propiedades Booleanas que funcionan como un filtro, y determinan si se muestran o no los archivos según su atributo, como son: Archive (Modificado), Hidden (Oculto), Normal (Normal), ReadOnly (Sólo Lectura), y System (del Sistema). Otra de las propiedades de las cajas de lista de archivos, es la propiedad Pattern, que define el patrón de búsqueda. Si la propiedad Pattern se establece, por ejemplo a “*.doc” o “*.txt”, en la caja de lista sólo se mostrarán los archivos de documento o los archivos de texto. Inicialmente Pattern es igual a “*.*”, permitiendo que se muestren todos los archivos. Al producir un Click en la lista, se selecciona uno de sus elementos de la lista, el cual se corresponde con un archivo. El nombre del archivo seleccionado se puede capturar mediante la propiedad FileName. También son importantes los eventos PathChanged y PatternChanged. Estos dos últimos se ejecutan al cambiar respectivamente la ruta y el patrón de búsqueda. 6.4.2. Caja de lista de directorio (Clase: DirListBox) La caja de lista de directorio muestra los directorios y subdirectorios de una unidad determinada en forma de árbol de jerarquía. La propiedad Path se refiere al nombre del directorio seleccionado en la caja de lista. Están disponibles las propiedades de cajas de lista convencionales List, ListIndex, ListCount, etc. El evento Change es utilizado para actualizar el contenido de la caja de lista de archivos mediante su propiedad Path. Private Sub DirListBox1_Change() Me.FileListBox1.Path = Me.DirListBox1.Path End Sub 6.4.3. Caja de lista de unidades (Clase: DriveListBox) El control gráfico muestra y permite seleccionar la unidad de disco activa. La propiedad Drive de este control determina la unidad de disco. Se pueden manipular las propiedades de cajas de lista List, ListIndex, ListCount, etc. El 93

Visual Basic 6.0

Unidad 6.- Archivos

evento Change es utilizado para actualizar el contenido de las cajas de lista de directorio al establecer su propiedad Path. Private Sub DriveListBox1_Change() Me.DirListBox1.Path = Me.DriveListBox1.Drive End Sub En la figura siguiente se muestran los tres controles de archivo para acceder a las unidades de almacenamiento secundario. DriveListBox

FileListBox

DirListBox Figura 6.4.- Objetos de archivos.

6.4.4. Cuadro de diálogo común (Clase: CommonDialog) El control ActiveX de la clase CommonDialog proporciona un conjunto de cuadros de diálogo estándar para realizar operaciones como abrir y guardar archivos, establecer las opciones de impresión y seleccionar colores y fuentes. Este diálogo común proporciona una interfaz entre Visual Basic y las funciones de la biblioteca de vínculos dinámicos Commdlg.dll de Microsoft Windows. Para crear un cuadro de diálogo utilizando este control, el archivo commdlg.dll debe encontrarse en el directorio SYSTEM de Microsoft Windows. a) Insertar el objeto CommonDialog Para usar el control CommonDialog en una aplicación, previamente se debe agregar a la caja de herramientas. Esto se puede hacer seleccionando el menú “Proyecto | Componentes” o presionando “Ctrl+T”. De esta manera aparece el cuadro de diálogo “Componentes”, donde se debe activar la casilla correspondiente a “Microsoft Common Dialog Control 6.0“ (ver Figura 6.5). El Common Dialog no tiene representación gráfica en tiempo de diseño, ya que sólo aparece en tiempo de ejecución mediante métodos que veremos mas adelante.

Visual Basic 6.0

Unidad 6.- Archivos

Figura 6.5.- Diálogo Componentes (Control Diálogo Común)

b) Propiedades del diálogo común Propiedad CancelError DefaultExt DialogTitle FileName FileTitle Filter Flags InitDir MaxFileSize

Descripción Si genera o no un error al usuario presionar el botón Cancelar. Extensión predeterminada de nombre de archivo. Título del cuadro de diálogo. Nombre y ruta del archivo seleccionado que se va a abrir o guardar. Nombre (sin la ruta) del archivo seleccionado que se va a abrir o guardar. Filtros presentados en el cuadro de lista “Tipo” de un cuadro de diálogo. Opciones para mostrar u ocultar elementos del cuadro de diálogo. Ruta inicial de ubicación de los archivos. Tamaño máximo del nombre de archivo abierto mediante el control. Tabla 6.2.- Propiedades del objeto Diálogo Común

En tiempo de ejecución, cuando el usuario elige un archivo, la propiedad FileName se utiliza para obtener el nombre de archivo seleccionado. Se puede establecer la propiedad Filter de forma que el cuadro de diálogo presente sólo ciertos tipos de archivos. Filter es una cadena de caracteres con la sintaxis siguiente: "descripción1 |filtro1 |descripción2 |filtro2..." Por ejemplo, para mostrar sólo archivos de texto .txt, y de imágenes .bmp e .ico: "Archivos de texto |*.txt |Imágenes e iconos |*.bmp;*.ico" La propiedad Flags se puede usar para cambiar varios elementos del cuadro de diálogo, así como para avisar al usuario cuando pueden producirse ciertas situaciones, tal como la escritura en un archivo existente, o la apertura de uno 95

Visual Basic 6.0

Unidad 6.- Archivos

inexistente. A continuación se muestran algunos de los valores que puede adoptar la propiedad Flags (ver Tabla 6.3). Constante cdlOFNReadOnly cdlOFNOverwritePrompt cdlOFNHideReadOnly cdlOFNNoChangeDir cdlOFNHelpButton cdlOFNAllowMultiselect cdlOFNPathMustExist cdlOFNFileMustExist cdlOFNCreatePrompt cdlOFNNoReadOnlyReturn cdlOFNExplorer

Descripción Hace que la casilla de verificación Sólo lectura esté activada inicialmente. El diálogo Guardar como, genera un mensajes si el archivo ya existe. Oculta la casilla de verificación Sólo lectura. Restablece como directorio al que lo era en el momento de abrirse el diálogo. Hace que el cuadro de diálogo presente el botón Ayuda. El cuadro de lista Nombre de archivo permite varias selecciones. Sólo se pueden escribir rutas de acceso válidas o existentes. Sólo puede introducir nombres de archivos existentes. El cuadro de diálogo requiere la creación de un archivo que no exista. El archivo devuelto no tendrá establecido el atributo de Sólo lectura. Usa la plantilla del cuadro de diálogo Abrir archivo de tipo Explorador. Tabla 6.3.- Valores de la propiedad Flags.

c) Métodos de diálogos común El tipo de cuadro de diálogo presentado está determinado por el tipo de método del objeto. En tiempo de ejecución se presenta un cuadro de diálogo, cuando se invoca el método apropiado; en tiempo de diseño, el control CommonDialog se presenta como un icono dentro del formulario. El CommonDialog puede presentar distintos cuadros de diálogo utilizando los siguientes métodos. Método ShowOpen ShowSave ShowColor ShowFont ShowPrinter ShowHelp

Cuadro de diálogo presentado Abrir Guardar como Color Fuente Imprimir u Opciones de impresión Invoca el motor de Ayuda de Windows Tabla 6.4.- Métodos del objeto Diálogo Común.

En el siguiente ejemplo, se muestra como se invoca el cuadro de diálogo Abrir. Private Sub cmdBotón_Click() Dim Archivo As String, Dim NúmeroDeArchivo As Integer Me.Diálogo.CancelError = False Me.Diálogo.Filter = "Office|*.doc;*.xls;*.ppt" Me.Diálogo.Flags = cdlOFNHideReadOnly Me.Diálogo.ShowOpen Archivo = Me.Diálogo.FileName If Archivo <> “” Then NúmeroDeArchivo = FreeFile Open Archivo For Output As #NúmeroDeArchivo End If End Sub

Visual Basic 6.0

Unidad 6.- Archivos

6.5. Archivos secuenciales 6.5.1. Abrir archivos secuenciales Los archivos secuenciales se pueden abrir de tres maneras, según el parámetro “tipo” de Open, y para archivos secuenciales puede ser Input, Output o Append. (1) Input se usa para abrir archivos existentes, a ser leídos, en el sistema. Si el archivo que intenta abrir no existe, se produce un error en tiempo de ejecución. (2) Output es para crear archivos nuevos en el sistema a ser escritos. Es exclusivo para crear e ingresar datos a archivos nuevos. Si el archivo existe, este se sobrescribe. (3) Append se usa para abrir archivos existentes o no en el sistema con el objeto de agregarle información sin sobrescribirlos. Si el archivo a abrir no existe, se crea como archivo nuevo; pero si existe, sólo se abre y se dispone para añadirle más datos de los que posee. 6.5.2. Leer archivos secuenciales Para leer archivos secuenciales, estos se deben abrir utilizando el parámetro Input de la instrucción Open. La información de los archivos secuenciales se puede leer por línea o por campos separados por coma. Para leer una línea completa se usa la instrucción “Line Input”, y para leer campos separados por coma se usa la instrucción “Input”. Private Sub cmdBotón_Click() Dim Línea As String Open "A:\Estados.txt" For Input As #1 Do While Not EOF(1) Line Input #1, Línea txtMiCaja.Text = txtMiCaja.Text & chr(13) & Línea Loop Close #1 End Sub Ahora suponga que el archivo de texto “Estados.txt” contiene los estados de Venezuela y sus códigos de área separados por coma: Caracas, 0212, Valencia, 0241, Lara, 0251, etc. A continuación, se abre el archivo y se muestran los estados de Venezuela y sus códigos de área en las cajas de lista lstEstado y lstCódigo. Private Sub cmdBotón_Click() Dim ElEstado, ElCódigo As String Open "A:\Estados.txt" For Input As #2 Do While Not EOF(2) Input #2, ElEstado, ElCódigo lstEstado.AddItem ElEstado lstCódigo.AddItem ElCódigo Loop Close #2 End Sub 6.5.3. Escribir en archivos secuenciales Para escribir en archivos secuenciales se utilizan como parámetros de “tipo” de la instrucción Open los valores Output o Append. Existen dos métodos para ingresar información en archivos secuenciales. Se pueden ingresar cadenas por línea del archivo con la función “Print”; o por campos separados por coma mediante la 97

Visual Basic 6.0

Unidad 6.- Archivos

función “Write”. El ejemplo a continuación muestra el uso de la función “Print” para agregar el contenido de tres cajas de texto del arreglo txtMiCaja al archivo de texto “Estados.txt”. Private Sub cmdBoton_Click() Open "A:\Estados.txt" For Append As #2 Print #2, txtMiCaja(0).Text Print #2, txtMiCaja(1).Text; txt.MiCaja(2).Text Close #2 End Sub Suponiendo que txtMiCaja (0) contiene “Carabobo”, txtMiCaja (1) contiene “0241” y txtMiCaja (2) contiene “Valencia”; la forma como se almacenan es: Carabobo 0241 Valencia Como se observa, Print dispone de una línea completa por cada campo. Si usamos la Instrucción “Write”, tanto la sintaxis como el resultado son diferentes. Los campos se separan con comas, y no se usa punto y coma, como en el caso de Print. Private Sub cmdBotón_Click() Open "A:\Estados.txt" For Append As #3 Write #3, txtDato(0).Text Write #3, txtDato(1).Text, txtDato(2).Text Close #3 End Sub A continuación observe que cada campo se enmarca entre comillas automáticamente. Además cada instrucción Write produce un salto de línea en el archivo, a menos que los campos se separen con coma. “Carabobo” “0241”, “Valencia” Para que todos los campos queden en una sola línea se debe escribir la instrucción: Write #3, txtDato(0).Text, txtDato(1).Text, txtDato(2).Text Observación: La instrucción Line Input se utiliza para leer un archivo que se ha escrito con la instrucción Print. Por otra parte, la instrucción Input se utiliza para leer un archivo que se ha escrito con la instrucción Write.

6.6. Archivos aleatorios 6.6.1. Abrir archivos aleatorios Para abrir archivos de acceso aleatorio el parámetro tipo de la instrucción Open debe establecerse a Random, aunque previamente se deben tener en cuenta ciertas consideraciones. Cada registro posee una estructura que se le confiere mediante un tipo de dato definido por el usuario. En la unidad 4 se estudiaron los tipos de datos provistos por el sistema. Resulta obligatoria para archivos directos 98

Visual Basic 6.0

Unidad 6.- Archivos

la definición de tipos de datos que le confieran una estructura. De esta manera se establece una serie de pasos para crear o abrir archivos aleatorios. Se desarrollará, como ejemplo, un archivo para almacenar los estados, código de área telefónicos y las capitales de un país. a) Crear la estructura del registro El código para crear tipos de datos personalizados, por lo general, se escribe en la sección declaraciones de cualquier módulo, según el alcance que desee el analista. La palabra reservada para definir tipos de datos es Type, la cual puede ser pública o privada. Para los archivos directos es fundamental definir un tamaño específico para los registros el cual debe ser menor a 32767. Por lo tanto, en la definición de tipo de dato, las cadenas de caracteres deben ser de longitud fija. Private Type T_Estado Nombre As String * 15 CódigoDeArea As String * 4 Capital As String * 20 End Type Observación: Por simple regla de Visual Basic, se acostumbra a comenzar el nombre del tipo de datos con la letra T mayúscula

b) Declarar las variables de registro La variable de registro representa una colección de cada uno de los campos que conforman al registro. Esta se declara de la misma manera como se estudió en la unidad 4, y se recomienda escoger la sección declaraciones, siempre posterior a la declaración Type. Para tener control del archivo, es necesario declarar otras variables para conocer la longitud de cada registro y la cantidad de registros almacenados en el archivo. Dim Estado As T_Estado Dim Longitud As Integer Dim Registros As Long

'Variable de registro 'Longitud de un registro 'Cantidad de registros

c) Determinar la longitud de cada registro y abrir el archivo Se recomienda utilizar el evento Load del objeto Form para efectuar es paso, y de esta manera el archivo se abre desde el principio de la aplicación; aunque se puede escoger cualquier otro evento y objeto del proyecto. Para calcular la longitud del registro se utiliza la función Len, y para el tamaño del archivo se utiliza LOF. Private Sub Form_Load() Longitud = Len(Estado) Open “A:\Estados.dat” For Random As #1 Len = Longitud Registros = LOF(1) / Longitud End Sub 6.6.2. Leer registros de archivos aleatorios La operación de lectura requiere que se especifique la posición de lectura dentro del archivo, para lo cual se utiliza una variable para la posición en la instrucción Get: La operación de lectura consiste en: (1) Leer una posición específica para la 99

Visual Basic 6.0

Unidad 6.- Archivos

variable de registro, y (2) Operar cada uno de los campos de la variable de registro. El siguiente procedimiento general, donde la variable “Posición” ha sido declarada previamente, Lee un registro y lo muestra en cajas de texto. Public Sub Leer() Get #1, Posición, txtMicaja(0).Text txtMicaja(1).Text txtMicaja(2).Text End Sub

Estado = Estado.Nombre = Estado.CódigoDeArea = Estado.Capital

6.6.3. Escribir registros en archivos directos Para colocar información en el archivo directo se usa la instrucción Put. Así como para la operación de lectura, la escritura también requiere la especificación de la posición. La operación de escritura consiste en: (1) Cargar cada uno de los campos de la variable de registro, y (2) Escribir la variable de registro en una posición específica. El siguiente procedimiento permite almacenar el contenido de las cajas de texto txtMiCaja. Public Sub Escribir() Estado.Nombre = txtMicaja(0).Text Estado.CódigoDeArea = txtMicaja(1).Text Estado.Capital = txtMicaja(2).Text Put #1, Posición, Estado End Sub 6.6.4. Localizar una posición de registro Si no se especifica la posición en la instrucción Get; el sistema lee el registro activo. Al abrir un archivo, la posición inicial es 1 (principio del archivo), y esta se va incrementando automáticamente cada vez que se efectúa una lectura. Get #1, , Estado Put #1, , Estado

'Lee el registro activo 'Escribe al final del archivo

El apuntador se puede llevar a una posición específica dentro del archivo de acceso aleatorio mediante la instrucción Seek. Para ubicar el cuarto registro, escribimos: Seek #1, 4 Observación: Si no se especifica una posición en la instrucción de escritura Put, el registro siempre se escribe al final del archivo, a pesar de efectuar previamente un Seek.

6.6.5. Tareas comunes de archivos aleatorios a) Avanzar registros Private Sub cmdAvanzar() If Posición < Registros Then I = 1 Else I = 0 Posición = Posición + I If Posición = Registros Then cmdAvanzar.Enabled = False If Registros > 1 Then cmdRetroceder.Enabled = True Leer End Sub 100

Visual Basic 6.0

Unidad 6.- Archivos

b) Retroceder registros Private Sub cmdRetroceder() If Posición > 1 Then I = 1 Else I = 0 Posición = Posición – I If Posición = 1 Then cmdRetroceder.Enabled = False If Registros > 1 Then cmdAvanzar.Enabled = True Leer End Sub c) Buscar un registro Private Sub Buscar(ByVal Buscado As String) Dim I As Long For I = 1 To Registros + 1 Get #1, I, Estado If Trim(Estado.Nombre) Like Buscado + “*” Then Exit For Next I If I > Registros Then 'No se encontró txtMicaja(0).Text = “” txtMicaja(1).Text = “” txtMicaja(2).Text = “” Else 'Si se encontró txtMicaja(0).Text = Estado.Nombre txtMicaja(1).Text = Estado.CódigoDeArea txtMicaja(2).Text = Estado.Capital End If End Sub d) Eliminar un registro Private Sub Buscar(ByVal Buscado As String) Dim I As Long Estado.Nombre = “” Put #1, Posición, Estado Open “Temporal.tmp” For Random As #2 Len = Len(Estado) For I = 1 To Registros Get #1, I, Estado If Trim(Estado.Nombre) <> “” Then Put #2, , Estado Next I Close #1, #2 Kill “A:\Estados.dat” Name “A:\Temporal.tmp” As “A:\Estados.dat” Open “A:\Estados.dat” For Random As #1 Len = Len(Estado) Posición = Posición – 1 cmdAvanzar End Sub En resumen, el código anterior para eliminar un registro de un archivo, sigue el siguiente procedimiento:  Hacer blanco uno de los campos del registro a eliminar.  Crear un archivo temporal  Agregar todos los registros, excepto los blancos, al archivo temporal. 101

Visual Basic 6.0

Unidad 6.- Archivos

 Cerrar los dos archivos.  Eliminar el archivo original  Renombrar el archivo temporal para que se convierta en el original.  Volver a abrir el archivo original.  Retomar la posición del registro anterior al eliminado.  Ejecutar un avance para mostrar el registro siguiente al eliminado.

102

Visual Basic 6.0

Unidad 7.- Bases de datos

Unidad 7 Bases de Datos “Es prudente tener presente que ni el éxito ni el fracaso son definitivos” .- Roger Babson

7.1. Introducción a Bases de Datos 7.1.1. Nociones básicas Las bases de datos permiten almacenar y mantener una gran cantidad de información de una manera bien organizada, de forma que sea posible devolver dicha información rápidamente. La estructura que trataremos es la de bases de datos relacionales, en la que se concibe una base de datos como un espacio de trabajo (WorkSpace) donde coexisten y se relacionan varios conjuntos de datos llamadas tablas, las cuales contienen filas, columnas e índices. a) Las Tablas son conjuntos de datos del mismo tema. Por ejemplo, Clientes, Proveedores, Ventas, Compras y Productos, son temas que se agrupan en tablas de una base de datos administrativa. b) Las Columnas son los Campos que representan características del tema de una tabla. Por ejemplo, de la tabla Productos se tienen los campos o características siguientes: Código, Descripción, Serial, Precio, Existencia, etc. c) Las Filas representan el registro en sí; es decir, un elemento de la tabla con todas sus características. Por ejemplo, un elemento de la tabla Productos sería: Monitor Compaq, serial 1102212221987, precio 215.000 Bs. y existencia 14. d) Finalmente, los Índices son números enteros en un campo especial autonumérico de la tabla y se utilizan para acceder rápidamente a un registro en una base de datos relacional, ordenar los registros y permitir las relaciones entre varias tablas. El campo de una tabla A puede requerir los datos de otra tabla B, y según el concepto de bases de datos relacional, el índice funciona como un apuntador o valor en la tabla A que hace referencia a un registro (fila) de la tabla B.

103

Visual Basic 6.0

Unidad 7.- Bases de datos

Figura 7.1.- Tabla “Productos” de una base de datos.

7.1.2. Arquitectura de bases de datos Básicamente los datos de una base de datos se almacenan en un archivo de disco local o remoto, y se conoce como la fuente u origen de datos (DataSource). Como se observa en la figura siguiente, las peticiones de servicios, de parte del usuario o una aplicación externa, no se realizan directamente sobre el origen de datos, sino que existe un motor de administración de la base de datos. Interfaz de Usuario Motor de Base de Datos Origen de Datos

Figura 7.2.- Arquitectura de Bases de Datos

En la figura anterior se pueden apreciar las peticiones mediante las flechas gruesas en el sentido hacia el origen de datos. Este motor de base de datos es una librería de funciones, las cuales ejecutan las operaciones necesarias sobre el origen de datos para responder a las solicitudes de servicio. Las librerías de funciones son archivos con extensión DLL o EXE, y no existen exclusivamente para el manejo de bases de datos; por el contrario, el sistema Windows se basa justamente en librerías de funciones, o DLL (Dynamic Link Library) como comúnmente se les nombra. La interfaz de usuario se define como la aplicación para presentar y actualizar los registros de una base de datos, para lo cual debe interactuar con el motor de base de datos. Los programas que integran a estos tres elementos fundamentales se conocen como Sistemas de Administración de Bases de Datos (DBSM), como lo son Microsoft Access, SQL Server, Oracle, Fox Pro, Clipper, Dbase, Paradox, etc. 7.1.3. Tecnologías de bases de datos Cada tipo de base de datos posee un motor diferente; es decir, un conjunto diferente de funciones, sólo compatibles con un origen de datos en particular. Los motores de bases de datos constan de (1) Proveedores de datos, que contienen y exponen los datos; (2) Clientes de datos, que utilizan los datos; y (3) Componentes de servicio, que procesan y transportan datos. Visual Basic, como lenguaje de programación, permite crear las aplicaciones de usuario; pero carece 104

Visual Basic 6.0

Unidad 7.- Bases de datos

de un motor de base de datos intrínseco, por lo que no se considera un manejador de bases de datos (DBSM). De esta manera, se han diseñado tecnologías de acceso a datos para la administración de bases de datos desde aplicaciones de Visual Basic. Estas tecnologías incluyen: a) Interfaces para orígenes de datos Visual Basic debe acceder a los motores de bases de datos apropiados según los orígenes de datos que el usuario desee manipular; es así como dispone de diversos proveedores de datos basados en una tecnología llamada OLE DB (OLE Data Base). OLE DB define una colección de interfaces que encapsulan varios servicios de los sistemas de administración de bases de datos (DBMS). Estas interfaces permiten crear componentes de software que implementen dichos servicios. Los clientes obtienen acceso a un objeto a través de interfaces implementadas en el objeto. Existe un servidor OLE DB por cada tipo de origen de datos. b) Modelos de objetos de bases a datos La variedad y complejidad de las interfaces OLE DB no permite el acceso directo desde Visual Basic. En vez de esto, existen tecnologías intermedias, entre OLE DB y Visual Basic, destinadas a ofrecer modelos de objetos de acceso a datos que encapsulan y exponen prácticamente toda la funcionalidad de OLE DB a las aplicaciones; de esta manera, se logra uniformidad en las tareas de programación sin importar el tipo de servidor o proveedor OLE DB. En Visual Basic existen tres modelos de objetos, los cuales proveen un conjunto de objetos y mecanismos necesarios en la conexión con la base de datos a través de OLE DB. El primer modelo de objetos fue implementado en la versión 3 de Visual Basic y se conoce como DAO (Data Access Objects), el cual posee la gran desventaja de no permitir el acceso a datos ubicados en servidores remotos, y además está dedicado al motor Microsoft Jet que utiliza Access. Para responder a estas limitaciones, en la versión siguiente de Visual Basic, se incluyó el modelo RDO (Remote Data Objects) como una interfaz exclusiva para el acceso a datos remotos. A partir de la versión 6, se comienza a utilizar el modelo ADO (ActiveX™ Data Objects), el cual encapsula la funcionalidad de las tecnologías DAO y RDO, reduciendo la cantidad de objetos, propiedades, métodos y eventos. Origen de Datos 1

Proveedor 1 OLE DB

Origen de Datos 2

Proveedor 2 OLE DB

Origen de Datos 3

Proveedor 3 OLE DB

Visual Basic

Modelo de Objetos

Interfaz de Usuario

Figura 7.3.- Acceso de Visual Basic a Bases de Datos

7.1.4. Proveedores OLE DB Para Visual Basic están disponibles los proveedores de Microsoft OLE DB para los siguientes tipos de bases de datos: a) Microsoft Index Server b) Microsoft Active Directory Service Interfaces (ADSI) 105

Visual Basic 6.0

Unidad 7.- Bases de datos

c) Microsoft SQL Server d) Microsoft Jet (Microsoft Access) e) Bases de datos de Oracle f)

Orígenes de datos ODBC (Open DataBase Connectivity)

Los orígenes de datos ODBC corresponden a bases de datos compatibles con la tecnología ODBC. Esta tecnología permite el acceso a distintos tipos de bases de datos adicionales a los que proporciona OLE DB. De esta manera se incrementa el espectro de orígenes de datos que se pueden acceder desde Visual Basic. Utilizando Microsoft OLE DB para ODBC es posible manipular datos provenientes de: Dbase (*.dbf), Excel (*.xls), FoxPro (*.dbf), Visual Foxpro (*.dbf), Paradox (*.db) y Archivos de texto separados por coma (*.csv). Aunque también es posible acceder a datos de Microsoft Access, Microsoft SQL Server y Oracle mediante OLE DB para ODBC, se recomienda utilizar el controlador correspondiente OLE DB Jet, SQL y Oracle. Convención: En adelante, para los ejemplos presentados en esta guía se ha escogido el proveedor OLE DB para Microsoft Jet para manejar bases de datos de Microsoft Access, y se utilizará ADO como modelo de objetos de acceso a datos.

7.1.5. Lenguajes de bases de datos El motor de base de datos ejecuta un conjunto de tareas sobre el origen de datos mediante las funciones almacenadas en archivos DLL, las cuales son activadas desde la interfaz de usuario. De esta manera, la interfaz de usuario debe proveer los mecanismos necesarios para la configuración y puesta en marcha de la base de datos. Los mecanismos antes mencionados, se agrupan o se clasifican en dos tipos de lenguaje, según la respuesta del motor de base de datos al servicio solicitado. a) Lenguaje de definición de datos (DDL): El DDL consta de las propiedades y métodos utilizados para definir y crear la propia base de datos, incluyendo sus tablas, campos, índices, relaciones, etc. Este lenguaje agrupa a todas las instrucciones relacionadas al diseño de la base de datos. DML incluye facilidades para consultar, actualizar, agregar y eliminar tablas, campos, índices y relaciones. b) Lenguaje de manipulación de datos (DML): El DML consta de las propiedades y los métodos utilizados para escribir la sección de las aplicaciones que tienen acceso a los registros de bases de datos existentes. DML incluye facilidades para consultar, desplazar, actualizar, ordenar, agregar y eliminar registros. Atención:

Esta clasificación no significa que existan dos lenguajes separados; es simplemente una forma de agrupar los elementos del lenguaje según su funcionalidad.

Las tareas de definición y configuración de las bases de datos, por lo general, se realizan utilizando los respectivos DBMS; es decir, no se crean aplicaciones destinadas a DDL aunque los lenguajes de programación, como Visual Basic, incluyan esta facilidad. La razón de esta práctica radica en el hecho que los DBMS poseen las herramientas más adecuada para el diseño de las bases de datos. Por otra parte, en la mayoría de los casos el sistema de base de datos ya se encuentra instalado, y lo que se requiere es la interfaz de usuario para acceder a los datos. 106

Visual Basic 6.0

Unidad 7.- Bases de datos

Observación: En esta guía de estudio no se consideran los métodos y propiedades para el diseño de bases de datos DDL, salvo algunos comandos SQL para el manejo de tablas.

7.1.6. Modos de manipulación de registros El lenguaje de manipulación de datos (DML) está relacionado con las operaciones (modificar, agregar, guardar, eliminar, ordenar) sobre los registros de una base de datos, y se puede aplicar de dos maneras según los siguientes modos. a) Modo de desplazamiento Basado en el movimiento a través de los registros de una tabla de la base de datos; y donde las operaciones se efectúan sobre un solo registro, que se corresponde al registro activo o seleccionado de la base de datos. Por ejemplo; la operación eliminar, sólo eliminará al registro activo. b) Modo relacional Basado en el Lenguaje de Consulta Estructurado (SQL), donde las operaciones pueden afectar a uno, varios o a todos los registros de una tabla de base de datos, según una definición de parámetros de selección. Por ejemplo; se pueden eliminar todos los registros de la tabla Productos cuyo campo Existencia sea nulo, y esto sin necesidad de hacer activos todos los registros a eliminar. 7.2. Objetos de acceso a datos ADO 7.2.1. Modelo de objetos de ADO El modelo de objetos de ADO define una colección de objetos programables para aprovechar la eficaz tecnología denominada OLE DB. Uno de los puntos fuertes de ADO es que puede exponer y utilizar las propiedades únicas de cada proveedor de datos. Independientemente del origen de datos utilizado, ADO es totalmente flexible y adaptable a los requisitos de acceso a datos de su aplicación. El modelo de objetos ADO, en su versión 2.0, consta de siete objetos y cuatro colecciones: Connection Objeto

Command Properties

Property

Parameters

Parameter

Properties

Property

Fields

Field

Colección

Rercorset

Properties Properties

Property

Errors

Error

Property

Figura 7.4.- Modelo de objetos ADO.

a) Objeto Connection: Contiene información acerca de un proveedor de datos y la su conexión, como el tipo de cursor, la cadena de conexión, el tiempo de 107

Visual Basic 6.0

Unidad 7.- Bases de datos

espera de la consulta, el tiempo de espera de la conexión y la base de datos predeterminada. b) Objeto Command: Contiene información acerca de un comando, como una cadena de consulta, nombre de una tabla, una definición de parámetro y otros. Puede ejecutar una cadena de comando en un objeto Connection de una cadena de consulta como parte de la apertura de un objeto Recordset, sin definir un objeto Command. El objeto Command es útil cuando desee definir parámetros de consultas o ejecutar procedimientos almacenados que devuelva parámetros de resultados. Los objetos Command admiten varias propiedades para describir el tipo y el propósito de la consulta y para ayudar a ADO a optimizar la operación. c) Objeto Recordset: Contiene los registros devueltos por una tabla o consulta, así como un cursor para dichos registros. Puede abrir un objeto Recordset (por ejemplo, al realizar una consulta) sin abrir explícitamente un objeto Connection. No obstante, si opta por crear un objeto Connection, puede abrir múltiples objetos Recordset con la misma conexión. d) Objeto Property: Contiene las características definidas por el proveedor de un objeto ADO. Los objetos ADO tienen dos tipos de características: Integradas y Dinámicas. Las propiedades integradas son las que están implementadas en ADO y se encuentran disponibles para cualquier objeto nuevo de ADO. Las propiedades dinámicas están definidas por el proveedor de datos subyacente y aparecen en la colección Properties para el objeto de ADO apropiado. Por ejemplo, una propiedad puede indicar si un objeto Recordset admite transacciones o actualizaciones. Ésta es una de las principales características de ADO, que permite al proveedor de servicios de ADO presentar interfaces especiales. Cada uno de los objetos Connection, Command, Recordset y Field tiene una colección Properties. e) Objeto Error: Contiene información ampliada acerca de condiciones de error producida por el proveedor de datos. Como una única instrucción puede generar dos o más errores, la colección Errors puede contener más de un objeto Error al mismo tiempo. La colección Errors está en el objeto Connection. f)

Objeto Parameter: Es un parámetro individual asociado a un objeto Command. El objeto Command utiliza la colección Parameters para que contenga a todos sus objetos Parameter. Los objetos Parameter de ADO se pueden generar automáticamente enviando consultas a la base de datos. Sin embargo, también puede generar esta colección mediante programación para mejorar el rendimiento en tiempo de ejecución.

g) Objeto Field: Contiene información acerca de una única columna de datos en el conjunto de registros (Recordset). El objeto Recordset utiliza la colección Fields para que contenga a todos sus objetos Field. Esta información de Field incluye el tipo de datos, la precisión y la escala numérica. 7.2.2. El objeto Connection Regla de Visual Basic de prefijo para nombre del objeto Connection: cnn.

a) Propiedades Propiedad ConnectionString

Descripción Cadena que contiene la información que se utiliza para establecer una conexión a un 108

Visual Basic 6.0

Propiedad Provider DefaultDatabase ConnectionTimeout CursorLocation Mode State

Unidad 7.- Bases de datos

Descripción origen de datos. Indica el nombre del proveedor de la base de datos en una conexión. Indica el nombre de la base de datos predeterminada en una conexión. Indica el intervalo de espera mientras se establece una conexión antes de que se genere un error. Establece o devuelve la posición de un motor de cursores. (AdUseNone, adUseClient, adUseServer). Indica los permisos disponibles para modificar datos en un objeto Connection. (Lectura, escritura...). Indica el estado de la conexión: abierta, cerrada. Tabla 7.1.- Propiedades del objeto Connection de ADO

La propiedad ConnectionString permite especificar un origen de datos mediante una cadena de conexión detallada que contiene una serie de expresiones (argumento = valor) separadas con punto y coma. Dim C As Cadena C=“Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\bd.mdb” El argumento Provider especifica el nombre del proveedor que se usa en la conexión, es decir, el motor de la base de datos y su versión. El argumento DataSource se refiere a la ruta y nombre de la base de datos que se desea acceder. También se puede especificar sólo al proveedor mediante la propiedad Provider; o sólo el nombre de la base de datos mediante la propiedad DefaultDatabase. Las opciones de la propiedad CursorLocation se describen en la tabla siguiente: Opción adUseNone adUseClient adUseServer

Descripción No se usan servicios de cursor. Usa cursores del lado del cliente suministrados por una biblioteca de cursores locales. Predeterminado. Usa cursores suministrados por el controlador o por el proveedor de datos. Tabla 7.2.- Opciones de la propiedad CursorLocation.

El valor de la propiedad CursorLocation afecta solamente a las conexiones establecidas después de que se haya establecido la propiedad. Los cambios en la propiedad CursorLocation no afectan a las conexiones existentes. Se recomienda utilizar la opción adUseClient si se esta trabajando con una base de datos local. b) Métodos Propiedad Open Execute Close Cancel

Descripción Abre una conexión a un origen de datos. Ejecuta una consulta, instrucción SQL, procedimiento almacenado o texto específico del proveedor. Cierra un objeto de conexión a un origen de datos y los objetos dependientes. Cancela la ejecución de una llamada asíncrona pendiente a un método Execute u Open. Tabla 7.3.- Métodos del objeto Connection de ADO

El método Open sólo establece una conexión física con la base de datos, para lo cual requiere el establecimiento de las propiedades ConnectionString, ConnectionTimeout y CursorLocation. La propiedad ConnectionTimeout esta 109

Visual Basic 6.0

Unidad 7.- Bases de datos

predefinida en 15 segundos, por lo tanto, algunas veces no es necesario establecer. El método Execute puede o no devolver filas. En el caso que devuelva filas (registros), el valor devuelto es una referencia a un objeto Recordset. 7.2.3. El objeto Recordset Regla de Visual Basic de prefijo para nombre del objeto Recordset: rst.

a) Propiedades Propiedad AbsolutePosition ActiveConnection BOF EOF CursorLocation CursorType EditMode Filter LockType RecordCount Source State Status

Descripción Especifica la posición ordinal del registro actual. Indica a qué objeto Connection pertenece actualmente el objeto. Indica que la posición del registro actual está antes del primer registro. Indica que la posición del registro actual está después del último registro. Establece o devuelve la posición de un motor de cursores. Indica el tipo de cursor que se usa en el objeto. Indica el estado de modificación del registro actual. Indica un filtro para los datos del conjunto de registros. Indica el tipo de bloqueo que se pone en los registros durante el proceso de edición. Indica el número actual de registros del objeto. Indica el origen de los datos (una instrucción SQL, un nombre de tabla o un procedimiento almacenado). Describe el estado del objeto: abierto o cerrado. Indica el estado del registro actual referente a las actualizaciones por lotes u otras operaciones masivas. Tabla 7.4.- Propiedades del objeto Recordset de ADO

La propiedad CursorLocation del Recordset es heredada del objeto Connection, aunque se puede cambiar en el objeto Recordset. Use la propiedad CursorType para especificar el tipo de cursor que se debe utilizar al abrir el objeto Recordset. La propiedad CursorType es de lectura/escritura cuando el Recordset está cerrado y de sólo lectura cuando está abierto. CursorType especifica los desplazamientos permitidos a través del conjunto de registros (ver Tabla 7.5) Opción adOpenForwardOnly adOpenKeyset adOpenDynamic adOpenStatic

Descripción Predeterminado. Sólo permite desplazarse hacia delante en los registros. Esto mejora el rendimiento en situaciones en las que sólo se quiere pasar una vez por cada registro. Son inaccesibles los registros que agregan o eliminan otros usuarios. Los cambios que otros usuarios hacen en los datos permanecen visibles. Se admiten todo tipo de movimientos entre registros. Las incorporaciones, cambios y eliminaciones que hacen otros usuarios permanecen visibles, y se admiten todo tipo de movimientos entre registros. Una copia estática de un conjunto de registros que se puede usar para buscar datos o generar informes. Las incorporaciones, cambios o eliminaciones que hacen otros usuarios no son visibles. Tabla 7.5.- Opciones de la propiedad CursorType

La propiedad LockType se establece antes de abrir un Recordset para especificar qué tipo de bloqueo debe usar el proveedor al abrirlo. LockType es de lectura/escritura cuando el Recordset está cerrado y de sólo lectura cuando está abierto. Los tipos de bloqueo se especifican en la tabla siguiente. Valor de LockType adLockReadOnly

Descripción Predeterminado. Sólo lectura—no puede modificar los datos. 110

Visual Basic 6.0

Unidad 7.- Bases de datos

Valor de LockType adLockPessimistic adLockOptimistic adLockBatchOptimistic

Descripción Bloqueo pesimista, registro a registro: el proveedor hace lo necesario para asegurar la modificación correcta de los registros, generalmente bloqueando registros en el origen de datos. Bloqueo optimista, registro a registro: el proveedor usa bloqueo optimista, bloqueando registros sólo cuando llama al método Update. Actualizaciones optimistas por lotes: requerido para el modo de actualización por lotes como contraposición al modo de actualización inmediata. Tabla 7.6.- Opciones de la propiedad LockType

La propiedad EditMode se puede usar evaluar el estado de edición de un registro, y así determinar la ejecución o no de acciones de guardado de registros. EditMode puede tener uno de los siguientes valores: Devuelve adEditNone adEditInProgress adEditAdd adEditDelete

Descripción Indica que no hay ninguna operación de modificación en ejecución sobre el registro actual. Indica que los datos del registro actual se han modificado pero que no se han guardado aún. Indica que se ha invocado el método AddNew y que no se ha guardado aún el registro actual nuevo. Indica que el registro actual se ha eliminado. Tabla 7.7.- Valores que devuelve la propiedad EditMode

La propiedad Filter se utiliza para descartar de manera selectiva registros de un objeto Recordset. El Recordset filtrado se convierte en el cursor actual. Esto afecta a otras propiedades, como AbsolutePosition y RecordCount, que devuelven valores basados en el cursor actual. Filter se basa en una cadena de criterio que se compone de cláusulas con el formato “[Nombre campo] Operador – Valor”; por ejemplo, la siguiente instrucción devuelve sólo registros cuyo apellido sea Smith: MiRecordset.Filter = "LastName = 'Smith'" Se pueden crear cláusulas compuestas mediante la concatenación de cláusulas individuales con operadores lógicos (por ejemplo, "LastName = 'Smith' AND FirstName = 'John'"). Si el nombre de campo contiene espacios, deberá encerrar el nombre entre corchetes (por ejemplo, “[Last Name] = ‘Smith’”). Se utilizan comillas simples para las cadenas y el símbolo de numeral (#) para las fechas. Si el operador es LIKE, se podrán utilizar comodines para el valor de comparación. Los únicos comodines que se admiten son el asterisco (*) y el signo de porcentaje (%) y deben ser el último carácter de la cadena. b) Métodos Método AddNew UpdateBatch CancelBatch Update CancelUpdate Open Cancel Close

Descripción Crea un nuevo registro Escribe en disco todas las actualizaciones pendientes de proceso por lotes. Cancela una actualización por lotes pendiente. Guarda los cambios realizados en el registro actual de un objeto Recordset. Cancela las modificaciones al registro actual o a un registro nuevo antes de invocar a Update. Abre un cursor que representa los registros de una base de datos o los resultados de una consulta. Cancela la ejecución de una llamada asíncrona pendiente a un método Open. Cierra un objeto Recordset, libera los datos asociados y los accesos exclusivos que pudiera tener. 111

Visual Basic 6.0

Método MoveFirst MoveNext MovePrevious MoveLast Requery Delete

Unidad 7.- Bases de datos

Descripción Pasa al primer registro y lo convierte en el registro actual. Pasa al siguiente registro y lo convierte en el registro actual. Pasa al anterior registro y lo convierte en el registro actual. Pasa al último registro y lo convierte en el registro actual. Actualiza los datos de un objeto Recordset volviendo a ejecutar la consulta en que se basa el objeto. Elimina el registro actual o al grupo de registros especificados mediante la propiedad Filter. Tabla 7.8.- Métodos del objeto Recordset de ADO

c) Eventos Eventos FetchProgress, FetchComplete WillChangeField, FieldChangeComplete WillMove, MoveComplete, EndOfRecordset WillChangeRecord, RecordChangeComplete WillChangeRecordset, RecordsetChangeComplete

Descripción Estado de recuperación: notificación del progreso de una operación de recuperación de datos, o de que la operación de recuperación ha concluido. Administración de cambio de campo: Notificación de que el valor del campo actual cambiará o ha cambiado. Administración de exploración: Notificación de que la posición de fila (registro) actual en un Recordset cambiará, ha cambiado o ha llegado al final del Recordset. Administración de cambios en la fila: Notificación de que algo en la fila (registro) actual del Recordset cambiará o ha cambiado. Administración de cambios en el Recordset: Notificación de que algo en el Recordset actual cambiará o ha cambiado. Tabla 7.9.- Eventos del objeto Recordset de ADO

7.2.4. Procedimiento para utilizar el modelo ADO Una aplicación típica basada en ADO utiliza un conjunto de procedimientos u operaciones establecidas para tener acceso a un origen de datos. El modelo de datos ADO requiere obligatoriamente el establecimiento de una conexión antes de cualquier operación sobre la base de datos. El procedimiento se detalla en los siguientes pasos: a) Crear y abrir la conexión (objeto Connection) Se especifica la cadena de conexión con información como el nombre del origen de datos, la identificación del usuario, la contraseña, el tiempo de espera de la conexión, la base de datos predeterminada y la ubicación del cursor. Establecidos estos parámetros se procede a abrir la conexión mediante el método Open del objeto Connection. b) Ejecutar el comando (objeto Command y Recordset) Se especifica el tipo de comando (tabla, consulta o procedimiento almacenado) y los registros afectados del origen de datos. El tipo de comando determina básicamente el tipo de origen de datos. El comando puede ser de selección de registros o de acción sobre los registros. Cuando el comando es de selección de registros, es necesario establecer el objeto Recordset que contendría al conjunto de registros. A continuación, según sea el comando de selección o de acción, se sigue uno de los siguientes procedimientos:  Ejecutando un comando de selección: Se crea y se abre el objeto Recordset para obtener el conjunto de registros provenientes de una tabla, del resultado de una consulta SQL o procedimiento almacenado. Para este paso, primeramente se definen las características del cursor, el nombre de la tabla, la instrucción de selección SQL, o nombre del procedimiento 112

Visual Basic 6.0

Unidad 7.- Bases de datos

almacenado; para posteriormente invocar el método Open del objeto Recordset.  Ejecutando un comando de acción: Consiste en ejecutar el método Execute del objeto Connection sin devolución de filas. Este método actúa sobre un conjunto de registros del origen de datos mediante instrucciones de acción SQL, pero no devuelve registros. c) Utilizar el conjunto de resultados (objeto Recordset) Aplica si el comando es de selección. En función del tipo de cursor (CursorType), se pueden examinar y modificar los datos de las filas en el servidor o en el cliente, mediante métodos y propiedades del objeto Recordset. d) Finalizar la conexión (objeto Connection) Cancela la conexión con el origen de datos. Se utiliza el método Close del objeto Connection. 7.3. Acceso a datos mediante Visual Basic y ADO 7.3.1. Métodos para utilizar ADO El modelo ADO se puede implementar de varias maneras desde Visual Basic, usando (a) El control de datos ADO, (b) ADO mediante código, o (c) El entorno de datos. a) El control de datos ADO Este control de datos permite efectuar una conexión con la base de datos y define un conjunto de filas (Recordset) provenientes de una tabla, del resultado de una consulta o de un procedimiento almacenado. Tiene la ventaja que es fácil y rápidamente configurable, provee los botones para desplazarse a través de los registros y se puede reconfigurar durante la ejecución. Pero por otra parte, no se tiene suficiente control sobre la conexión, de tal manera que se pueden producir errores durante la carga, si la base de datos es movida de su ubicación original. b) ADO mediante código Creando los objetos ADO mediante código, el control de la conexión y del origen de datos es total; pero se deben crear por código todos los procedimientos, lo que puede resultar un poco tedioso para el programador. Una vez que se han creado los objetos Recordset, se acostumbra a asignar estas referencias de objeto al control de datos ADO, con el fin de aprovechar su funcionalidad. c) El entorno de datos El entorno de datos es un objeto de la clase DataEnvironment que contiene las conexiones (DEConnection), comandos (DECommand) y campos de una o varias bases de datos. El diseñador de entorno de datos permite definir uno o varios objetos conexión (DEConnection); y de cada conexión, el objeto Recordset se define mediante objetos comando (DECommand). Si bien presenta la ventaja de crear los controles enlazados de manera sencilla

113

Visual Basic 6.0

Unidad 7.- Bases de datos

(arrastrar desde el diseñador y colocar en el formulario), el acceso a los datos se debe codificar haciendo referencia al nombre del objeto DataEnvironment. Estos procedimientos, aunque se estudian de manera separada, se pueden combinar o complementar entre sí para obtener una máxima eficiencia de la interfaz de base de datos y su configuración. Por otra parte, la visualización de los datos de un Recordset se realiza enlazando estos a objetos receptores de datos que se conocen como Controles Enlazados a un campo o al Recordset completo. 7.3.2. Controles enlazados a datos Los objetos receptores de datos son controles que pueden ser enlazados con orígenes de datos. Estos son de la clase TextBox, ListBox, ComboBox, CheckBox, PictureBox, Image y Label; y además controles no estándar como el DataGrid, DataCombo y DataList. Según los métodos para utilizar ADO (7.3.1), los controles se pueden enlazar de las siguientes maneras: a) Control de datos ADO: En tiempo de diseño, en la propiedad DataSource del objeto se indica el nombre del control de datos ADO, y en la propiedad DataField del objeto se escoge el nombre de uno de los campos del Recordset. b) ADO mediante código: Se enlaza en tiempo de ejecución mediante una referencia del objeto Recordset a la propiedad DataSource del objeto receptor utilizando la sentencia SET. También se debe establecer la propiedad DataField con una instrucción de asignación del nombre del campo como cadena en forma explícita. c) Entorno de datos: En tiempo de diseño, en la propiedad DataSource del objeto se indica el nombre del entorno de datos, en la propiedad DataMember se coloca el nombre del comando (DECommand), y luego se especifica el nombre del campo en la propiedad DataField. Para este caso, también es posible arrastrar y colocar. 7.3.3. El control de datos ADO a) Agregar el control de datos en la caja de herramientas: Este se debe agregar mediante el cuadro de diálogo Componentes (Ctrl+T), seleccionando el objeto Microsoft ADO Data Control 6.0 (OLEDB), como se muestra en la figura 7.5.

114

Visual Basic 6.0

Unidad 7.- Bases de datos

Figura 7.5.- Diálogo de componentes (Control de datos ADO)

b) Crear la conexión con la base de datos: Una vez dibujado el control de datos ADO, se utiliza su propiedad ConnectionString para crear la cadena de conexión, la cual despliega un diálogo que facilita este procedimiento (ver Figura 7.6).

Figura 7.6.- Ventana de la propiedad ConnectionString

Seleccionado la opción “Usar cadena de conexión”, y el botón “Generar…”, aparece el asistente que se muestra en la figura 7.7, el cual permite seleccionar, tanto el motor (Proveedor), como el nombre de la base de datos (Conexión).

115

Visual Basic 6.0

Unidad 7.- Bases de datos

Figura 7.7.- Asistente para crear una conexión a un origen de datos ADO

c) Establecer el conjunto de registros: La propiedad CommandType define el tipo de origen de datos. La propiedad RecordSource, abre el diálogo que se muestra a continuación para seleccionar una tabla o escribir un texto SQL.

Figura 7.8.- Diálogo de propiedades para establecer el origen de registros

d) Enlazar controles a los datos del Recordset: Los controles enlazados se crean estableciendo las propiedades DataSource y DataField en tiempo de diseño; pero también se pueden establecer en tiempo de ejecución de la siguiente 116

Visual Basic 6.0

Unidad 7.- Bases de datos

manera. Suponga que el control de datos ADO tiene como nombre MiAdoDC, y que se desea enlazar una caja de texto MiCaja al campo Apellido de una tabla de datos (Recordset con CommandType = adCmdTable): Set Me.MiCaja.DataSource = Me.MiAdoDC.Recordset Me.MiCaja.DataField = "Apellido" También es posible mostrar todos los campos y registros utilizando el objeto DataGrid. Para lo cual, primero debe agregarse a la caja de herramientas mediante el diálogo de Componentes (Ctrl+T) seleccionado la opción Microsoft DataGrid Control 6.0 (OLEDB). En este caso sólo se especifica la propiedad DataSource, ya que no es necesario especificar un campo en particular. Suponga que el objeto DataGrid tiene el nombre MiDataGrid: Set Me.MiDataGrid.DataSource = Me.MiAdoDC.Recordset e) Utilizar el conjunto de registros: La propiedad Recordset del control de datos ADO hace referencia al conjunto de registros especificados mediante las propiedades CommandType y RecordSource. Suponga que el control de datos ADO tiene como nombre MiAdoDC:  Agregar un registro nuevo MiAdoDC.Recordset.AddNew  Guardar modificaciones del registro activo o del registro nuevo MiAdoDC.Recordset.Update  Cancelar una modificación o agregado de registro MiAdoDC.Recordset.CancelUpdate  Buscar un registro cuyo Apellido comience con el contenido de una caja de texto Dim Buscar As String Me.MiAdoDC.Recordset.MoveFirst Buscar = "Apellido Like '" & Me.Text4.Text & "*'" Me.MiAdoDC.Recordset.Find Buscar If Me.MiAdoDC.Recordset.EOF Then Me.Label1.Caption = "No se encontró" Me.MiAdoDC.Recordset.MoveFirst End If  Borrar el registro activo MiAdoDC.Recordset.Delete  Desplazarse al último registro MiAdoDC.Recordset.MoveLast  Mostrar la cantidad de registros del Recordset en un objeto etiqueta Me.label1.Caption = MiAdoDC.Recordset.RecordCount

117

Visual Basic 6.0

Unidad 7.- Bases de datos

7.3.4. Creación de objetos ADO en código a) Crear la referencia a la biblioteca de tipos ADO: Las referencias se establecen a través del menú Proyecto | Referencias, el cual despliega el diálogo que se muestra a continuación. Debe seleccionar Microsoft ActiveX Data Object 2.X Library.

Figura 7.9.- Ventana de referencias a librerías de objetos

b) Crear las variables de objeto: Para crear eventos en una variable tipo objeto se utiliza la sentencia WithEvents después de Dim, Public o Static. Dim WithEvents Cnn As ADODB.Connection Dim WithEvents Rst As ADODB.Recordset c) Crear los objetos Connection y Recordset: Se recomienda utilizar el evento Form_Load para este fin. Se utiliza la sentencia Set para la referencia a objeto. Set Cnn = New ADODB.Connection Set Rst = New ADODB.Recordset d) Abrir el objeto Connection: Es conveniente chequear previamente el estado de la conexión, ya que si esta se encuentra abierta, y se intenta abrir nuevamente, se producirá un error. Antes de abrir la conexión, se debe establecer la cadena de conexión mediante la asignación de la propiedad ConnectionString. If Cnn.State Then Cnn.Close Cnn.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;_ Data Source=C:\Notas.mdb" Cnn.Open e) Abrir el objeto Recordset: Al igual que el objeto Connection, es conveniente verificar previamente el estado del Recordset, ya se produce un error al intentar abrir un Recordset que ya está abierto. Para abrir el conjunto de registros (Recordset) se debe especificar la localización del cursor 118

Visual Basic 6.0

Unidad 7.- Bases de datos

(CursorLocation), el tipo de cursor (CursorType), el tipo de bloqueo de registros (LockType), la conexión activa, y el origen de registros. En el ejemplo siguiente, las propiedades CursorLocation y LockType se establecen de manera explícita, y el resto de las propiedades van implícitas en la misma línea de ejecución del método Open. If Rst.State Then Rst.Close Rst.CursorLocation = adUseClient Rst.LockType = adLockOptimistic Rst.Open "Alumnos", Cnn, adOpenDynamic f)

Enlazar los datos del Recordset a un control: Una vez mas, basta con establecer las propiedades DataSource y DataField del objeto que se desea enlazar, en este caso una caja de texto llamada MiCaja en la que se quieren mostrar los valores del campo Apellido: Set Me.MiCaja.DataSource = Rst Me.MiCaja.DataField = "Apellido" Si se desea mostrar todos los campos y registros utilizando el objeto DataGrid se debe especificar sólo la propiedad DataSource: Set Me.MiDataGrid.DataSource = Rst

g) Utilizar el conjunto de registros: El objeto Rst (Recordset) hace referencia al conjunto de registros especificados en la ejecución del método Open.  Agregar un registro nuevo Rst.AddNew  Guardar modificaciones del registro activo o del registro nuevo Rst.Update  Cancelar una modificación o agregado de registro Rst.CancelUpdate  Buscar un registro cuyo Apellido comience con lo que esté en una caja de texto Dim Buscar As String Rst.MoveFirst Buscar = "Apellido Like '" & Me.Text4.Text & "*'" Rst.Find Buscar If Rst.EOF Then Me.Label1.Caption = "No se encontró" Rst.MoveFirst End If  Borrar el registro activo Rst.Delete  Desplazarse al último registro Rst.MoveLast 119

Visual Basic 6.0

Unidad 7.- Bases de datos

 Mostrar la cantidad de registros del Recordset en un objeto etiqueta Me.label1.Caption = Rst.RecordCount 7.3.5. El diseñador de entorno de datos a) Agregar el diseñador de entorno de datos: Se debe visualiza el diálogo componentes (Ctrl+T) y seleccionar Data Environment de la pestaña Diseñadores:

Figura 7.10.-Diálogo Componentes (Diseñadores)

b) Agregar un entorno de datos: Al hacer clic en el menú Proyecto | Agregar Data Environment, se despliega el diseñador del entorno de datos como se muestra en la figura 7.11. Este diseñador permite configurar el objeto Entorno de datos con múltiples conexiones (Control, Escuelas) u objetos DEConnection, y para cada conexión se pueden especificar conjuntos de registros (Alumnos, Exámenes, Asistencia, Materias, etc.) u objetos DECommand.

120

Visual Basic 6.0

Unidad 7.- Bases de datos

Figura 7.11.-Diseñador del objeto Entorno de datos

c) Crear los objetos DEConnection y DECommand: Estos objetos se crean haciendo clic derecho sobre el objeto correspondiente. Por ejemplo para crear conexiones se hace clic derecho sobre el objeto de entorno de datos MiEntornoDeDatos. d) Crear los controles enlazados: Esta es una de las grandes ventajas de usar el diseñador del entorno de datos. Con la operación de arrastrar y colocar, los objetos enlazados se crean automáticamente sobre el formulario. Si no se desea utilizar esta facilidad, o si desea reconfigurar los controles enlazados en tiempo de diseño, se deben establecer las propiedades DataSource (Nombre del objeto entorno de datos: MiEntornoDeDatos), DataMember (Nombre de un objeto DECommand: Alumnos), y DataField (Nombre de uno de los campos de dataMember). Ahora en tiempo de ejecución, sólo se hace referencia al objeto Recordset correspondiente a un comando. Por ejemplo, el comando Alumnos crea automáticamente el objeto rsAlumnos de la clase Recordset. Set Me.MiCaja.DataSource = MiEntornoDeDatos.rsAlumnos Me.MiCaja.DataField = "Apellido" Igualmente para el control DataGrid, en tiempo de diseño habría que especificar las propiedades Datasource y DataMember; pero en tiempo de ejecución basta con hacer referencia al objeto Recordset relacionado al comando: Set Me.MiDataGrid.DataSource = MiEntornoDeDatos.rsAlumnos e) Utilizar el conjunto de registros: Los objetos rsAlumnos, rsExamenes, rsMaterias, etc., son de la clase Recordset, por lo tanto permiten manipular el conjunto de registros.  Agregar un registro nuevo MiEntornoDeDatos.rsAlumnos.AddNew  Guardar modificaciones del registro activo o del registro nuevo MiEntornoDeDatos.rsAlumnos.Update  Cancelar una modificación o agregado de registro MiEntornoDeDatos.rsAlumnos.CancelUpdate 121

Visual Basic 6.0

Unidad 7.- Bases de datos

 Buscar un registro cuyo Apellido comience con lo que esté en una caja de texto Dim Buscar As String MiEntornoDeDatos.rsAlumnos.MoveFirst Buscar = "Apellido Like '" & Me.Text4.Text & "*'" MiEntornoDeDatos.rsAlumnos.Find Buscar If MiEntornoDeDatos.rsAlumnos.EOF Then Me.Label1.Caption = "No se encontró" MiEntornoDeDatos.rsAlumnos.MoveFirst End If  Borrar el registro activo MiEntornoDeDatos.rsAlumnos.Delete  Desplazarse al último registro MiEntornoDeDatos.rsAlumnos.MoveLast  Mostrar la cantidad de registros del Recordset en un objeto etiqueta Me.label1.Caption = MiEntornoDeDatos.rsAlumnos.RecordCount 7.4. Lenguaje de consulta estructurado SQL 7.4.1. Introducción a SQL Como hemos visto, el modelo relacional se basa en el Lenguaje de Consulta Estructurado, mejor conocido como SQL. El lenguaje de consulta estructurado (SQL) es un lenguaje de base de datos normalizado, utilizado o incluido en el motor de base de datos para crear objetos RecordSet. También se puede utilizar con el método Execute del objeto Connection de ADO para manipular directamente lotes de registros de las bases de datos. Es posible crear “consultas SQL de paso a través” para manipular bases de datos remotas cliente-servidor. SQL es un lenguaje de programación, cuyos orígenes están estrechamente relacionados con la invención de las bases de datos relacionales por E. F. Codd a principios de los años 70. Un antecedente del actual SQL fue el lenguaje Sequel, razón por la cual SQL todavía se pronuncia en inglés como “Sequel” en vez de “letra a letra”, aunque las dos pronunciaciones son aceptables. El SQL moderno ha evolucionado hasta ser un estándar utilizado ampliamente en casi todas las bases de datos relacionales y se encuentra definido en la norma ANSI. La mayoría de las implementaciones de SQL tienen pocas variaciones respecto al estándar, incluyendo la versión admitida por el motor de base de datos Microsoft Jet. SQL tiene la ventaja de ser una interfaz de bases de datos normalizada, por lo que conocer los comandos SQL permite acceder y manipular una gran variedad de productos de bases de datos procedentes de distintos fabricantes. Para utilizar SQL desde Visual Basic, se debe construir la instrucción SQL en una variable tipo cadena de caracteres, la cual sirve de argumento para objetos de ADO. El lenguaje permite efectuar dos tipos de consultas: a) Consultas de selección: devuelven un conjunto de registros que se pueden manipular mediante el objeto RecordSet de ADO. Por ejemplo, habiendo 122

Visual Basic 6.0

Unidad 7.- Bases de datos

creado los objetos Cnn (Connection) y Rst (Recordset), se utiliza el método Open del objeto Recordset para obtener registros de la tabla Alumnos: Dim CadSQL As String CadSQL = “SELECT [Apellido], [Nombre] FROM Alumnos;” If Rst.State Then Rst.Close Rst.CursorLocation = adUseClient Rst.LockType = adLockOptimistic Rst.Open CadSQL, Cnn, adOpenDynamic b) Consultas de acción: realizan una operación sobre la base de datos o sobre uno o más registros de una tabla. Para este caso no es necesario crear el objeto Recordset, ya que las consultas de acción no devuelven registros. En su lugar se utiliza el método Execute del objeto Connection. El siguiente ejemplo elimina los registros de la tabla Alumnos con más de 25 inasistencias: Dim CadSQL As String CadSQL = “DELETE * FROM Alumnos WHERE [Inasistencia] > 25” If Cnn.State Then Cnn.Close Cnn.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;_ Data Source=C:\Notas.mdb" Cnn.Execute CadSQL Como se observa en los ejemplos anteriores, lo único nuevo es la construcción de la instrucción SQL, ya que los objetos ADO se siguen utilizando de la misma manera. A continuación veremos los elementos y sintaxis del lenguaje de consulta estructurado SQL. 7.4.2. Elementos del lenguaje SQL El lenguaje SQL está compuesto por (a) Comandos, (b) Cláusulas, (c) Operadores y (d) Funciones de agregado. Estos componentes, se combinan en instrucciones completas para seleccionar, actualizar, agregar o borrar registros de bases de datos. a) Comandos SQL Los comandos corresponden a las órdenes que se especifican mediante SQL, y en la sintaxis constituyen el inicio de cada instrucción. Comando SELECT UPDATE INSERT DELETE

Utilizado para Seleccionar un conjunto de registros de la base de datos y crear un Recordset. Modificar los valores de los campos de uno o más registros. Agregar uno o más registros a una tabla de base de datos. Eliminar uno o más registros de una tabla de base de datos. Tabla 7.10.- Algunos comandos de SQL

b) Cláusulas SQL Las cláusulas son condiciones de modificación utilizadas para definir los datos que desean seleccionar o manipular, y la forma como estos se presentan. Cláusula FROM WHERE GROUP BY HAVING ORDER BY

Descripción Especifica las tablas de las cuales se van a seleccionar los registros. Especifica las condiciones de los registros que se van a seleccionar. Separa los registros seleccionados en grupos específicos. Especifica las condiciones que deben satisfacer cada grupo generado por GROUP BY. Indica los campos para el ordenamiento de los registros. 123

Visual Basic 6.0

Unidad 7.- Bases de datos Tabla 7.11.- Algunas cláusulas de SQL

c) Operadores SQL Existen dos tipos de operadores en el lenguaje SQL, operadores lógicos y operadores relacionales. Los operadores lógicos se usan para conectar expresiones lógicas, normalmente dentro de una cláusula WHERE o HAVING. Para SQL los operadores lógicos son: AND, OR y NOT. Por otra parte, los operadores relacionales (ver Tabla 7.12) se usan para comparar valores relativos de dos expresiones. Operador < > = BETWEEN IN <= >= <> LIKE

Significado/Uso Menor que Mayor que Igual que Especifica un intervalo de valores Especifica registros de una base de datos Menor o igual que Mayor o igual que Distinto de Utilizado en la comparación de un modelo Tabla 7.12.- Operadores de comparación SQL

d) Funciones de agregado SQL Las funciones de agregado (ver Tabla 7.13) se usan dentro de una cláusula SELECT para devolver un único valor que se aplica a un conjunto de registros agrupados según cierto criterio. Función COUNT MAX AVG SUM MIN

Descripción Calcula el número de veces que aparece un valor en un campo especificado. Devuelve los registros con el valor más alto de un campo especificado. Calcula el promedio de todos los valores de un campo especificado. Calcula la suma de todos los valores de un campo especificado. Devuelve los registros con el valor más bajo de un campo especificado. Tabla 7.13.- Funciones de agregado SQL

7.4.3.

Consultas de selección (SELECT)

La instrucción SELECT se utiliza para recuperar registros de una base de datos en forma de un conjunto de registros, almacenándolos en un nuevo objeto Recordset. Las instrucciones SELECT no modifican los datos de la base de datos; sólo los recuperan. La sintaxis general de la consulta SELECT es la siguiente: SELECT listaCampos FROM nombresTablas IN nombreBaseDatos WHERE criteriosDeSelección GROUP BY listaCampos HAVING criteriosDeGrupo ORDER BY listaCampos [ASC|DESC] La consulta SELECT más simple, seleccionando sólo los campos Nombre y Apellido es: SELECT [Nombre], [Apellido] FROM Empleados; Sintaxis SQL: Los nombres de campos se colocan entre corchetes y se separan con comas. Las instrucciones SQL terminan con punto y coma. 124

Visual Basic 6.0

Unidad 7.- Bases de datos

Para seleccionar todos los campos de la tabla Empleados: SELECT * FROM Empleados; Sintaxis SQL: El asterisco en SQL indica todos los campos. Para el operador LIKE el comodín asterisco se sustituye por el caracter porcentaje %.

La cláusula WHERE especifica una condición para el filtrado de los registros. La cláusula GROUP BY permite agrupar el conjunto de registros, y HAVING determina los registros a filtrar una vez efectuado el agrupamiento. Mientras GROUP BY ordena los registros por el campo especificado, ORDER BY permite seleccionar otro campo de ordenamiento. Por ejemplo se pueden obtener todos los empleados contratados después del año 2000, cuyo apellido comienza con las letras “Ro” (Rodriguez, Román, Rosales,…), agrupados por el departamento al que pertenecen, y con sueldo inferior o igual a 500 mil Bolívares, además ordenado por apellido: SELECT [Nombre], [Apellido], [Departamento] FROM Empleados WHERE [Ingreso] > #31/12/2000# AND [Apellido] LIKE 'R%' GROUP BY [Departamento] HAVING [Sueldo] <= 500000 ORDER BY [Apellido] ASC; Sintaxis SQL: Las cadenas de caracteres se especifican entre apóstrofes. Las fechas se delimitan con el signo numeral. Los valores numéricos no utilizan delimitadores.

Las funciones de agregado se utilizan en la definición de campos de la consulta SELECT. El resultado de las funciones de agregado se adjudica a un alias mediante la palabra reservada AS. Por ejemplo, se puede calcular la suma de los sueldos de todos los empleados por departamento: SELECT [Departamento], SUM([Sueldo]) AS CostoDepartamento FROM Empleados; 7.4.4. Consultas de acción (DELETE, INSERT, UPDATE) a) Consulta de eliminación (DELETE) DELETE [tabla.*] FROM expresiónTabla WHERE criterios En el siguiente ejemplo se eliminan los registros de la tabla Empleados cuyo campo Estatus es igual Despedido. DELETE * FROM Empleados WHERE [Estatus] = 'Despedido'; b) Consulta de datos añadidos (INSERT)  Se puede ejecutar una consulta de datos añadidos con registros múltiples: INSERT INTO destino [IN baseDatosExterna] SELECT [origen.]campo1[, campo2[, ...] 125

Visual Basic 6.0

Unidad 7.- Bases de datos

FROM expresiónTabla Sería conveniente almacenar los registros de empleados despedidos en una tabla antes de ejecutar la consulta de eliminación en la tabla de empleados: INSERT INTO Despedidos SELECT * FROM Empleados WHERE [Estatus] = 'Despedido';  Se puede ejecutar una consulta de datos añadidos sobre un único registro: INSERT INTO destino [(campo1[, campo2[, ...]])] VALUES (valor1[, valor2[, ...]) Por ejemplo, para agregar un nuevo empleado a la tabla empleados: INSERT INTO Empleados ([Nombre], [Apellido], [Sueldo]) VALUES ('Pedro', 'Pérez', 500000) c) Consulta de actualización (UPDATE) UPDATE tabla SET Campo1 = nuevoValor1, Campo2 = nuevoValor2 WHERE criterios; UPDATE es especialmente útil cuando desea cambiar numerosos registros o cuando los registros que quiere cambiar están en múltiples tablas. Puede cambiar varios campos simultáneamente. El siguiente ejemplo incrementa el sueldo de todos empleados con 5 o más de 5 años de antigüedad en un 10 por ciento. Simultáneamente, se actualiza la edad del empleado. UPDATE Empleados SET [Sueldo] = [Sueldo]*1.1, [Edad] = DateDiff('yyyy', [Nacimiento], Date()), WHERE [Antiguedad] >= 5; 7.5. Reportes de bases de datos 7.5.1. Introducción a reportes Como instrumento de administración, el reporte o informe es usado para proporcionar a la gerencia los elementos necesarios para controlar una organización de forma efectiva. Los informes presentan los datos de una base de datos de una manera organizada, comprensiva y atractiva al usuario. Es posible generar pedidos, facturas, cartas, etiquetas de correos y otros de salida de datos. Los generadores de informe son programas especializados que cuentan con, además de motores de bases de datos, motores de impresión que se encargan de controlar todo lo relacionado al formato de las hojas de reporte. Visual Basic en su versión 6.0 incluye un generador de informes integrado como objeto de la clase DataReport. En versiones anteriores, y en la nueva versión .NET, se incluye un programa generador de informes conocido como Crystal Report. Dada la eficiencia de Crystal Report y su vigencia en nuevas versiones de Visual Basic, en esta guía se tratará este generador de informes. 126

Visual Basic 6.0

Unidad 7.- Bases de datos

7.5.2. Pasos para crear un reporte Para crear un informe con Crystal Report, previamente debe asegurarse que esté incluido en la lista de Diseñadores en la ventana de Componentes (Ctrl+T). De esta manera aparece como una de las opciones dentro del menú Proyecto del IDE de Visual Basic. Aunque es posible crear el reporte utilizando por separado el programa Crystal Report, y luego anexarlo al proyecto; los pasos que veremos a continuación se refieren al uso del generador de informes en forma integrada. a) Seleccione el menú Proyecto | Agregar Crystal Report 9. Aparece el cuadro de diálogo “Crystal Report Gallery”.

Figura 7.12.-Diálogo Crystal Report Gallery

b) Seleccione la opción correspondiente al tipo de creación de reporte, es decir; “Using the Report Expert”, “As a Blank Report” o “From an Existing Report”. En nuestro caso utilizaremos la primera opción, para la cual se habilita la lista de asistentes según el tipo de reporte, de la cual escogeremos “Standard”; y al presionar el botón OK se abre el asistente que se muestra en la figura 7.13.

127

Visual Basic 6.0

Unidad 7.- Bases de datos

Figura 7.13.-Diálogo de selección de Tablas para reportes

c) La opción “Create New Connection” incluye OLEDB (ADO), el cual despliega un sencillo asistente, parecido al del control de datos ADO, para seleccionar el motor y el archivo de base de datos. Al presionar el botón siguiente se abre el diálogo de selección de campos.

Figura 7.14.-Diálogo de selección de Campos para reportes

d) El siguiente cuadro de diálogo permite elegir uno o varios campos mediante los cuales se agrupan los datos en la presentación del reporte. Para nuestro ejemplo, los productos podrían agruparse por el campo fabricante.

128

Visual Basic 6.0

Unidad 7.- Bases de datos

Figura 7.15.-Diálogo para agrupar los registros de un reporte

e) El siguiente cuadro de diálogo permite elegir uno o varios campos mediante los cuales se filtran los datos con el objeto de mostrar sólo ciertos registros. Por ejemplo, se podrían mostrar sólo los productos cuyo campo Existencia tenga el valor de cero con el objeto de generar un listado de fallas o faltantes. Es importante hacer notar que al seleccionar un campo determinado, aparecen el en cuadro de diálogo dos cajas combinadas, una para seleccionar el operador relacional, y otra para seleccionar el valor de comparación.

Figura 7.16.-Diálogo para filtrar los registros de un reporte

A continuación se presenta un cuadro de diálogo con los estilos o plantillas de reporte disponibles, lo que facilita en gran medida la tarea de diseño. 129

Visual Basic 6.0

Unidad 7.- Bases de datos

Figura 7.17.-Diálogo para seleccionar la plantilla de diseño de un reporte

g) Finalmente el asistente consulta al usuario sobre dos aspectos. El primero solicita confirmación para crear automáticamente el formulario donde se presentará el reporte, y se recomienda tildar este aspecto positivamente. La segunda consulta es sobre la modificación automática de las propiedades del proyecto, la cual debe indicarse en NO para evitar que Crystal Report cambie el objeto inicial que se carga al ejecutarse la aplicación.

Figura 7.18.-Diálogo de confirmación para crear un reporte

h) A continuación, en el proyecto se crea un formulario nuevo y un objeto Crystal Report. También se puede observar el reporte en vista de diseño. Lo que queda es escribir el código necesario para mostrar el nuevo formulario (método Show).

130

Visual Basic 6.0

Unidad 7.- Bases de datos

7.5.3. Partes del generador de reportes En la vista de diseño, el generador de reportes presenta tres secciones básicas: Encabezado de página, Detalle y Pie de página. Tanto el encabezado como el pie de página albergan etiquetas, membretes, títulos de las columnas y cualquier otra información propia del informe. La sección que contiene los datos es la de detalle. En esta sección se colocan los campos de la base de datos.

Figura 7.19.-Vista de diseño de un reporte de Crystal Report

Cuando el informe se muestra en vista preliminar, el cuerpo de la página muestra los datos almacenados en la base de datos; y los campos especiales, como la fecha, se actualizan a la fecha del computador.

Figura 7.20.-Vista preliminar de un reporte de Crystal Report

131

Visual Basic 6.0

Unidad 7.- Bases de datos

7.5.4. Campos de un reporte Toda la información que aparece en un reporte está contenida en objetos gráficos denominados campos. Además de estos campos, la herramienta de diseño ofrece dos objetos gráficos para la creación de líneas y cuadros. A continuación veremos los tipos de campos más importantes que se pueden colocar en un reporte de Crystal Report.

Figura 7.21.-Tipos de campos de Crystal Report

a) Campos de base de datos: Son los campos que contienen información de las columnas de una tabla o Recordset de la base de datos activa. Se caracterizan porque se colocan en la sección Detalle del generador de informe y se corresponden con cada uno de los registros de la base de datos. Observación: Sólo deben arrastrase los campos seleccionados hasta la sección correspondiente del generador de informe.

b) Campos de texto: Estos campos se corresponden al objeto etiqueta conocido de Visual Basic. Un campo de texto es simplemente un campo que contiene texto independiente. Puede contener un único carácter, una palabra, frases completas o párrafos. Este es un comando usado para agregar etiquetas, títulos, notas al pie, disculpas, explicaciones, comentarios o cualquier otra clase de texto que fuera necesario. Para agregar un campo de texto, este se debe escoger de la clase TextObject en la caja de herramientas, para dibujarlo luego en la sección correspondiente. Observación:

Como el tamaño máximo de un campo de texto es 32K (incluyendo los caracteres retorno de carro y salto de línea), se recomienda que los campos de texto se usen sólo con bloques de texto de tamaño más manejable.

c) Campos de fórmula: Los campos de fórmula permiten crear un objeto de datos calculados. Una fórmula es una instrucción que establece ciertas acciones sobre determinados datos antes de imprimirlos en el informe. Crystal Report ofrece un editor de ecuaciones, el cual se activa automáticamente con el botón derecho del ratón y seleccionar New. El editor de ecuaciones contiene un conjunto de funciones 132

Visual Basic 6.0

Unidad 7.- Bases de datos

matemáticas, de cadena y otras, operadores de varios tipos y los campos de la base de datos activa para construir expresiones de cálculo.

Figura 7.22.-Editor de ecuaciones de Crystal Report

d) Campos especiales: La información adicional de un informe referida a fecha, número de página, número de registros, etc., se puede insertar utilizando los campos especiales. Los campos especiales son como los campos de fórmula, pero están predefinidos en el sistema.

Figura 7.23.-Campos especiales de Crystal Report

133

Visual Basic 6.0

Unidad 8.- Tecnología OLE

Unidad 8 Tecnología OLE “A pocos hombres les falta capacidad; si fracasan es porque les falta dedicación” .- Calvin Coolidge

8.1. Teoría de OLE 8.1.1. Estándar COM Visual Basic proporciona las herramientas que le permiten combinar objetos de distintos orígenes mediante la visión evolucionada de componentes de software, que se basa un estándar abierto y extensible conocido como el Modelo de Objetos Componentes (COM, Component Object Model). COM es una arquitectura o modelo de programación de plataforma independiente, distribuida y orientada a objeto para la creación de componentes de software (objetos) que puedan interactuar. Gracias a este estándar binario se pueden diseñar aplicaciones a partir de componentes que se comunican entre sí, que interactúan unos con otros, a través de un conjunto común de interfaces, con la velocidad y la sencillez de uso que caracteriza a Visual Basic. El Modelo de Objetos Componentes (COM), incluye la Automatización como el estándar de interoperabilidad, y ha permitido el desarrollo de las tecnologías que habilitan la interoperabilidad, conocidas como ActiveX. La Automatización es una característica del Modelo de Objetos Componentes (COM), y este a su vez forma la infraestructura de la especificación ActiveX. 8.1.2. Automatización La Automatización, antes denominada Automatización OLE, es un estándar usado por las aplicaciones para proveer objetos de una forma consistente a otras aplicaciones; en otras palabras, la norma que permite la comunicación entre objetos de las aplicaciones se conoce como Automatización. Se puede decir que la automatización es la parte de OLE que define, no sólo cómo se comparte el código entre las aplicaciones, sino también cómo se pueden compartir servicios públicos entre las mismas. La Automatización se usa típicamente para crear aplicaciones que ofrecen objetos a herramientas de programación y lenguajes de macros, para crear y manipular los objetos de una aplicación desde otra aplicación, o para crear herramientas para tener acceso a objetos y manipularlos. El uso de la Automatización en Visual Basic permite "tomar prestada" la funcionalidad de otras aplicaciones, al controlar sus objetos desde el interior de la aplicación de Visual Basic. Si se trata de un objeto de Automatización, se pueden emplear sus propiedades y métodos en el código. Cada objeto de Automatización es un bloque que puede utilizarse en código para recopilar y exponer información y funciones de otras aplicaciones, de forma que tengan sentido en la aplicación actual. Por ejemplo, se puede generar una aplicación que utilice Excel de Microsoft como 134

Visual Basic 6.0

Unidad 8.- Tecnología OLE

motor de cálculo, y cuyos informes se generen como documentos de Microsoft Word. Muchas de las aplicaciones actuales han aprovechado la Automatización para usar el código de otras aplicaciones. 8.1.3. Tecnología OLE y ActiveX Una aplicación completa se puede ofrecer como componente (objeto) a otra aplicación mediante una parte de ActiveX conocida como OLE. Se dice que la tecnología ActiveX incluye a la tecnología OLE, pero que no está limitada a ella. Mientras ActiveX se utiliza en forma general, OLE se enmarca en la creación y manipulación de documentos compuestos; es decir, documentos con distintos formatos. A pesar de esta diferenciación muchos autores coinciden en que OLE era la forma tradicional de referirse a lo que ahora se conoce como ActiveX. La palabra ActiveX es el nombre de marca de Microsoft para agrupar a las tecnologías que habilitan la interoperabilidad usando el Modelo de Objetos Componentes (COM). La interoperabilidad permite a componentes de software interactuar unos con otros sin tener en cuenta el lenguaje en que fueron escritos. Así, ActiveX (anteriormente OLE) facilita la integración de aplicaciones permitiendo que los programadores definan juegos de interfaces, grupos de métodos y propiedades a través de los cuales una aplicación accede a los servicios de objetos de otra aplicación. El concepto de ofrecer funcionalidad mediante interfaces estándar hace de ActiveX una tecnología abierta y extensible, ya que todas las aplicaciones basadas en ActiveX pueden definir y usar estas interfaces. La tecnología ActiveX permite ensamblar componentes software reutilizables en aplicaciones y servicios, conocidos como Componentes ActiveX. 8.1.4. Componentes ActiveX Un componente ActiveX es un fragmento reutilizable de código de programación y datos compuesto por uno o más objetos creados mediante la tecnología ActiveX. Un componente ActiveX es una unidad de código ejecutable, como un archivo .exe, .dll u .ocx, que sigue la especificación ActiveX para proporcionar objetos. Los componentes ActiveX le ofrecen al programador la capacidad de ensamblar aplicaciones sofisticadas a partir de piezas que ya existen, dentro de las cuales se encuentran: a) Componentes incluidos en las aplicaciones habilitadas para ActiveX Las aplicaciones compatibles con la tecnología ActiveX, como Microsoft Excel, Microsoft Word y Microsoft Access, proporcionan objetos que se puede manipular mediante programación desde la aplicación de Visual Basic. Por ejemplo, puede usar en su aplicación propiedades, métodos y eventos de una hoja de cálculo de Microsoft Excel o de un documento de Microsoft Word. b) Componentes de código ActiveX Los componentes de código (antes Servidores OLE) son bibliotecas de objetos programables que proporcionan una forma fácil de empaquetar el código para su reutilización. A diferencia de un objeto contenido en una aplicación habilitada para ActiveX, un objeto contenido en el componente de código se puede ejecutar en el mismo proceso que la aplicación, lo que permite un acceso más rápido al objeto. c) Controles ActiveX 135

Visual Basic 6.0

Unidad 8.- Tecnología OLE

Puede agregar características sin necesidad de crearlas, utilizando controles ActiveX como componentes. Un control ActiveX es una extensión del cuadro de herramientas de Visual Basic. Los controles ActiveX se usan como cualquiera de los controles estándar incorporados, como el control CheckBox. Cuando se agrega un control ActiveX, este pasa a formar parte del entorno de desarrollo y del tiempo de ejecución, y proporciona nueva funcionalidad a la aplicación. Los controles ActiveX incrementan la capacidad del programador conservando algunos métodos, propiedades y eventos ya familiares, como la propiedad Name, que se comportan como cabría esperar. Pero además, los controles ActiveX incorporan métodos y propiedades adicionales que aumentan enormemente la flexibilidad y capacidad del programador en Visual Basic. Existen controles ActiveX de diversos proveedores que ofrecen muchas características especializadas, como mostrar un calendario en un formulario o leer datos con un determinado formato. Por ejemplo, las ediciones Profesional y Empresarial de Visual Basic incluyen los controles Windows® Common, que permiten crear aplicaciones totalmente compatibles con las barras de herramientas, barras de estado y modos de ver de las estructuras de directorios de Windows en sus diferentes versiones. d) Documentos ActiveX Los documentos ActiveX le permiten crear aplicaciones interactivas para Internet. Se pueden definir formularios que pueden aparecer en ventanas de los exploradores de Internet. Los documentos ActiveX pueden mostrar cuadros de mensajes y formularios secundarios, y pueden contener controles ActiveX. Los documentos ActiveX también pueden funcionar como componentes de código. Además de los tipos de componentes ActiveX existentes antes expuestos, Visual Basic también permite al programador crear sus propios componentes. El desarrollo de componentes software mediante la tecnología ActiveX no se debe confundir con la programación orientada a objetos (OOP); ya que esta se ocupa de crear objetos, mientras que ActiveX se ocupa de que los objetos funcionen juntos. 8.1.5. Componentes en proceso y fuera de proceso Los componentes ActiveX interactúan con la aplicación y entre sí mediante una relación cliente-servidor. El cliente es el código de aplicación que utiliza las características de un componente. El servidor es el componente y sus objetos asociados. Dependiendo de la forma en que esté implementado, un componente ActiveX se puede ejecutar en el mismo proceso que las aplicaciones cliente o en un proceso diferente. En general, si un componente ActiveX se ha implementado como parte de un archivo ejecutable (.exe), se trata de un servidor fuera de proceso y se ejecuta en su propio proceso. Si se ha implementado como una biblioteca de vínculos dinámicos (.dll u .ocx), se trata de un servidor en proceso y se ejecuta en el mismo proceso que la aplicación cliente.

136

Visual Basic 6.0

Unidad 8.- Tecnología OLE

8.2. Aplicaciones habilitadas para ActiveX 8.2.1. Objetos insertables Hay tres categorías generales de controles en Visual Basic: los controles intrínsecos, los controles ActiveX, y los objetos insertables. Estos últimos son el caso de los componentes compatibles con la vinculación e incrustación de objetos admitido tradicionalmente por OLE. Se pueden insertar objetos componentes (como documentos de Word, u Hojas de cálculo de Excel) en una aplicación sin necesidad de escribir código, utilizando la interfaz visual del componente. Hay dos maneras de usar la interfaz visual de un componente: a) Agregando un control contenedor OLE a la aplicación, e insertando después un objeto en el control contenedor OLE. b) Agregando la clase del objeto al cuadro de herramientas, y después, agregando un objeto de esa clase a la aplicación, como lo haría con un control TextBox sobre el formulario. La clase es de un control de aplicación habilitada para ActiveX. 8.2.2. Control contenedor OLE El control contenedor OLE proporciona la máxima flexibilidad para usar la interfaz visual de un objeto. Un control contenedor OLE sólo puede contener un objeto cada vez. Hay varias formas de crear un objeto vinculado o incrustado en el control contenedor OLE una vez que se ha dibujado sobre el formulario. El método elegido dependerá de si va a crear el objeto vinculado o incrustado en tiempo de diseño o en tiempo de ejecución. A continuación veremos detalles de interés relacionados al control contenedor OLE, como incrustación y vinculación, formas de insertar objetos, las propiedades y métodos mas resaltantes del control, y algunas utilidades básicas. a) Incrustación y vinculación Si un objeto esta vinculado, se crea una referencia o apuntador al documento fuente, de tal manera que las modificaciones de los datos durante la ejecución se efectúan en el documento original. Si el objeto esta incrustado, se crea una copia del documento original en la aplicación, las modificaciones se efectúan sólo en y durante la aplicación de Visual Basic, y en consecuencia los cambios no son persistentes, ya que se pierden al terminar o detener la ejecución. El control contenedor OLE dispone de métodos para guardar los cambios de los datos de objetos incrustados mediante archivos binarios. b) Insertar objetos en tiempo de diseño Para insertar objetos en tiempo de diseño se utiliza el cuadro de diálogo Insertar objeto, o el cuadro de diálogo Pegado especial. El cuadro de diálogo Insertar objeto (ver Figura 8.1) aparece automática e inmediatamente después de dibujar el control contenedor OLE sobre el formulario. Este permite escoger entre crear un nuevo objeto, o utilizar un documento ya existente. Si se activa la casilla “Vincular”, el objeto que se crea es vinculado. También es posible escoger si se muestra el contenido del documento o el icono de la interfaz del documento. Si se cancela el cuadro de diálogo, el control OLE quedará vacío. En este caso las propiedades SourceDoc 137

Visual Basic 6.0

Unidad 8.- Tecnología OLE

y SourceItem en la ventana de propiedades permiten activar una vez más el cuadro de diálogo.

Figura 8.1.- Diálogo Insertar objeto

Por su parte, el cuadro de diálogo Pegado especial está disponible si se ha copiado algo en el portapapeles, y se puede activar haciendo clic derecho sobre el control contenedor OLE. La apariencia de este diálogo se muestra a continuación.

Figura 8.2.- Diálogo Pegado especial

c) Insertar objetos en tiempo de ejecución Se puede crear un objeto vinculado o incrustado desde un archivo, en tiempo de ejecución, con los métodos CreateLink o CreateEmbed del objeto contenedor OLE. Estos métodos requieren el argumento “documento fuente”, que es la ruta de acceso y el nombre del archivo desde el cual se crea el objeto. Opcionalmente, para objetos vinculados, se puede indicar el argumento “elemento fuente”, que especifica los datos que se desean vincular o incrustar del documento fuente. También, para objetos incrustados, es opcional indicar el argumento “clase”, para especificar el nombre de la interfaz que provee el objeto. El siguiente fragmento de código crea un objeto vinculado proveniente de la hoja de cálculo activa del archivo “prueba1.xls”, y consiste de las primeras 15 filas y 8 columnas: 138

Visual Basic 6.0

Unidad 8.- Tecnología OLE

OLE1.CreateLink "C:\EXCEL\PRUEBA1.XLS", "L1C1:L15C8" Para el caso de incrustación se especifica la clase, como se muestra: OLE1.CreateEmbed " C:\EXCEL\PRUEBA2.XLS", "Excel.Sheet" d) Propiedades del control contenedor OLE La siguiente tabla enumera las propiedades del control OLE. Propiedad Class DisplayType Object OLEType OLETypeAllowed SizeMode SourceDoc SourceItem

Descripción Identifica el objeto contenido en el control contenedor OLE. Presentación con su contenido o como un icono. Propiedad de sólo lectura, en ejecución, que indica la clase activa. Determina si un objeto se puede vincular o incrustar en el control OLE. Determina el tipo de objeto que puede crear (vinculado, incrustado). Determina el tipo de ajuste de tamaño de la imagen de los datos. Esta propiedad determina el archivo de origen del vínculo o la plantilla. Especifica los datos que se van a vincular dentro de un archivo. Tabla 8.1.- Propiedades del control contenedor OLE

La propiedad Class determina el tipo de objeto que contiene el control OLE. Por ejemplo, si contiene datos de una hoja de cálculo de Microsoft Excel versión 5.0, la propiedad Class es “Excel.Sheet.5”. Object es la propiedad que representa al objeto contenido en el control OLE, y se utiliza para realizar tareas de Automatización, que incluyen la manipulación por programa de las propiedades y métodos que el objeto admite. Mediante la propiedad SourceDoc se especifica la ubicación y el nombre del archivo de documento ActiveX. e) Métodos del control contenedor OLE La siguiente tabla muestra los métodos más importantes que dispone el control contenedor OLE. Método CreateEmbed CreateLink DoVerb InsertObjDlg PasteSpecialDlg SaveToFile ReadFromFile

Descripción Crea un objeto incrustado. Crea un objeto vinculado. Ejecuta el verbo especificado (o predeterminado) sobre el objeto; es decir: Abrir, Editar, Imprimir, etc. Muestra el cuadro de diálogo Insertar objeto, para escoger el objeto que contendrá el control OLE. Muestra el cuadro de diálogo Pegado especial, para pegar el contenido del Portapapeles en el control OLE. Guarda los datos de objetos incrustados en archivos binarios. Recupera los datos guardados en archivos binarios de objetos incrustados. Tabla 8.2.- Métodos del control contenedor OLE

Guardar y recuperar datos de objetos incrustados Los datos asociados con un objeto incrustado no son persistentes; es decir, cuando se cierra un formulario que contiene un control contenedor OLE, los cambios efectuados sobre los datos asociados al control se pierden si no se guardan previamente. Una vez que los datos se han guardado en un archivo, posteriormente puede abrir el archivo y restaurar los datos del objeto. Para esto sólo se pueden utilizar archivos binarios abiertos, y los métodos SaveToFile o ReadFromFile según corresponda. El procedimiento de guardado se ilustra a continuación: 139

Visual Basic 6.0

Unidad 8.- Tecnología OLE

Private Sub cmdGuardarOLE_Click() Open "PRUEBA.BIN" For Binary As #1 OLE1.SaveToFile 1 Close #1 End Sub

'Abrir archivo 'Guardar arch. 'Cerrar arch.

Y el procedimiento de evento siguiente permite la recuperación de los datos: Private Sub cmdRecuperarOLE_Click() Open "PRUEBA.BIN" For Binary As #1 OLE1.ReadFromFile 1 Close #1 End Sub

'Abrir archivo 'Leer archivo 'Cerrar arch.

Cada vez que se modifica el contenido de un objeto se llama al evento Updated. Este evento es útil para determinar si los datos de un objeto se han modificado antes de guardarlos. Para ello, establezca en el evento Updated una variable global que indique si es necesario guardar el objeto. g) Ejecutar el verbo predeterminado de un objeto Una vez que se ha cargado un objeto en el contenedor OLE, se puede ejecutar la acción o verbo predeterminado del objeto mediante el método DoVerb con argumento 0. La acción o verbo predeterminado es la operación que se lleva a cabo cuando se efectúa un doble clic sobre el documento fuente en una ventana o Explorador de Windows. En la mayoría de los casos, el verbo predeterminado es Editar. Otros verbos comunes son Abrir, Mostrar, Imprimir, etc. Por ejemplo, el siguiente fragmento de código activa la acción predeterminada del objeto contenido en OLE1: OLE1.DoVerb 0 'Cero para verbo predeterminado 8.2.3. Control de aplicación ActiveX De la misma forma que se utiliza el cuadro de herramientas para agregar a un formulario uno de los controles incorporados de Visual Basic, también puede usarse para agregar un objeto de aplicación habilitada para ActiveX. En primer lugar, se agrega la clase del objeto al cuadro de herramientas y, después, se agrega el objeto a un formulario. Para agregar la clase de un objeto al cuadro de herramientas se debe: a) Elegir Componentes en el menú Proyecto, o presionar Ctrl+T. b) Del diálogo Componentes, seleccionar la ficha Objetos insertables (ver Figura 8.3).

140

Visual Basic 6.0

Unidad 8.- Tecnología OLE

Figura 8.3.- Diálogo Componentes (Objetos insertables)

c) Seleccionar la clase que se desea agregar al cuadro de herramientas. Visual Basic agregará un botón de esa clase al cuadro de herramientas (ver Figura 8.4).

Excel

Word

WordPad

Paint

Graph

Figura 8.4.- Cuadro de herramientas (Objetos insertables)

Por ejemplo, para agregar al cuadro de herramientas un botón Hoja de cálculo de Excel, seleccione Hoja de cálculo de Microsoft Excel en la ficha Objetos insertables del cuadro de diálogo Componentes. Una vez agregada la clase del objeto al cuadro de herramientas, puede dibujarla en un formulario para crear un objeto de esa clase, es decir una hoja de cálculo de Excel sobre el formulario. 8.3. Componentes de código 8.3.1. Referencias a un objeto Si un componente ActiveX proporciona una biblioteca de tipos, es necesario agregar una referencia a la biblioteca de tipos en el proyecto de Visual Basic antes de poder usar los objetos de la biblioteca. Una biblioteca de tipos de un componente Active X contiene definiciones de todos los objetos que proporciona el 141

Visual Basic 6.0

Unidad 8.- Tecnología OLE

componente, incluidas definiciones para todos los métodos, propiedades y eventos disponibles. 8.3.2. Crear referencias a objetos Para crear una referencia a un objeto definido en una biblioteca de tipos es necesario: a) Elegir Referencias, en el menú Proyecto. En el cuadro de diálogo Referencias (ver Figura 7.9), seleccionar el nombre del componente ActiveX que contiene los objetos que desea usar en la aplicación. Se puede usar el botón Examinar para buscar el archivo de biblioteca de tipos que contiene el objeto que se necesita. Las bibliotecas pueden tener una extensión de archivo .olb (librería de objetos) o .tlb (librería de tipos). Los archivos ejecutables (.exe) y de biblioteca de vínculos dinámicos (.dll) también pueden proporcionar bibliotecas de tipos, por lo que también se pueden buscar archivos que tengan estas extensiones de archivo. b) Elegir Examinador de objetos, en el menú Ver, para ver la biblioteca de tipos a la que se ha hecho referencia, seleccionando la biblioteca de tipos apropiada en la lista Proyecto/Biblioteca del cuadro de diálogo Examinador de objetos (ver Figura 4.1). Se pueden usar todos los objetos, métodos y propiedades que se enumeran en el Examinador de objetos de la aplicación. c) Declarar una variable de objeto de la clase del objeto. Por ejemplo, se podría declarar una variable de la clase Excel.Chart para hacer referencia a un objeto Chart de Microsoft Excel. Dim xlChart As Excel.Chart d) Asignar una referencia de objeto a la variable utilizando la palabra clave New, CreateObject o GetObject en una instrucción Set. Si el objeto es dependiente (una hoja es dependiente de un libro en Excel), se debe asignar una referencia de objeto utilizando un método de un objeto de nivel superior en una instrucción Set. La asignación de referencia de objeto crea propiamente al objeto. En el ejemplo siguiente se abre el archivo Ingresos.xls como un libro de Microsoft Excel: Dim Libro As Excel.Workbook Set Libro = GetObject("C:\Cuentas\Ingresos.xls") Observe que antes de usar la instrucción Set, se aplica el punto (c) de declaración de la variable de objeto; en este caso se declara Libro como libro de Excel. 8.3.3. Utilizar las propiedades y métodos de un objeto Después de asignar una referencia de objeto a una variable de objeto (después de crear el objeto), puede usar la variable para manipular las propiedades y los métodos del objeto. Se mantiene la sintaxis objeto.propiedad para establecer y devolver los valores de la propiedad de un objeto o la sintaxis objeto.método para usar los métodos del objeto. Por ejemplo, para cerrar el objeto Libro, mediante su método Close. Libro.Close 142

Visual Basic 6.0

Unidad 8.- Tecnología OLE

8.3.4. Responder a los eventos de un objeto Para hacer que una aplicación responda a los eventos de un objeto proporcionado por componentes ActiveX, primero se debe declarar la variable de objeto mediante la palabra clave WithEvents, ya que los procedimientos de evento para los objetos proporcionados por componentes no están disponibles automáticamente. Después de declarar una variable de objeto mediante WithEvents, en la ventana de código la variable se utiliza para presentar procedimientos de evento para el objeto. Entonces se puede agregar código a estos procedimientos para responder a los eventos del objeto. En forma detallada, para crear un procedimiento de evento para un objeto proporcionado por un componente, se siguen los pasos a continuación: a) La declaración descrita en el punto (c) de 8.3.2, debe hacerse en la sección de declaraciones de un formulario o módulo de clase, utilizando la palabra reservada WithEvents de la siguiente manera: Dim WithEvents Libro As Excel.Workbook b) Al efectuar la declaración anterior, Visual Basic agrega y muestra el nombre de la variable de objeto al cuadro de lista Objeto de la ventana de código. Cuando selecciona la variable de objeto, Visual Basic muestra los procedimientos de evento del objeto en el cuadro de lista Eventos de la ventana de código (ver Figura 8.5).

Figura 8.5.- Ventana de código con eventos de un objeto componente

c) Finalmente, sólo resta seleccionar un procedimiento de evento y agregarle el código que se desea ejecutar cuando se produzca el evento. Por ejemplo, suponga que una aplicación de Visual Basic se basa en los datos presentados en un libro de trabajo de Microsoft Excel y que ya ha declarado una variable de objeto Libro con WithEvents para el libro de trabajo. Es necesario que cuando un usuario intente cerrar el libro de trabajo, la aplicación muestre un mensaje explicativo, y evite que se cierre el libro de trabajo, tomando en cuenta que los datos del libro son vitales en el normal funcionamiento de la aplicación. En 143

Visual Basic 6.0

Unidad 8.- Tecnología OLE

este sentido, el procedimiento de evento idóneo del objeto componente es Libro_BeforeClose. El fragmento de código siguiente muestra este procedimiento de evento y las líneas de instrucción que se ejecutarán al intentar cerrar el libro de trabajo. Private Sub Libro_BeforeClose(Cancel As Boolean) Libro.Application.Visible = False ' Oculta la ventana de Microsoft Excel. MsgBox "Este libro de trabajo debe seguir abierto..." ' Muestra el mensaje explicativo. Libro.Application.Visible=True ' Muestra nuevamente la ventana de Microsoft Excel. Cancel = True ' El argumento Cancel a True cancela el cierre. End Sub 8.3.5. Ejemplo completo usando componente de código Suponga que ha creado un formulario con tres cuadros de texto (Text1, Text2 y Text3) y un botón de comando (Command1), y ha agregado al proyecto una referencia a la biblioteca de objetos de Microsoft Excel (Microsoft Excel 11.0 Object Library). Se agregará código al procedimiento de evento Command1_Click del botón de comando que utilice el método Formula de Microsoft Excel para sumar dos números introducidos en Text1 y Text2, y que muestre el resultado en Text3, tal como se muestra: Private Sub Command1_Click() ' Declarar variables de objeto para Microsoft Excel. Dim Aplicación As Excel.Application Dim Libro As Excel.Workbook Dim Hoja As Excel.Worksheet ' Asignar referencias de objeto a las variables. Set Aplicación = New Excel.Application Set Libro = xlApp.Workbooks.Add Set Hoja = xlBook.Worksheets.Add ' Asignar los valores de las cajas de texto a celdas. Hoja.Cells(1, 1).Value = Text1.Text Hoja.Cells(2, 1).Value = Text2.Text ' Usar el método Formula para sumar los valores Hoja.Cells(3, 1).Formula = "=L1C1 + L2C1" Text3.Text = Hoja.Cells(3, 1) ' Guardar la hoja de cálculo (si lo desea). Hoja.SaveAs "C:\Temp.xls" ' Cerrar el libro de trabajo con el método Close. Libro.Close ' Cerrar Microsoft Excel con el método Quit. Aplicación.Quit 144

Visual Basic 6.0

Unidad 8.- Tecnología OLE

' Liberar los objetos. Set Aplicación = Nothing Set Libro = Nothing Set Hoja = Nothing End Sub 8.4. Controles ActiveX 8.4.1. Cargar controles ActiveX Los controles ActiveX tienen la extensión de archivo .ocx. Se pueden usar los controles ActiveX suministrados con Visual Basic o bien puede conseguir controles adicionales desarrollados por otros programadores en la Web o por otros medios. Los controles ActiveX de Visual Basic son controles de 32 bits. Algunos programadores ofrecen controles ActiveX de 16 bits, que no son compatibles para Visual Basic 6.0. Al igual que los objetos insertables, para usar controles ActiveX es necesario cargarlos previamente al cuadro de herramientas. Para agregar un control al cuadro de herramientas de un proyecto se siguen los siguientes pasos: a) En el menú Proyecto, haga clic en Componentes para mostrar el cuadro de diálogo Componentes, como se ve en las figuras 6.5 y 7.5. También se puede ver el cuadro de diálogo Componentes si hace clic con el botón secundario del Mouse (ratón) en el cuadro de herramientas, o presionando Ctrl+T. b) Los elementos que se muestran en este cuadro de diálogo incluyen todos los controles ActiveX registrados. Marque la casilla de verificación que hay a la izquierda del nombre del control. c) Haga clic en Aceptar para que todos los controles ActiveX que haya seleccionado aparezcan ahora en el cuadro de herramientas. Para agregar controles ActiveX al cuadro de diálogo Componentes, haga clic en el botón Examinar y busque los archivos que tengan la extensión .ocx. Estos archivos suelen estar instalados en el directorio \Windows\System o System32. 8.4.2. Archivos de controles ActiveX En la tabla siguiente se muestran los nombres de los componentes más comunes que del cuadro diálogo Componentes, sus archivos y los controles ActiveX que contienen. Nombre del componente Microsoft ADO Data Control 6.0 Microsoft Chart Control 5.5 Microsoft Comm Control 6.0 Microsoft Common Dialog Control 6.0 Microsoft Data Bound Grid Control 5.0 Microsoft Data Bound List Controls 6.0 Microsoft Data Grid Control 6.0 Microsoft Data List Controls 6.0 Microsoft FlexGrid Control 6.0 Microsoft Grid Control Microsoft Hierarchical Flex Grid Control 6.0 Microsoft MaskedEdit Control 6.0 Microsoft Multimedia Control 6.0

Nombre del archivo MSADODC.OCX MSCHART.OCX MSCOMM32.OCX COMDLG32. OCX DBGRID32.OCX DBLIST32.OCX MSDATGRD.OCX MSDATLST.OCX MSFLXGRD.OCX GRID32.OCX

ADO Data Control Microsoft Chart MSComm CommonDialog DBGrid DBList, DBCombo DataGrid DataList, DataCombo MSFlexGrid Grid

MSHFLXGD.OCX

MSHFlexGrid

MSMASK32.OCX MCI32.OCX

MaskedEdit Multimedia MCI

145

Controles ActiveX

Visual Basic 6.0

Unidad 8.- Tecnología OLE

Nombre del componente Microsoft PictureClip Control 6.0 Microsoft RichTextBox Control 6.0 Microsoft SysInfo Control 6.0 Microsoft TabbedDialog Control 6.0 Microsoft Windows Common Controls2 6.0 Microsoft Windows Common Controls3 6.0 Microsoft Winsock Control 6.0 Microsoft Windows Common Controls 6.0

Nombre del archivo PICCLP32.OCX RICHTX32.OCX SYSINFO.OCX TABCTL32.OCX MSCOMCT2.OCX

Controles ActiveX PictureClip RichTextBox SysInfo Microsoft Tab Control Animation, UpDown, MonthView, DTPicker, FlatScrollbar

COMCT332.OCX

CoolBar

MSWINSCK.OCX

WinSock TabStrip, Toolbar, StatusBar, ProgressBar, TreeView, ListView, ImageList, Slider, ImageCombo

MSCOMCTL.OCX

Tabla 8.3.- Archivos de controles ActiveX

En adelante se verá una introducción de algunos de los controles ActiveX de la tabla anterior, refiriéndose a los mismos por su nombre de clase. 8.4.3. Control ActiveX Animation El control Animation reproduce secuencias de vídeo AVI sin sonido. Una secuencia AVI está formada por una serie de marcos de mapas de bits, como una película. Un ejemplo es la hoja de papel que "vuela" de una carpeta a otra al copiar archivos en el sistema Windows.

Figura 8.6.- Ejemplo del control ActiveX Animation

Aunque las secuencias AVI pueden tener sonido, cuando lo tienen no pueden usarse con el control Animation y se producirá un error si intenta cargar un archivo de ese tipo. Sólo puede usar secuencias AVI sin sonido. Para reproducir archivos .avi con sonido, utilice el control Multimedia (MCI). Nota:

Encontrará diversos archivos .avi sin sonido en el directorio \Graphics\ AVI del CD-ROM de Visual Basic.

En tiempo de ejecución, el control Animation no tiene un marco visible. El control Animation mantiene un subproceso de ejecución independiente mientras se reproduce la secuencia. Por tanto, la aplicación no se bloquea y puede continuar la ejecución dentro de su proceso. Al usar el control, el archivo .avi se abre con el método Open, se reproduce con el método Play y se detiene con el método Stop. Una vez terminada la reproducción de un vídeo, puede usar el método Close para cerrar el archivo. No es necesario cerrar un archivo para poder abrir otro. En el código siguiente se utilizan dos controles CommandButton, cmdPlay y cmdStop. Como título de cmdPlay, 146

Visual Basic 6.0

Unidad 8.- Tecnología OLE

establezca "Abrir y reproducir". El título del control CommandButton cmdStop es "Detener". Private Sub cmdPlay_Click() anmAvi.Open "C:\Videos\FILECOPY.AVI" anmAVI.Play End Sub Este código detiene la reproducción del vídeo: Private Sub cmdStop_Click() anmAVI.Stop End Sub 8.4.4. Control ActiveX CoolBar El control CoolBar (Comctl332.ocx) permite crear barras de herramientas configurables por el usuario similares a las de Microsoft Internet Explorer. El control CoolBar es un control contenedor, capaz de contener otros controles secundarios. Consta de una o más zonas dimensionables conocidas como bandas. Cada banda puede albergar un único control secundario, como se muestra en la Figura 8.7.

Figura 8.7.- Ejemplo de control ActiveX CoolBar

El método para agregar controles secundarios a un control CoolBar varía ligeramente del método para agregar controles a otros contenedores. El control se debe asociar primero con un objeto Band; el límite de controles secundarios por banda es de uno, de tal manera que el control CoolBar contendrá tantos objetos como bandas. Para agregar un objeto a un CoolBar: a) Con el control CoolBar seleccionado, seleccione un control del Cuadro de herramientas y dibújelo sobre el control CoolBar. b) Abra la Página de propiedades de CoolBar y seleccione la ficha Bandas. c) Use los botones Index para seleccionar el índice del objeto Band en el que desea que aparezca el control. d) Seleccione el control de la lista Secundario. El control secundario se desplazará y se dimensionará con el objeto Band en tiempo de ejecución. Nota:

Si agrega simplemente un control sin asociarlo a una banda, aparecerá como un control flotante sobre el control CoolBar en tiempo de ejecución. Para evitarlo, establezca la propiedad Visible del control a False.

147

Visual Basic 6.0

Unidad 8.- Tecnología OLE

Puede modificar los controles contenidos en un CoolBar en tiempo de ejecución con la propiedad Child del objeto Band. 8.4.5. Control ActiveX DTPicker El control DateTimePicker muestra información de fecha, de hora o ambas a la vez y actúa como una interfaz en la que los usuarios pueden modificar la información de fecha y de hora. Cuando el control DateTimePicker está desplegado, aparece un calendario.

Figura 8.8.- Ejemplo del control ActiveX DTPicker

El control tiene dos modos de funcionamiento diferentes: a) En el modo Calendario desplegable (predeterminado, ver Figura 8.8) se muestra al usuario un calendario en el que puede selecciona una fecha. b) En el modo Formato de hora, el usuario selecciona un campo en la fecha u hora mostrada (por ejemplo el mes, el día, el año, hora, minuto, etc.) y establece su valor con la flecha hacia arriba o hacia abajo situada a la derecha del control. Puede usar el control para mostrar la fecha en los varios formatos preestablecidos, entre los cuales están: fecha corta (14/11/97), fecha larga (Viernes, 14 de noviembre de 1997) y hora (7:00:00 PM). También es posible especificar formatos personalizados mediante el uso de cadenas de formato. 8.4.6. Control ActiveX ImageList Un control ImageList contiene una colección de imágenes que pueden usar otros controles comunes de Windows, específicamente los controles ListView, TreeView, TabStrip y ToolBar. El uso del control ImageList como almacén único de imágenes le ahorrará tiempo de desarrollo, pues le permite escribir código que se refiera a un catálogo de imágenes único y coherente. En lugar de escribir código que cargue mapas de bits o iconos (con la función LoadPicture), puede llenar el control ImageList una única vez, asignar valores a la propiedad Key si lo desea y escribir código que utilice las propiedades Key o Index para hacer referencia a cada una de las imágenes. El objeto ListImage pertenece a la colección ListImages, y tiene las propiedades estándar de las colecciones: Key, Index y Count. También dispone de métodos estándar, como Add, Remove y Clear. Por último, el control presenta los métodos Overlay, Draw y ExtractIcon, que permiten crear imágenes compuestas, dibujar imágenes en los objetos que tengan la propiedad hDC y crear 148

Visual Basic 6.0

Unidad 8.- Tecnología OLE

un icono a partir de un mapa de bits almacenado en el control. Para agregar una imagen (objetos ListImage) en tiempo de diseño, utilice el cuadro de diálogo Páginas de propiedades del control ImageList: a) Haga clic con el botón secundario del Mouse (ratón) en el control ImageList y seleccione Propiedades. b) Haga clic en la ficha Imágenes para mostrar las páginas de propiedades del control ImageList, como se ilustra en la figura siguiente.

Figura 8.9.- Propiedades del control ActiveX ImageList

c) Haga clic en el botón Insertar imagen para mostrar el cuadro de diálogo Seleccionar imagen. d) Utilice el cuadro de diálogo para buscar los archivos de mapa de bits o de icono, y después haga clic en Abrir. e) Asigne un valor único a la propiedad Key. Para esto, haga clic en el cuadro Key y escriba una cadena. f)

Repita los pasos 3 a 6 hasta que haya llenado el control con las imágenes deseadas.

8.4.7. Control ActiveX TreeView El control TreeView está diseñado para mostrar datos de naturaleza jerárquica, como árboles organizativos, las entradas de un índice, o los archivos y directorios de un disco. Como veremos en forma detallada, un TreeView está formado por nodos u objetos Node (ver Figura 8.10).

149

Visual Basic 6.0

Unidad 8.- Tecnología OLE

Figura 8.10.-Ejemplo del control ActiveX TreeView

a) Establecer las propiedades del objeto Node Un "árbol" se compone de ramas sucesivas de "nodos" y cada nodo consta normalmente de una imagen (establecida con la propiedad Image) y una etiqueta (establecida con la propiedad Text). Un control ImageList asociado al control TreeView proporciona las imágenes para los nodos. Un nodo puede expandirse o contraerse dependiendo de si tiene o no nodos secundarios (nodos hijos que parten de él). En el nivel superior están los nodos "raíz" (padre), y cada nodo raíz puede tener cualquier número de nodos secundarios. El número total de nodos no está limitado (salvo por las restricciones del sistema). Cada nodo de un árbol es en realidad un objeto Node programable que pertenece a la colección Nodes. Como en otras colecciones, cada miembro de la colección tiene un valor único en las propiedades Index y Key, lo que permite el acceso a las propiedades del nodo. Por ejemplo, el código siguiente utiliza el índice de un nodo determinado ("7") para establecer sus propiedades Image y Text: tvwMiÁrbol.Nodes(7).Image = "cerrado" tvwMiÁrbol.Nodes(7).Text = "IEEE" Sin embargo, si se ha asignado al nodo una clave única (propiedad Key), por ejemplo "7 ID", el mismo código se podría escribir de esta forma: tvwMiÁrbol.Nodes("7 ID").Image = "cerrado" tvwMiÁrbol.Nodes("7 ID").Text = "IEEE" b) Relaciones entre nodos y referencias a nodos relativos Cada nodo puede ser secundario (hijo) o primario (padre), según su relación con otros nodos. El objeto Node cuenta con varias propiedades que devuelven distintos datos sobre los nodos secundarios o primarios. Por ejemplo, el código siguiente utiliza la propiedad Children para devolver el número de nodos secundarios (hijos) que tiene un nodo (el nodo 10): MsgBox tvwMiÁrbol.Nodes(10).Children Algunas de las propiedades no devuelven información numérica o de dato como lo hace Children, sino que devuelven una referencia a otro objeto Node. Por ejemplo, la propiedad Parent devuelve una referencia al nodo primario 150

Visual Basic 6.0

Unidad 8.- Tecnología OLE

(padre) de un nodo específico (hijo). Con esta referencia se puede manipular el nodo primario, como se muestra en el código siguiente para Text e Index del nodo primario de nodo 10: MsgBox tvwMiÁrbol.Nodes(10).Parent.Text MsgBox tvwMiÁrbol.Nodes(10).Parent.Index Puede usar la instrucción Set con una variable de objeto de tipo Node para manipular referencias a otros objetos Node. Por ejemplo, el código siguiente establece una variable de objeto Node con la referencia que devuelve la propiedad Parent. Después se utiliza la variable de objeto en lugar del objeto: Dim tempNode As Node ' Declara una variable de objeto. Set tempNode = tvwMiÁrbol.Nodes(10).Parent MsgBox tempNode.Text ' Devuelve la propiedad Text. MsgBox tempNode.Index ' Devuelve la propiedad Index. c) Agregar objetos Node a la colección Nodes Para agregar un objeto Node al árbol, utilice el método Add (colección Nodes). Este método tiene dos argumentos, relative y relationship, que determinan dónde se agregará el nodo. El primer argumento, relative, indica el nombre de un nodo, mientras que el segundo, relationship, especifica la relación entre el nuevo nodo y el indicado en relative. Por ejemplo, el código siguiente agrega un nodo denominado "nodo 11" como un nodo secundario de otro llamado "nodo 7". La constante intrínseca tvwChild especifica que el nuevo nodo es un nodo secundario (hijo) del indicado en el primer argumento. El tercer argumento asigna la propiedad Key al nuevo nodo. tvwMiÁrbol.Nodes.Add "nodo 7", tvwChild, "nodo 11" Otras relaciones posibles, además de tvwChild son las siguientes: Constante

Valor

tvwLast

tvwNext tvwPrevious tvwChild

2 3 4

Relación El nodo se coloca después de todos los nodos que están al mismo nivel que el indicado en relative. El nodo se coloca después del indicado en relative. El nodo se coloca delante del indicado en relative. El nodo pasa a ser un nodo secundario del indicado en relative. Tabla 8.4.- Constantes del argumento relationship

Por ejemplo, suponga que hay tres nodos y que desea colocar un cuarto nodo entre el segundo y el tercero. El código sería el siguiente: tvwMiÁrbol.Nodes.Add "nodo 2", tvwNext Otros argumentos del método Add son key, text e image. Con estos argumentos puede asignar las propiedades Key, Text e Image al crear el nuevo objeto Node. 8.4.8. Control ActiveX ListView El control ListView muestra datos en forma de objetos ListItem. Cada objeto ListItem puede tener un icono opcional asociado con la etiqueta del objeto. Este control es idóneo para representar subconjuntos de datos (como los miembros de una base de datos) u objetos discretos (como plantillas de documentos). Puede 151

Visual Basic 6.0

Unidad 8.- Tecnología OLE

funcionar junto con un control TreeView, para dar al usuario una visión ampliada de un nodo del control TreeView. El control ListView puede mostrar los datos en cuatro vistas diferentes: a) Iconos: permite arrastrar y colocar cada objeto y reorganizar los objetos.

Figura 8.11.-Ejemplo del control ActiveX ListView Vista Iconos grandes

b) Iconos pequeños: igual que iconos, pero permite que se vean más objetos ListItem.

Figura 8.12.-Ejemplo del control ActiveX ListView Vista Iconos pequeños

c) Lista: muestra una vista ordenada del objeto ListItems.

Figura 8.13.-Ejemplo del control ActiveX ListView Vista Lista

d) Informe: muestra una vista ordenada, donde los elementos secundarios permiten que aparezca información adicional.

152

Visual Basic 6.0

Unidad 8.- Tecnología OLE

Figura 8.14.-Ejemplo del control ActiveX ListView Vista Reporte

Para cambiar la vista, puede usar la propiedad View. Con la propiedad View puede permitir al usuario cambiar dinámicamente la vista. En el código siguiente se establece la propiedad View a vista de Informe (3), mediante la constante intrínseca lvwReport: ListView1.View = lvwReport Un objeto ListItem consta de una etiqueta (la propiedad Text) y una imagen opcional suministrada por un control ImageList. Sin embargo, el control ListView, a diferencia de otros controles, puede usar dos controles ImageList, que se establecen a través de las propiedades Icons y SmallIcons. En las vistas de: Lista, Iconos pequeños e Informe, puede usar iconos pequeños suministrados por un control ImageList, para representar cada objeto ListItem. Por el contrario, cuando está en vista de Iconos, el control utiliza un conjunto de imágenes distinto, suministrado por un segundo control ImageList. Para establecer las propiedades Icons y SmallIcons en tiempo de diseño, utilice el cuadro de diálogo Páginas de propiedades. Nota:

El control ImageList determina el tamaño de los iconos empleados. Los tamaños disponibles son 16 x 16, 32 x 32, 48 x 48 y Personalizado.

En el código siguiente se declara primero una variable de objeto de tipo ListItem y después se establece esa variable a un único objeto ListItem agregado a la colección con el método Add. A continuación se establecen las propiedades SmallIcon e Icon con la referencia de la variable de objeto: Dim itmX as ListItem Set itmX = ListView1.ListItems.Add() itmX.SmallIcon = "LibroPequeño" itmX.Icon = "LibroGrande" Una vez establecida las imágenes de un ListItem con las propiedades SmallIcon e Icon, estas aparecerán automáticamente al cambiar de vista con la propiedad View. En la vista Reporte, existen los objetos ColumnHeader y ListSubItem. Tanto la presencia como el número de objetos ListSubItem dependen de la presencia y el número de objetos ColumnHeader. Es decir, no puede crear ningún objeto ListSubItem si no hay presentes objetos ColumnHeader. Además, el número de objetos ColumnHeader determina el número de objetos ListSubItem que puede establecer para el objeto ListItem, que serán siempre uno menos que el número 153

Visual Basic 6.0

Unidad 8.- Tecnología OLE

de objetos ColumnHeader. Esto se debe a que el primer objeto ColumnHeader siempre está asociado a la propiedad Text del objeto ListItem. 8.4.9. Control ActiveX ToolBar Un control Toolbar contiene una colección de objetos Button con los que se crea una barra de herramientas que puede asociar a una aplicación. Normalmente, una barra de herramientas contiene botones que corresponden a elementos de algún menú de la aplicación, lo que proporciona una interfaz gráfica para que el usuario tenga un acceso rápido a las funciones y comandos utilizados con más frecuencia (ver Figura 8.15).

Figura 8.15.-Ejemplo del control ActiveX ToolBar

Para crear una barra de herramientas, debe agregar objetos Button a una colección Buttons. Cada objeto Button puede tener un texto y una imagen opcionales, indicados por un control ImageList asociado. El texto se establece con la propiedad Caption y la imagen con la propiedad Image de cada objeto Button. En tiempo de diseño, puede agregar objetos Button al control en el cuadro de diálogo Página de propiedades de Toolbar. Al hacer doble clic en una barra de herramientas en tiempo de ejecución se invoca el cuadro de diálogo Personalizar barra de herramientas, que permite al usuario ocultar, mostrar o reorganizar los botones de la barra de herramientas. También puede abrir el cuadro de diálogo Personalizar barra de herramientas si invoca el método Customize. Esto es posible siempre que se establezca la propiedad AllowCustomize en True. Si desea guardar y restaurar el estado de una barra de herramientas o permitir que el usuario final lo haga, utilice los métodos SaveToolbar y RestoreToolbar. La propiedad Style del objeto Button determina su comportamiento. A continuación se indican los cinco estilos de botones, con sus usos posibles: Constante

Valor

tbrDefault

TbrCheck

tbrButtonGroup

tbrSeparator

Uso posible Predeterminado. Puede usar el estilo Default cuando la función que representa el botón no depende de otras funciones. Además, al hacer clic en el botón, vuelve a su posición normal cuando la función ha terminado. Verificación. Debe usar el estilo Check cuando el botón representa una alternancia de algún tipo. De esta forma, cuando el botón está presionado, continuará así hasta que se presione de nuevo y queda liberado. Grupo de botones. Puede usar este estilo ButtonGroup cuando un grupo de funciones se excluyan mutuamente. Es decir, en un momento dado sólo una de las funciones que representa el grupo de botones puede estar activada. Separador. Este estilo Separator no tiene otra función que crear un botón de ocho píxeles de ancho. Puede usarlo para separar otros dos botones o para agrupar varios botones que tengan el estilo ButtonGroup. 154

Visual Basic 6.0

Unidad 8.- Tecnología OLE

Constante

Valor

tbrPlaceholder

Uso posible Marcador de posición. Este estilo Placeholder funciona como un botón "ficticio". Puede usarlo para crear un espacio en el control Toolbar donde desee que aparezca otro control (por ejemplo, un control ComboBox o ListBox). Tabla 8.5.- Estilos del objeto Button de ToolBar

El evento ButtonClick ocurre siempre que se hace clic en un botón (excepto en aquéllos con el estilo marcador de posición o separador). Puede identificar el botón en el que se ha hecho clic por sus propiedades Index o Key. Con cualquiera de estas dos propiedades, puede usar la instrucción Select Case para programar la función del botón, como ilustra el código del ejemplo siguiente: Private Sub tlbRTF_Click(ByVal Button As Button) Select Case Button.Key Case "AbrirArchivo" OpenFile Case "Guardar" SaveFile Case Else ' Otros casos. End Select End Sub 8.4.10. Control ActiveX TabStrip Un control TabStrip actúa como los separadores de un cuaderno o las etiquetas de un grupo de carpetas de archivador. Con el control TabStrip puede definir múltiples páginas en la misma área de una ventana o un cuadro de diálogo de una aplicación. El control consta de uno o más objetos Tab de una colección Tabs. En tiempo de diseño y en tiempo de ejecución puede modificar la apariencia de los objetos Tab si establece sus propiedades y además, en tiempo de ejecución, si invoca métodos para agregar y quitar objetos Tab o Ficha como se muestra en la Figura 8.16.

Figura 8.16.-Ejemplo del control ActiveX TabStrip

Para identificar la función de una ficha, puede asignar una imagen del control ImageList al objeto Tab. Para ello, primero debe asociar un control ImageList al control TabStrip, lo que puede hacer en tiempo de diseño o en tiempo de ejecución. Para crear objetos Tab en tiempo de diseño haga clic con el botón secundario del Mouse en el control TabStrip y, después, haga clic en Propiedades para abrir el cuadro de diálogo Páginas de propiedades.

155

Visual Basic 6.0

Unidad 8.- Tecnología OLE

8.4.11. Conclusiones sobre ActiveX Gracias a la tecnología ActiveX se ha logrado desarrollar componentes software, cuya característica principal es la interoperabilidad para su reutilización, lo que ha facilitado enormemente las tareas de programación de alto nivel. Estos fragmentos de código se han establecidos el nombre de Componentes ActiveX, dentro de los cuales se encuentran las aplicaciones habilitadas para ActiveX, los componentes de código, los controles ActiveX y los documentos ActiveX. Este último tipo de componente no se trata en esta guía, ya que involucra la creación de aplicaciones para Internet, lo que requiere a su vez la creación de componentes ActiveX, y esto corresponde a un curso de programación avanzada de objetos con Visual Basic. En todo caso, para usar los objetos de documentos ActiveX ya creados, se sigue el procedimiento descrito en el punto 8.4.1, como si fueran controles ActiveX.

156

Visual Basic 6.0

Unidad 9.- Funciones API

Unidad 9 Funciones API “Tu destino no es sólo saber, sino obrar de acuerdo a tus conocimientos” .- Fichte

9.1. Teoría de funciones API 9.1.1. Funciones API Las API son funciones externas a Visual Basic que se encuentran almacenadas y compiladas en archivos de extensión DLL y EXE. Las siglas API corresponden a Application Programming Interface o en español, Interfaz para la Programación de Aplicaciones. Estas funciones API están disponibles en diversos archivos, incluyendo los archivos DLL o EXE creados por el usuario con lenguajes de nivel intermedio como C++. Aunque existen incontables funciones API de distintos proveedores, en esta guía, nos dedicaremos al estudio de algunas de las funciones del sistema operativo Windows® exclusivamente. 9.1.2. Las API de Windows Como se explicó anteriormente, las funciones API del sistema operativo Windows están disponibles para efectuar tareas que Visual Basic no contempla dentro de sus funciones predefinidas o intrínsecas. Estas funciones del sistema operativo se encuentran almacenadas en archivos indispensables para Windows, conocidos como bibliotecas o librerías de vínculos dinámicos. Algunas de estas bibliotecas se muestran en la tabla siguiente. Biblioteca de vínculo dinámico Advapi32.dll Comdlg32.dll Gdi32.dll Kernel32.dll Lz32.dll Mpr.dll Netapi32.dll Shell32.dll User32.dll Winmm.dll Winspool.drv

Descripción Servicios, incluidas llamadas de seguridad y del Registro. Biblioteca de la API de diálogos comunes. Biblioteca de la API para dispositivos gráficos. Soporte común de la API base de 32 bits de Windows. Rutinas de compresión de 32 bits. Enrutadores de múltiples proveedores. Biblioteca de la API para redes de 32 bits. Biblioteca de la API para Shell de 32 bits. Rutinas para interfaces de usuario. Multimedia de Windows. Contiene las llamadas de la API a la cola de impresión. Tabla 9.1.- Archivos contenedores de funciones API

9.1.3. Declarar funciones API Para usar una función API en Visual Basic tal como se usa normalmente una función del sistema Basic, se deben efectuar tres pasos previos: 157

Visual Basic 6.0

Unidad 9.- Funciones API

a) Declarar la función mediante la sentencia “Declare” en un módulo estándar previamente creado. Declare Function NOM Lib “LIB” (Par1, Par2…) As Tipo b) Declarar las constantes públicas en el módulo estándar. Este paso es opcional y depende si la función utiliza alguna constante. Public Const Constante1 = Valor1 Public Const Constante2 = Valor2 c) Declarar las estructuras en forma pública en el módulo estándar. Este paso es opcional y depende si la función requiere de alguna estructura. Public Type ESTRUCTURA Campo1 As Tipo Campo2 As Tipo ... End Type La razón de utilizar un módulo estándar para efectuar las declaraciones, es que de esta manera la función API implementada quedaría disponible en forma pública para todos los módulos del proyecto. 9.1.4. Utilizar funciones API Una vez efectuadas las declaraciones correspondientes para hacer accesible una función API, esta podrá usarse como cualquier otra función a lo largo de su programa. En el ejemplo siguiente, se ha creado un módulo estándar en el cual se escribe el código necesario para declarar la función API de Windows “ExitWindowsEx”. Esta función permite apagar, reiniciar y cerrar la sesión del sistema Windows. ExitWindowsEx reside en el archivo USER32 que se mostró en la tabla 9.1, carece de estructuras y posee cuatro constantes, las cuales determinan el procedimiento a ejecutar por la función. Como se observa en el fragmento de código, la función ExitWindowsEx posee dos parámetros, uFlags que indica en tipo de procedimiento, y dwReserved que se coloca a cero por tratarse de un parámetro reservado. Public Public Public Public Public

Const EWX_FORCE = 4 Const EWX_LOGOFF = 0 Const EWX_REBOOT = 2 Const EWX_SHUTDOWN = 1 Declare Function ExitWindowsEx Lib "USER32" (ByVal_ uFlags As Long, ByVal dwReserved As Long) As Long

Luego, en cualquier parte del código del programa, se puede llamar a la función. En este caso, para el ejemplo, se utiliza el procedimiento de evento Click de un botón de comando para reiniciar el equipo (se usa la constante EWX_REBOOT): Private Sub cmdBotón_Click() Dim Ret As Long Ret = ExitWindowsEx (EWX_REBOOT, 0) End Sub

158

Visual Basic 6.0

Unidad 9.- Funciones API

También se puede apagar por completo el equipo, pero esta vez se deberá usar la constante EWX_SHUTDOWN: Private Sub cmdBotón_Click() Dim Ret As Long Ret = ExitWindowsEx (EWX_SHUTDOWN, 0) End Sub 9.1.5. Visor de texto API En el paquete de Visual Basic está incluida una utilidad para escribir rápidamente, de una manera sencilla y evitando errores humanos, las declaraciones, constantes y estructuras de las funciones API de Windows. Esta utilidad se conoce como el visor de texto API y su interfaz se muestra en la figura siguiente.

Figura 9.1.- Visor de texto API

La utilidad principal del visor de texto API consiste en que le evita al programador la tediosa tarea de tener que escribir las declaraciones necesarias para hacer accesible una función API. El programador selecciona la función, las constantes y estructuras, las copia y luego las pega en módulos del proyecto. Los elementos de la interfaz del visor de texto API se describen a continuación: a) En Tipo de API se selecciona el tipo de elemento que se buscará en el Cuadro de búsqueda, sólo escribiendo las primeras letras del nombre de la función, es decir, puede ser la declaración, las constantes o las estructuras. b) En elementos disponibles aparecerán las declaraciones, constantes o estructuras disponibles según se halla escogido en Tipo de API.

159

Visual Basic 6.0

Unidad 9.- Funciones API

c) En la sección Elementos seleccionados, aparecerán las declaraciones de la función, constantes o estructuras agregadas con el botón Agregar. Los elementos se pueden agregar públicos o privados. d) Mientras que el botón Quitar permite eliminar un elemento de la sección Elementos seleccionados, el botón Borrar elimina todos los elementos. e) Finalmente, se debe presionar el botón Copiar para colocar el contenido de la sección Elementos seleccionados en el portapapeles del sistema, esto con el objeto de pegar las declaraciones en el módulo estándar creado para tal fin. 9.2. Técnicas para usar funciones API 9.2.1. Resolver conflictos de nombre de API Ocasionalmente, los procedimientos de DLL tienen un nombre que no es un identificador válido, ya sea por un carácter inválido (por ejemplo, un guión) o porque coincida con una palabra clave de Visual Basic (por ejemplo, GetObject). En este caso, se utiliza la palabra clave Alias para especificar el nombre del procedimiento no válido. 9.2.2. Enviar cadenas a funciones API Visual Basic emplea un tipo de datos String conocido como BSTR, que es un tipo de datos definido por Automatización, y está formado por un encabezado, que contiene información acerca de la longitud de la cadena. Este tipo de datos se pasa como un puntero, por lo que el procedimiento de DLL es capaz de modificar la cadena. (Un puntero es una variable que contiene la ubicación en memoria de otra variable, en lugar de los datos reales.) Los datos BSTR son Unicode, lo que significa que cada carácter ocupa dos bytes. Por otra parte, los procedimientos de la mayoría de los archivos DLL reconocen los tipos LPSTR, que son punteros de cadenas de C terminadas con un carácter nulo. Los tipos LPSTR no tienen encabezado. Si un procedimiento de DLL espera un LPSTR (un puntero a una cadena terminada con un carácter nulo) como argumento, se pasa el tipo de datos de Visual Basic BSTR por valor. Puesto que los punteros del tipo BSTR son punteros al primer byte de datos de la cadena terminada con un carácter nulo, parecerá un tipo LPSTR para el procedimiento de DLL. Por ejemplo, la función sndPlaySound acepta una cadena que asigna nombre a un archivo de sonido digitalizado (.wav) y reproduce ese archivo. Private Declare Function sndPlaySound Lib "winmm.dll" _ Alias "sndPlaySoundA" (ByVal lpszSoundName As String, _ ByVal uFlags As Long) As Long Puesto que el argumento de cadena para este procedimiento se declara mediante ByVal, Visual Basic pasa un tipo BSTR que apunta al primer byte de datos: Dim SoundFile As String, ReturnLength As Long SoundFile = Dir("c:\Windows\System\" & "*.wav") Result = sndPlaySound(SoundFile, 1) 9.2.3. Recibir cadenas de funciones API La función GetWindowsDirectory verifica la instalación del sistema operativo y devuelve en una cadena la ruta completa del directorio donde se almacena Windows. No requiere de constantes ni de estructuras; sin embargo, el hecho de 160

Visual Basic 6.0

Unidad 9.- Funciones API

devolver una cadena, implica un tratamiento especial a la misma, y la necesidad de implementar una funciรณn auxiliar, tal como se estudiรณ en el objetivo 4.4. Este trato especial se debe a que las funciones API estรกn desarrolladas en lenguaje C, donde las cadenas poseen un carรกcter Nulo que indica fin de cadena; y en Visual Basic este carรกcter no existe. Por lo tanto, el caracter nulo de la cadena devuelta debe ser truncado o eliminado. El proceso se inicia declarando variables tipo cadena con longitud fija, y rellenando cada posiciรณn con espacios vacรญos, para luego utilizar la funciรณn API. A la cadena devuelta se le extirpa el carรกcter nulo y los subsiguientes espacios vacรญos sobrantes. A continuaciรณn tenemos la declaraciรณn de la funciรณn API GetWindowsDirectory: Public Declare Function GetWindowsDirectory Lib "kernel32" Alias "GetWindowsDirectoryA" (ByVal lpBuffer As String, ByVal nSize As Long) As Long Ahora una funciรณn personalizada se encarga de ejecutar todo el proceso, incluyendo la llamada de la funciรณn API: Public Function DirWindows() As String Dim ret As Long Dim Cadena As String * 200 Cadena = Space(200) ret = GetWindowsDirectory(Cadena, 200) If ret <> 0 Then Cadena = Left(Cadena, InStr(Cadena, vbNullChar) - 1) DirWindows = Trim(Cadena) Else DirWindows = "No existe directorio Windows" End If End Function En adelante, para obtener el directorio de Windows, bastarรก con utilizar la funciรณn DirWindows de la siguiente manera: Text1.Text = DirWindows() 9.2.4. Utilizar procedimientos generales auxiliares Para determinar el estado de ocupaciรณn y espacio libre de un disco, se puede utilizar la funciรณn API GetDiskFreeSpaceEx, la cual se declara a continuaciรณn: Public Declare Function GetDiskFreeSpace Lib "kernel32" Alias "GetDiskFreeSpaceA" (ByVal lpRootPathName As String, lpSectorsPerCluster As Long, lpBytesPerSector As Long, lpNumberOfFreeClusters As Long, lpTotalNumberOfClusters As Long) As Long Como se observa, el nombre de la funciรณn resulta bastante extenso, ademรกs de la cantidad de parรกmetros. En esta circunstancia es oportuno utilizar un procedimiento general que facilite el uso de esta funciรณn cada vez que se requiera. El procedimiento general Espacio cumple con esta funciรณn: 161

Visual Basic 6.0

Unidad 9.- Funciones API

Sub Espacio(Ruta As String, Cap As String, Libre As String) Dim ret As Long Dim P1 As Currency 'Bytes libres Dim P2 As Currency 'Capacidad del disco Dim P3 As Currency 'Espacio libre total ret = GetDiskFreeSpaceEx(Ruta, P1, P2, P3) Libre = Format(P1 * 1000) Cap = Format(P2 * 1000) End Sub La próxima vez que se deseen determinar las condiciones de capacidad del disco, basta con utilizar el procedimiento general Espacio: Dim Tamaño As String Dim Libre As String Espacio "C:\", Tamaño, Libre lblCapacidadDeDisco.Caption = Tamaño lblEspacioLibreDeDisco.Caption = Libre 9.2.5. Utilizar funciones API sin parámetros Existe una función API que devuelve el tiempo en milisegundos desde que se encendió el PC, denominada GetTickCount. Esta función no posee parámetros, ni constantes, ni estructuras, y es muy útil para generar retardos de tiempo para programas de juegos u otras aplicaciones. La declaración es la siguiente: Public Declare Function GetTickCount Lib "kernel32" Alias "GetTickCount" () As Long A diferencia del punto anterior (9.2.4), en estos casos se debe evitar el uso de funciones o procedimientos auxiliares como este: Function Tiempo() Tiempo = GetTickCount() End Sub Lo anterior no ofrece alguna ventaja significativa, y lo que realmente si ocasiona es más tiempo de procesamiento. Se puede pensar en un procedimiento que encapsule un conjunto de pasos para logra un objetivo en particular donde la función API intervenga. Tal es el caso del procedimiento siguiente para generar un retardo de tiempo: Sub Retardo(Tiempo As Long) Dim Inicio As Long Inicio = GetTickCount() Do While Not(GetTickCount >= Inicio + Tiempo) DoEvents Loop End Sub Luego, cuando sea necesario detener la ejecución de un programa (por alguna razón operativa) durante 10 segundos por ejemplo, bastará incluir la siguiente línea de código en la parte del programa donde se desea el retardo: Retardo (10000) 162

Visual Basic 6.0

Unidad 9.- Funciones API

Consideración final En esta guía sólo se han mostrado algunos ejemplos de utilidades de las funciones API. En realidad existe una enorme cantidad de funciones API y controles ActiveX, tanto en el sistema operativo Windows, como en otros; siendo Internet la principal fuente de ellos. Este es el inicio para el desarrollo de aplicaciones más robustas y profesionales. El programador mas destacado es aquel que aprovecha, no sólo las herramientas intrínsecas de Visual Basic, sino las provistas a través de la API y los componentes ActiveX. Esta es la línea divisoria que separa a los novatos, de los programadores avanzados. Aún queda algo de camino que recorrer: crear nuestros propios objetos, diseñar aplicaciones para redes incluyendo Internet con DHTML, agregar ayuda a las aplicaciones, controlar puertos u otro hardware del PC para desarrollos SCADA o similares, etc.; pero estamos armados con los fundamentos necesarios para alcanzar, muy pronto, el nivel de expertos. ¡Suerte programadores!

163