ndice de contenido

INTRODUCCIN................................................................................................................................................................4 1.1.- BREVE HISTORIA DEL BASIC.......................................................................................................................... 4 1.2.- CARACTERSTICAS Y VENTAJAS DEL VISUAL BASIC...............................................................................5 1.3.- VISUAL BASIC FRENTE AL BASIC TRADICIONAL ..................................................................................... 7 1.4.- SITUACIN DEL VISUAL BASIC EN EL MERCADO ACTUAL ................................................................... 7 INSTALACIN Y PERSONALIZACIN DEL VISUAL BASIC................................................................................... 19 2.1.- INSTALACIN....................................................................................................................................................19 2.2.- PERSONALIZACIN DEL ENTORNO DE TRABAJO DEL VISUAL BASIC.............................................. 22 CARACTERSTICAS GENERALES DEL ENTORNO DE PROGRAMACIN DEL VISUAL BASIC...................... 26 3.1.- INTRODUCCIN................................................................................................................................................26 3.2.- CONCEPTOS BSICOS DEL LENGUAJE VISUAL BASIC...........................................................................26 3.3.- DESCRIPCIN DEL ENTORNO DE TRABAJO DE VISUAL BASIC............................................................31 GENERACIN DEL INTERFACE GRFICO DE APLICACIONES............................................................................ 37 4.1.- DISEO GENERAL DEL INTERFACE GRFICO DE UNA APLICACIN................................................. 37 4.2.- ADICIN DE CONTROLES AL INTERFACE.................................................................................................. 39 4.3.- EJEMPLO DE OTRA APLICACIN..................................................................................................................45 PROPIEDADES................................................................................................................................................................. 49 5.1.- DEFINICIN....................................................................................................................................................... 49 5.2.- VENTANA DE PROPIEDADES......................................................................................................................... 49 5.3.- ESPECIFICACIN Y ESTABLECIMIENTO DE PROPIEDADES PARA UN DETERMINADO CONTROL .......................................................................................................................................................................................50 5.4.- EXTRACTO DE LAS PROPIEDADES MS UTILIZADAS............................................................................52 DESARROLLO DE PROGRAMAS EN VISUAL BASIC............................................................................................... 59 6.1.- PROYECTOS....................................................................................................................................................... 59 6.2.- OPCIONES DE AMBIENTE Y DE PROYECTO............................................................................................... 60 6.3.- CREACIN DE FICHEROS EJECUTABLES................................................................................................... 61 6.4.- DESARROLLO COMPLETO DE UNA APLICACIN.....................................................................................62 GENERACIN DE CDIGO EN VISUAL BASIC.........................................................................................................67 7.1.- INTERFACE GRFICO Y CDIGO DE LA APLICACIN............................................................................ 67 7.2.- PROCEDIMIENTOS........................................................................................................................................... 68 7.3.- IMPLEMENTACIN DE CDIGO EN LOS DIFERENTES ELEMENTOS DE UNA VENTANA...............69 EL LENGUAJE DEL VISUAL BASIC............................................................................................................................. 76 8.1.- INTRODUCCIN................................................................................................................................................76 8.2.- VARIABLES........................................................................................................................................................ 76 8.3.- TIPOS DE DATOS............................................................................................................................................... 78 8.4.- MDULOS.......................................................................................................................................................... 81 8.5.- PROCEDIMIENTOS........................................................................................................................................... 82 8.6.- ESTRUCTURAS DE CONTROL EN VISUAL BASIC..................................................................................... 86 8.7.- DESARROLLO DE UNA APLICACIN........................................................................................................... 90 8.7.- ARRAYS...............................................................................................................................................................94 8.8.- ESTRUCTURAS................................................................................................................................................100 DISEO DE MENS...................................................................................................................................................... 101 9.1.- INTRODUCCIN..............................................................................................................................................101 9.2.- CREACIN DE MENS.................................................................................................................................. 101 9.3.- CDIGO ASOCIADO A LOS MENS............................................................................................................ 104 9.4.- MENS DINMICOS.......................................................................................................................................105 9.5.- SUBMENS...................................................................................................................................................... 106 9.6.- ELEMENTOS DE LOS MENS.......................................................................................................................106 9.7.- CONTROL DE MENS EN TIEMPO DE EJECUCIN................................................................................. 107 9.8.- DISEO DE MENS POP-UP......................................................................................................................... 109 9.9.- LISTADO DEL PROGRAMA MENU.MAK.....................................................................................................111 CUADROS DE DILOGO..............................................................................................................................................114 10.1.- INTRODUCCIN............................................................................................................................................ 114 10.2.- TIPOS DE CUADROS DE DILOGO........................................................................................................... 115 10.3.- CUADROS DE DILOGO PREDEFINIDOS................................................................................................ 115 10.4.- CUADROS DE DILOGO A MEDIDA......................................................................................................... 117

10.5.- CUADROS DE DILOGO MS COMUNES ............................................................................................ 121 10.6.- CDIGO DEL PROGRAMA EJEMPLO CD.MAK....................................................................................... 124 GRFICOS...................................................................................................................................................................... 133 11.1.- INTRODUCCIN ........................................................................................................................................... 133 11.2.- DIBUJAR EN VISUAL BASIC., GENERALIDADES ..................................................................................133 11.3.- MTODOS GRFICOS.................................................................................................................................. 140 11.4.- CONTROLES GRFICOS.............................................................................................................................. 144 11.5.- PROPIEDADES AVANZADAS.......................................................................................................................154 11.6.- CDIGO DE LA APLICACIN GRAFICO.MAK.........................................................................................155 FICHEROS....................................................................................................................................................................... 168 12.1.- INTRODUCCIN............................................................................................................................................168 12.2.- TIPOS DE FICHEROS EN VISUAL BASIC.................................................................................................. 168 12.3.- CONTROLES PARA EL MANEJO DE FICHEROS...................................................................................... 179 CONTROL Y MANEJO DEL RATN............................................................................................................................186 13.1.- INTRODUCCIN............................................................................................................................................186 13.2.- SUCESOS ASOCIADOS AL RATN.............................................................................................................186 13.4.- APLICACIONES GRFICAS DEL RATN..................................................................................................190 13.5.- ARGUMENTOS DE LOS SUCESOS DE RATN.........................................................................................193 13.6.- DRAG AND DROP..........................................................................................................................................195 EL DEBUGGER...............................................................................................................................................................201 14.1.- INTRODUCCIN............................................................................................................................................201 14.2.- LA TCNICA DEL DEBUGGING..................................................................................................................201 14.3.- LOS ERRORES Y SUS CLASES.................................................................................................................... 202 14.4.- TIEMPO DE DISEO, TIEMPO DE EJECUCIN, MODO DE RUPTURA (BREAK MODE)..................204 14.5.- PUNTOS DE RUPTURA (BREAK POINTS).................................................................................................205 14.6.- EJECUCIN ARBITRARIA DE CDIGO.....................................................................................................206 14.7.- VENTANA "CALLS" ......................................................................................................................................207 14.8.- EXPRESIONES "WATCH"..............................................................................................................................208 14.9. LA VENTANA DEBUG.................................................................................................................................... 210 14.10.- MANEJO DE ERRORES ..............................................................................................................................211 14.11.- LISTADO DEL PROGRAMA ERROR......................................................................................................... 216 14.12.- LISTADO DEL PROGRAMA INSTALA......................................................................................................218 INTERFACE DE DOCUMENTO MLTIPLE (VENTANAS MDI)..............................................................................221 15.1.- INTRODUCCIN............................................................................................................................................221 15.2.- CARACTERSTICAS DE LAS VENTANAS HIJAS.....................................................................................222 15.3.- VISUALIZACIN DE VENTANAS MDI...................................................................................................... 222 15.4.- MENS EN VENTANAS MDI....................................................................................................................... 223 15.5 .- DISEO DE UNA BARRA DE HERRAMIENTAS...................................................................................... 224 15.6.- APLICACIN EJEMPLO: MDI.MAK........................................................................................................... 224 INTERCAMBIO DINMICO DE DATOS.....................................................................................................................236 16.1.- INTRODUCCIN............................................................................................................................................236 16.2.- CONCEPTOS BSICOS DE UNA CONVERSACIN DDE........................................................................236 16.3.- ENLACES EN UN INTERCAMBIO DINMICO DE DATOS.....................................................................237 16.4.- ENLACES DDE EN TIEMPO DE DISEO...................................................................................................237 16.5.- PROPIEDADES DEL ENLACE (LINK PROPERTIES)................................................................................ 239 16.6.- EVENTOS ASOCIADOS AL DDE................................................................................................................. 240 VINCULACIN E INCRUSTACIN DE OBJETOS (OLE).........................................................................................243 17.1.- INTRODUCCIN............................................................................................................................................243 17.2.- CONTROL OLE2 ...........................................................................................................................................244 17.3.- AUTOMATIZACIN OLE..............................................................................................................................250 LIBRERAS DE ENLACE DINMICO ........................................................................................................................ 253 18.1.- INTRODUCCIN............................................................................................................................................253 18.2.- DEFINICIN Y USO DE LAS DLLs............................................................................................................ 253 18.3.- DECLARACIN DE PROCEDIMIENTOS CONTENIDOS EN DLLs.......................................................254 18.4.- LLAMADAS A PROCEDIMIENTOS CONTENIDOS EN DLLs................................................................ 255 18.5.- DEFINICIN DE LOS TIPOS DE ARGUMENTOS.....................................................................................255 CUSTOM CONTROLS....................................................................................................................................................260 19.1.- INTRODUCCIN............................................................................................................................................260 19.2 TIPOS DE CUSTOM CONTROLS....................................................................................................................261 CONTROL DE ACCESO A BASES DE DATOS............................................................................................................278 20.1.- INTRODUCCIN............................................................................................................................................278

20.2.- BASES DE DATOS - CONCEPTOS BSICOS............................................................................................. 278 20.3.- CREACIN DE UNA TABLA........................................................................................................................ 280 20.4.- CONTROL DE ACCESO A BASES DE DATOS............................................................................................284 20.5.- ABRIR UNA BASE DE DATOS..................................................................................................................... 287 20.6.- RECORDSET................................................................................................................................................... 289 20.7.- AADIR, EDITAR Y BORRAR REGISTROS...............................................................................................291 20.8.- CONCEPTOS AVANZADOS.......................................................................................................................... 293 20.9.- ESTRUCTURA INTERNA DE LAS BASES DE DATOS............................................................................. 295 ACCESO A BASES DE DATOS:OBJETOS DE ACCESO A DATOS........................................................................... 297 21.1.- INTRODUCCIN............................................................................................................................................297 21.2.- CREACIN DE UNA BASE DE DATOS.......................................................................................................297 21.3.- LOS OBJETOS Y SUS PROPIEDADES.........................................................................................................301 21.4.- ABRIENDO UNA BASE DE DATOS............................................................................................................. 303 21.5.- COMPACTACIN DE BASES DE DATOS................................................................................................... 304 21.6.- REPARACIN DE BASES DE DATOS......................................................................................................... 305 21.7.- MANIPULACIN DE DATOS....................................................................................................................... 306 21.8.- PROPIEDADES DE LOS OBJETOS: TABLE, DYNASET, SNAPSHOT.....................................................309 21.9.- ORDENACIN DE REGISTROS...................................................................................................................309 21.10.- NAVEGACIN ENTRE REGISTROS......................................................................................................... 310 21.11.- UTILIZACIN DE LAS CONSULTAS........................................................................................................ 313 DISTRIBUCIN DE APLICACIONES VISUAL BASIC..............................................................................................315 22.1.- INTRODUCCIN............................................................................................................................................315 22.2.- UTILIDAD SETUPWIZARD.......................................................................................................................... 315 22.3.- HERRAMIENTAS DE INSTALACIN PERSONALIZADA....................................................................... 318

CAPTULO 1 INTRODUCCIN 1.1.- BREVE HISTORIA DEL BASIC

El BASIC (Beginners All-purpose Symbolic Instruction Code) naci en 1964 en Dartmouth Collegue, Hanover (New Hampshire), como un lenguaje orientado al aprendizaje de la programacin. En ese sentido, se defini como un lenguaje sencillo, robusto y que sirviera como punto de encuentro entre los alumnos y el ordenador. John Kemey y Tomas Kurzt nunca pensaron en el gran impacto que tendra, en la comunidad informtica mundial, el lenguaje que ellos desarrollaron. Muchos estudiantes observaron maravillados que podan escribir casi los mismos programas que antes, pero de una forma ms sencilla y sin entrar en las dificultades del FORTRAN (el FORTRAN ha estado ligado siempre al ambiente universitario y cientfico). Rpidamente, el BASIC fue teniendo adeptos en los ambientes informticos y su popularidad creci en paralelo a las versiones que de l se realizaban para las diferentes plataformas de desarrollo. En 1978 un comit estatal define la normativa del BASIC STANDARD. La aparicin de los ordenadores personales IBM PC, fue el gran detonante para la definitiva popularizacin de este lenguaje. Basta recordar, el ya mtico BASICA y su posterior versin, el GW BASIC. Un producto que revolucion el mundo del BASIC, fue la aparicin del primer compilador de BASIC para ordenadores compatibles (PC); el TURBO BASIC. Hay que decir, que partiendo de la filosofa de sencillez que emanaba del "concepto" BASIC este lenguaje estaba diseado conceptualmente como un intrprete, pero la demanda de rapidez en la ejecucin de los programas, hizo que el mercado informtico ofreciera rpidamente los compiladores BASIC . Los lenguajes de alto nivel trabajan traduciendo el cdigo de entrada, tambin llamado cdigo fuente (este cdigo fuente depende de la sintaxis del lenguaje escogido), a cdigo mquina, que es propio de cada familia de microprocesadores y es ejecutado directamente para obtener los resultados propios del programa que se intenta realizar .

Como es de todos sabido, hay dos tipos bsicos de traductores: los intrpretes y los compiladores. La diferencia entre ambos es clara, los primeros leen una lnea de cdigo y acto seguido efectan las acciones pertinentes, mientras que los segundos leen el cdigo y generan un fichero en cdigo maquina que se ejecutar posteriormente. Dentro de los compiladores de Basic destacaron dos, que en su tiempo fueron dos autnticos estndares de la programacin: el Quick Basic y el Basic PDS. El primero, que cont

con una gran difusin, estaba orientado al desarrollo de medias y pequeas aplicaciones, mientras que el segundo se destinaba al desarrollo de aplicaciones de carcter profesional. Sin embargo, la historia en general, y la historia de la informtica muy en particular, no se detiene y cuando pareca que estaba todo descubierto aparece un nuevo entorno de desarrollo que funciona bajo el DOS y que revolucionar, entre otras cosas, los conceptos de programacin. Nos estamos refiriendo, como no, al entorno Windows. Desde que en 1985 apareci en el mercado, Windows se ha caracterizado por su enfoque visual, que permite un rpido aprendizaje por parte del usuario y por una filosofa de trabajo que nace de la idea del Desktop Computing (informtica de sobremesa ), es decir, el usuario tiene a su disposicin toda una serie de programas, de carcter grfico y de similar aspecto, que puede ejecutar en su ordenador de sobremesa. Adems, no era frecuente el poder ejecutar varias aplicaciones a la vez e intercambiar datos entre ellas. Todas estas facilidades que Windows ofrece al usuario, se traducen en una enorme cantidad de complicaciones para el programador que se ve desbordado por las ms de 1200 funciones que posee Windows y por una metodologa de trabajo si no era excesivamente complicada, si muy estricta. Hasta la aparicin de Windows 3.0 la mayora de los diseos de programas se realizaban en C y se compilaban con la ayuda del Windows SDK (Windows Software Development Kit). Con la gran difusin que supuso el lanzamiento de la versin 3.0 de Windows, muchas compaas ofrecan lenguajes cuyo fin ltimo era rescatar al programador de las complicaciones del API (Aplication Program Interface) de Windows. As surgieron numerosos productos, algunos con gran xito comercial (Actor, Turbo Pascal, ToolBook, Borland C++, etc.). Microsoft respondi a esta creciente competencia lanzando al mercado un producto que, indudablemente, ha cambiado los conceptos dentro de la programacin bajo Windows: el Visual Basic.

Antes de la aparicin de Visual Basic, haba dos grandes tendencias entre los programadores de aplicaciones Windows. Por un lado, estaban aquellos que defendan un enfoque tradicional, es decir, seguan un modelo lineal de programacin estructurada (C, Pascal, etc.) y por otro, aquellos que se decantaron por el modelo de programacin orientada al objeto (Actor, Smaltalk, C++, etc.). Con Visual Basic surge un tercer concepto : la programacin visual, que est a mitad de camino de las dos anteriores.

1.2.- CARACTERSTICAS Y VENTAJAS DEL VISUAL BASIC

Cuando Microsoft sac al mercado la versin 1.0 de Visual Basic, muchos de los programadores pensaron que se trataba de una aplicacin de entretenimiento. Posteriormente, avanzaron en sus evaluaciones y lo utilizaron como herramienta para realizar rpidos prototipos

de aplicaciones, que una vez realizadas en Visual Basic, deberan ser reescritas en C, C++ , Pascal o cualquier otro "viejo" entorno de desarrollo. Con la versin 2.0 de Visual Basic los desarrolladores miran a este producto como una herramienta profesional y robusta con la que pueden realizar desarrollos finales, consumiendo mucho menos tiempo en el diseo de la aplicacin y por tanto aumentando su productividad. Con la comercializacin de la versin 2.0, Microsoft ha solventado las deficiencias anteriores y ha mejorado el ya de por s atractivo producto. Pocos meses despus del lanzamiento de Visual Basic 2.0, Microsoft dio un paso ms y lanz la versin 3.0. Esta versin si bien no introduce cambios en el entorno de trabajo de Visual Basic 2.0, si que aade importantes caractersticas entre las que destacan el OLE 2.0, controles para el acceso a bases de datos, creacin de programas de instalacin, etc. En el mes de Septiembre de 1995 se lanza la versin 4.0 de Visual Basic en la que se incorpora como novedad la posibilidad de creacin de aplicaciones de 16 y 32 bits. Pero es sin duda alguna la adopcin integral de la tecnologa OLE la caracterstica mas sobresaliente de esta nueva versin. Visual Basic 4.0 se presenta como un entorno de desarrollo potente y en su versin de 32 bits como un entorno de desarrollo corporativo donde la tecnologa cliente servidor cobra su verdadero sentido. Visual Basic es un entorno de desarrollo visual para Windows y DOS. Hay que destacar el adjetivo visual, como un nuevo concepto en la informtica de nuestros das, y que ser, sin lugar a dudas, el mtodo de programacin del futuro. No en vano, Microsoft ha desarrollado Visual C++, que est destinado a triunfar en la comunidad de los programadores en C++ y que unir el concepto de programacin visual con la potencia de la programacin orientada a objetos. Para crear un programa bajo Visual Basic se deben seguir tres pasos: - Creacin del interface de usuario, dibujando los controles que sean necesarios, creando mens, etc. - Definicin de las propiedades de los objetos que hemos dibujado. Estas propiedades, determinarn el comportamiento de los controles frente a acciones del usuario o de otros controles. - Generacin del cdigo necesario para responder a los eventos que ocurren en el interface. El programador novicio debe cambiar sus esquemas de programacin, antes de empezar a disear aplicaciones en Visual Basic, ya que es un entorno conducido por eventos. Esto significa, que el programador debe plantear su cdigo de una manera no lineal, pues no sabe de antemano el comportamiento del programa ante cada usuario final. (Aqu el diseo conducido por eventos se acerca a la programacin orientada a objetos y se aleja totalmente de la programacin lineal).

Visual Basic, se presenta ante el programador profesional, como un sistema objetivamente potente, capaz de desarrollar aplicaciones que exploten todas las caractersticas de Windows e incluso las ms avanzadas: MDI (Interface de documentos mltiples), OLE (unin e insercin de objetos), DDE (Intercambio Dinmico de Datos), acceso a todas las APIs del sistema, etc. Visual Basic puede ser expandido mediante los famosos "Custom Controls" o controles a medida (VBXs), los cuales son libreras de enlace dinmico (DLL's) que amplan las funciones del lenguaje. Generalmente, han sido producidos por terceras empresas, creando uno de los ms florecientes mercados de software de hoy en da. En la nueva versin 4.0 ha aparecido un nuevo estndar de controles personalizados denominados OCXs que son VBXs desarrolladas bajo la tecnologa OLE y que presentan una doble naturaleza de 16/32 bits.

1.3.- VISUAL BASIC FRENTE AL BASIC TRADICIONAL

Ya hemos mencionado antes la gran aceptacin que tuvo el Basic en los ambientes escolares, universitarios y entre los programadores noveles. Esta es la causa, por la que muchos programadores con amplia experiencia, han desdeado desde siempre al Basic al calificarlo como un lenguaje eminentemente didctico cuya nica aplicacin era la enseanza. Sin embargo, hay que decir que el Basic ha servido como plataforma de grandes desarrollos industriales. Baste sealar la cobertura que Microsoft ha dado a este lenguaje, pues no en vano, tena, como hemos dicho antes, dos compiladores de Basic: Quick Basic y Basic PDS. Desde la aparicin de Visual Basic para Windows y posteriormente con la versin para DOS, el mercado de los compiladores de Basic y del desarrollo de aplicaciones bajo Windows, se ha revolucionado y el xito de estos productos ha sorprendido incluso a Microsoft, que ha anunciado que ya no editar nuevas versiones de Quick Basic y BASIC PDS, pues han sido desplazados por Visual Basic. Microsoft ha comprobado, por el xito que han tenido sus versiones de Visual Basic para DOS y sobre todo para Windows, que el futuro de los lenguajes, pasa por la programacin visual conducida por eventos.

1.4.- SITUACIN DEL VISUAL BASIC EN EL MERCADO ACTUAL

La cuota de mercado que tena el Basic antes de la aparicin de Visual Basic, era muy importante. De hecho compaas lderes en el diseo de compiladores como Microsoft , tenan en sus catlogos varios compiladores diferentes. Desde la aparicin de Visual Basic 1.0, el mercado ha cambiado radicalmente. Este producto, ha ayudado, si cabe, ha promocionar el Basic entre los programadores de hoy, y sobre todo, a promocionar el Basic entre los programadores de aplicaciones bajo Windows.

Si hace tan solo tres aos, alguien hubiera dicho que la herramienta de desarrollo ms sencilla y una de las ms potentes para el entorno Windows iba a ser implementada en Basic, sera tachado, sin lugar a dudas, de loco y visionario. Pero la realidad se impone, y los conceptos de programacin visual y de programacin conducida por eventos, han revolucionado el mundo de la programacin, en especial, el mundo del desarrollo de aplicaciones Windows.

1.4.1.- VERSIONES Microsoft, lanz hace menos de dos aos un producto denominado Visual Basic 1.0. Este producto, era un entorno de desarrollo para programas Windows. En poco ms de seis meses, apareci Visual Basic Professional Edition, que incorporaba toda una serie de nuevas utilidades al Visual Basic 1.0. En diciembre de 1992 se present la versin para el DOS de Visual Basic que se denomino Visual Basic Standard Edition/DOS, a la vez que apareci otro producto que reuna toda una serie de mejoras respecto al anterior y que se denomin Visual Basic Professional Edition/DOS. Casi paralelamente a la aparicin de estos dos productos, Microsoft puso en el mercado una nueva versin del Visual Basic 1.0 que denomin Visual Basic 2.0 para Windows. Igual camino sigui la versin 3.0 de Visual Basic, la cual sali al mercado a mediados de 1993. Esta versin no supone unos cambios bruscos con la versin anterior pero aade importantes elementos especialmente relacionados al acceso a otras aplicaciones Windows. Visual Basic 4.0se presenta en tres versiones diferentes : Estndar, Profesional y Empresarial, en este libro trataremos sobre las caractersticas de la versin Profesional por ser esta la mas difundida en todos los mbitos del mercado.

1.4.1.1.- Visual Basic para Windows.

Como ya hemos dicho antes, Visual Basic para Windows 1.0 fue el producto pionero dentro del mercado del desarrollo visual. A finales de 1992, Microsoft sac al mercado la versin para Windows Visual Basic 2.0. Este producto, tambin cuenta con dos ediciones, la Estndar y la Profesional. Tan "solo" se diferencian, en que la versin Profesional posee una serie de utilidades que mejoran las caractersticas operativas de este producto y le da una potencia adicional necesaria para competir en el mercado de las plataformas profesionales de desarrollo. Gracias ha esta nueva versin, Microsoft ha solucionado muchas de las carencias de VB/Windows 1.0 y ha incluido un fcil acceso a todos los servicios potenciales que ofrece Windows 3.1 (MDI, OLE, arrays mayores de 64K , acceso a 256 colores , etc.). VB/Windows 2.0 nos ofrece la posibilidad de salvar la descripcin de las Forms en cdigo ASCII, se ha aadido una barra de iconos que nos facilitarn las tareas ms comunes (salvar y cargar ficheros, ejecutar y detener la aplicacin, etc.), la depuracin de errores es ms

eficiente, la ejecucin del programa resulta ms rpida, el editor se ha mejorado, el interface es ms flexible y se puede acceder a algunos de los aspectos de ms bajo nivel de Windows. Esta nueva versin cuenta con nuevos tipos de datos como es "Variant", que puede calificar a cualquier clase de informacin. As puede tomar un valor numrico en una sentencia y carcter en la siguiente. Han aumentado los controles estndar que vienen incluidos y se ha mejorado en ms de 20% la velocidad de ejecucin de los programas compilados con esta nueva versin. La versin Professional de VBWin 2.0 ofrece toda una serie de nuevos Custom Controls que sern muy apreciados entre los programadores. Entre los nuevos Custom Controls podemos destacar : Control de comunicaciones: que abrir a nuestros diseos la puerta del complicado mundo de las comunicaciones, permitindonos enviar y recibir datos por nuestro puerto serie. Controles 3D: pertenecientes a la casa SHERIDAN, que darn una atractiva apariencia tridimensional a nuestros desarrollos. Control de los Dilogos Comunes: que nos permitir aprovechar los dilogos estndar de Windows contenidos en COMMDLG.DLL . Control de Animacin: podemos crear secuencias animadas con bitmaps, en respuesta a una accin del usuario. Control de Grficos: podemos disear y manipular diversos estilos de grficos. Control MAPI: gracias a este control podemos utilizar desde nuestros programas el "Messaging Application Program Interface" que es el encargado de la gestin, a bajo nivel, del correo electrnico. Control Multimedia MCI: podemos grabar y reproducir cualquier tipo de fichero (audio, video, MIDI, etc.) compatible con las especificaciones Multimedia de Windows. Control Pen: orientado a aquellos desarrolladores que quieren comenzar a trabajar con la tecnologa Pen Computing. La versin profesional, tambin nos ofrece el compilador de ayudas, para que podamos disear los ficheros de ayuda para nuestros desarrollos, el kit de desarrollo de controles, mediante el cual y con ayuda de un compilador de C o de Pascal podemos programar nuestros propios "Custom Controls". Casi sin tiempo para asimilar la versin 2.0, Microsoft nos sorprende con la 3.0, tambin distribuida en edicin estndar y profesional. Los cambios ms importantes con respecto a la versin 2.0 son: en la edicin estndar: - control data para el acceso a bases de datos,

- control OLE 2, que incorpora las nuevas posibilidades de la tecnologa OLE - control Common Dialog, ya existente en la edicin profesional del 2.0, - posibilidad de crear mens pop-up, - SetupWizard, para la distribucin de programas. en la edicin profesional: - Crystal Reports, para la creacin de informes, - soporte para el acceso a datos, siguiendo la tecnologa de Microsoft Access, - control Outline, para la visualizacin de una lista jerrquica, mejoras en el mdulo de desarrollo de controles (CDK).

1.4.1.2.- Visual Basic 4.0.

Si partimos del irrefutable hecho que Visual Basic 3.0 es sin lugar a dudas el lenguaje de programacin ms extendido en nuestros das y que su crecimiento es el mayor entre todas la herramientas de desarrollo actuales, no nos debe sorprender la importancia que ha tenido la presentacin de la nueva versin de Visual Basic en el mercado informtico internacional. Microsoft est potenciando el Visual Basic como eje de su estrategia futura en campos tan diversos como plataforma rpida de diseo de aplicaciones, macro lenguaje comn entre aplicaciones Windows y como lenguaje de la Internet del futuro. Visual Basic 4.0 es la nueva versin que hizo su aparicin en el mercado el pasado mes de Noviembre; recordemos que se present como la herramienta estrella para el desarrollo de aplicaciones para Windows 95. Visual Basic 4.0 se presenta en 3 versiones diferentes ( Estndar, Profesional y Empresarial) y como dato a tener en cuenta, por primera vez en uetro mercado, podemos adquirir un lenguaje de programacin de propsito general en castellano ( se incluye manuales, ficheros de ayuda y entorno de desarrollo totalmente traducidos); observe el atnito lector la importancia que est dando Microsoft a este producto. Permtanme mencionar brevemente las capacidades de la versin estndar de Visual Basic 4.0. - Entorno nico de desarrollo de 32 Bits. - Acceso a bases de datos sin incluir el soporte para ODBC. - No incluye el conjunto de controles OLE profesionales. - No soporta la creacin de Servidores OLE. Como veras esta versin est orientada a aquellas personas u organizaciones que desean descubrir el potencial de esta herramienta pero que no necesitan las caractersticas avanzadas de las otras dos versiones. Esta, se hace ideal para la formacin inicial del personal en el entorno de desarrollo de Visual Basic, si bien es verdad que en mi modesto entender, recomendara optar inicialmente por cualquiera de las otras dos versiones. Antes de pasar a describir pormenorizadamente todas las capacidades de las versiones Profesional y Empresarial de Visual Basic 4.0 quisiera hacer un breve apunte de la importancia de la tecnologa OLE tanto en nuestros das como en un futuro cercano y su directa "presin" en nuestros desarrollos.

Si bien es verdad que OLE 1.0 surgi como una simple tecnologa que nos permita usar documentos compuestos, no es menos verdad que esta implementacin era frgil y de escasa utilidad. Con la aparicin de OLE 2.0 el escenario ha cambiado radicalmente. Esta tecnologa ( realmente habra que hablar de conjunto de tecnologas ) ha revolucionado el mundo de la programacin en el entorno Windows. No olvidemos que el futuro OLE 3.0 ser el eje del prximo sistema operativo orientado a objetos de Microsoft y que ser gracias a la Tecnologa OLE Automation la que permitir a los miles de programadores de Visual Basic liderar el desarrollo de aplicaciones para INERNET/INTRANET. Visual Basic 4.0 es sin lugar a dudas el contenedor OLE ms evolucionado de Microsoft y por este motivo se hace ideal como plataforma de desarrollo en la que las tecnologas de OLE jueguen un importante papel. Hagamos una pequea aclaracin de los tres conceptos que implica el nombre de Visual Basic que son en s diferentes niveles de un mismo lenguaje. Visual Basic : Es el lenguaje de desarrollo en si; incluyendo su entorno de desarrollo y su concepto de diseador visual de aplicaciones. Visual Basic para Aplicaciones : Es un subconjunto del lenguaje de Visual Basic que Microsoft ha adoptado como lenguaje comn de todas sus aplicaciones y que est licenciado a terceras compaas hasta convertirlo en el lenguaje universal del entorno Windows. Ya es conocido por todos la integracin total de la gama OFFICE con Visual Basic para aplicaciones. Son cada vez mas los programadores que estn realizando aplicaciones ofimticas integrando todos los productos de Oficce ( Word, Excel, Access, Project ) mediante Visual Basic. Visual Basic Script : Es un nuevo subconjunto de Visual Basic y junto a la Tecnologa de los Controles ActiveX sern la piedra angular de Microsoft en el campo de Internet/Intranet. Gracias a esta estrategia podremos integrar en los documentos HTML sentencias de Visual Basic Script que ser ejecutadas localmente y gracias a los Controles ActiveX integraremos controles OCXs mejorados en las paginas html. Ya hay acuerdos de licenciar Visual Basic Script a otras plataformas : Apple y Unix. Como vers, la importancia del Visual Basic en el mundo Windows es un hecho objetivo y ampliamente aceptado por la comunidad informtica. Pero centrmonos de nuevo en las versiones Profesional y Empresarial de Visual Basic 4.0. Voy a intentar describir las potencialidades de ambas versiones, si bien, quiero aclarar que la edicin Empresarial contiene todas las capacidades de la Edicin Profesional ms las que le son propias. Nadie se sorprender si decimos que el mundo de las aplicaciones de 16 bits, tecnolgicamente hablando, ha muerto; si bien es verdad que las transiciones son largas y que hoy en da la gran mayora de las aplicaciones instaladas son de 16 bits. Cualquier desarrollador se esfuerza en introducir las nuevas aplicaciones de 32 bits pero a menudo choca de frente con la cruda realidad del mundo empresarial e industrial, que no poseen equipos lo suficientemente potentes para dar el paso definitivo y todo ello acompaado por la inicial desconfianza a un nuevo sistema operativo. Visual Basic 4.0 se presenta en dos arquitecturas diferentes que comparten el mismo lenguaje y similar entorno de desarrollo. Es necesario indicar que ambas versiones se incluyen en el paquete de Visual Basic 4.0 y es a la hora de la instalacin donde decidiremos si queremos disponer de la

versin de 32 bits, 16 bits o de ambas. Si decidimos instalar ambas, tendremos directorios diferentes para cada una de las dos versiones. Realmente donde descubriremos todo el potencial de Visual Basic 4.0 es en el desarrollo de aplicaciones de 32 bits, donde podremos escoger entre diferentes arquitecturas multinivel y desarrollar nuestros propios servidores OLE y DLLs . La versin de 16 bits soporta el uso de VBXs y OCXs ( custom controls OLE ) de 16 bits mientras que la versin de 32 bits slo soporta los OCXs de 32 bits. No olvidemos que los controles VBXs dieron sin lugar a dudas el puesto predominante que tiene Visual Basic, pero el estndar VBX no estaba pensado para una arquitectura de 32 bits y tena algunas limitaciones. La versin de 32 bits incluye una serie de controles (OCXs) propios de Windows 95 que no existen en su hermana menor. El avispado lector se preguntar si existe una compatibilidad de cdigo entre ambas versiones. La respuesta es sencilla : SI. Tan solo tenemos que sustituir los OCXs de 16 bits por los de 32 bits y compilar de nuevo. Pero si nuestro programa contiene declaraciones de funciones del API de 16 bits de Windows tendremos que sustituirlas por las declaraciones de las mismas llamadas bajo el API de 32 bits. Visual Basic 4.0 ofrece dos facilidades para lograr la migracin en la declaracin de funciones del API: 1.- Compilacin Condicional : Esta nueva versin, soporta directivas de compilacin condicional que nos permitirn incluir/excluir cdigo en la compilacin. As la siguiente directiva detectar si est siendo compilado bajo un sistema operativo de 16 o 32 bits y en funcin de esto insertar unas determinadas declaraciones. # If Win31 = 1 Then Declare Function GetVersion Lib "Kernel" ( ) as Long # Else Declare Function GetVersion Lib" Kernel32" ( ) as Long # End If 2.- Desarrollo de Add-Ins propios que automaticen el proceso: Inicialmente tan solo diremos que los Add-Ins son servidores OLE que una vez compilados pasan a formar parte del entorno de desarrollo (IDE) de Visual Basic y que su utilidad radica en automatizar tareas en dicho entorno; en este mismo artculo encontrars informacin ms detallada sobre esta novedosa y til caracterstica de Visual Basic 4.0. Existen en el mercado varios Add-Ins que nos permitirn migrar las declaraciones de 16 a 32 bits automticamente, incluso como ejercicio de programacin te puedes plantear el diseo de un Add-In para lograr la migracin de plataforma. Entre las mejoras que podemos obtener con la migracin de nuestras aplicaciones a 32 bits, la velocidad no ser un factor decisivo sino la gran cantidad de barreras que los sistemas de 16 bits imponen al desarrollador; ya no tendremos que preocuparnos por los arrays mayores de 64 K, el numero mximo de lneas que soportada una caja de lista ( 32.767 lneas), se ampla el lmite de controles en una form, Thunking automtico entre aplicaciones, etc. Creo que es necesario hacer hincapi en que el cambio de la arquitectura de 16 bits a la de 32 no se debe tener en cuenta como argumento principal, el aumento de velocidad en las aplicaciones, sino toda la serie de nuevas tecnologas que ya son accesibles desde la arquitectura de 32 bits. S hay un aumento real de la

velocidad en el mundo de los 32 bits pero en ningn caso sirve como justificante nico de la migracin de aplicaciones de 16 a 32 bits. Baste un sencillo comentario al proceso de THUNKING. Cuando en un sistema conviven aplicaciones de 16 y 32 bits que operan en espacios de memoria separados y bien delimitados, necesitamos un mecanismo automtico que nos permita realizar llamadas desde aplicaciones de 32 bits a funciones de otras aplicaciones de 16 bits ( o viceversa) que se estn ejecutando en el sistema de una forma transparente al programador. Este mecanismo es el Thunking y su nico inconveniente es la sobrecarga que aade. Quiero retar a cualquier paciente lector a que trate de enumerar alguna plataforma de desarrollo de aplicaciones Windows que no incluya la capacidad de programacin orientada a objetos entre sus capacidades, Visual Basic ofrece un soporte limitado para la programacin orientada a objetos. Visual Basic surge como un lenguaje de orientado a eventos que por el contenido del entorno grfico subyacente ( Windows ) y de la reutilizacin de "objetos visuales" puede ser asimilado a un lenguaje orientado a objetos. En la prctica, la programacin en Visual Basic, se reduce a instanciar visualmente una serie de objetos ( visuales o no ) como pueden ser: Forms, Controles estndar, OCXs, etc. Posteriormente asignaremos valores a sus propiedades con lo que estableceremos su apariencia, definiremos sus comportamientos con la creacin de Rutinas y Funciones que respondern a determinados estmulos del mundo exterior o de otros objetos por medio de los eventos de cada objeto. Dicho as, parece que estamos describiendo un sistema de objetos ideal pero Visual Basic no soporta alguna de las caractersticas que definen tericamente a un sistema orientado a objetos. No existe soporte para la herencia, si bien es verdad que estn apareciendo utilidades que permiten una perfecta emulacin de dicha capacidad. Para integrarse ms en la tecnologa de la programacin orientada a objetos, esta nueva versin incluye un nuevo tipo de fichero denominado CLASS MODULE, en el que podemos definir las propiedades y funciones de cualquier objeto. Como el lector adivinar es posible cambiar la codificacin de una determinada clase, sin afectar al resto del programa, siempre y cuando no se hayan producido cambios su interface de comunicacin. Cualquier CLASE se compone de una serie de datos miembro que en Visual Basic denominaremos Propiedades y que generalmente declararemos como Private para encapsular dichos valores del resto de la aplicacin. Como generalmente tendremos que controlar el proceso de asignacin y consulta de dichas Propiedades, Visual Basic 4.0 incluye unas nuevos procedimientos Property ( Property Get, Property Set, Property Let), que son en esencia, procedimientos que se ejecutarn previamente a la asignacin y consulta de las propiedades. Para ejemplificar lo anteriormente dicho vamos a definir dentro de un fichero CLASS, la clase PERSONA con las propiedades Nombre y Edad y sus procedimientos Property : ' DATOS MIEMBRO DE LA CLASE PERSONA DE CARACTER PRIVADO Private sNombre as String Private iEdad as Integer ' PROCEDIMIENTOS PROPERTY DE LA CLASE PERSONA DE CARACTER PUBLICO 'este procedimiento se ejecutar en asignaciones del tipo MiPersona.Nombre = "Pablo" Public Property Let Nombre ( unNombre As String ) sNombre = UCase( unNombre ) End Property

'este procedimiento se ejecutar en asignaciones del tipo x$ = MiPersona.Nombre Public Property Get Nombre ( ) As String Nombre = sNombre End Property Tan slo nos faltara incorporar los mtodos o funciones que segn su mbito seran de carcter privado o pblico y que definiran el comportamiento de la clase en cuestin, si bien esto ya estara fuera del mbito de este articulo, baste aadir que las clases poseen per se, dos eventos cuya finalidad no pasar desapercibida a los programadores de C++; Initialize y Terminate. Estos eventos contendrn el cdigo que se ejecutara previo a la inicializacin/terminacin de un objeto. No quiero terminar esta breve introduccin a las posibilidades que ofrece Visual Basic 4.0 en el campo de los Objetos sin hacer una breve mencin al Objeto Coleccin (Collection). Las colecciones son conjuntos ordenados de objetos ( en el ms amplio sentido de la palabra ) que pueden compartir o no su naturaleza y que nos permitirn almacenar mltiples con gran sencillez y eficacia. As podramos definir una coleccin Personas que contendra todas las instanciaciones ( objetos) de la clase Persona que necesitemos. Anteriormente ya dijimos que Visual Basic se puede considerar como el contenedor/servidor universal de objetos OLE. Realmente podramos afirmar que Visual Basic est construido totalmente sobre la tecnologa OLE; el entorno de desarrollo es un servidor OLE, el propio lenguaje ( Visual Basic para Aplicaciones ) es en s otro servidor OLE. Visual Basic 4.0 es el contenedor deOLE ms perfeccionado. Sin lugar a dudas la aportacin mas importante de la tecnologa OLE en VB 4.0 es el nacimiento del estndar OCXs. Pero, qu es una OCXs ?. La respuesta no es sencilla, Tcnicamente hablando es un servidor OLE In Proccess que soporta la incrustacin de objetos ( Embedding ) pero no la unin ( Linking ), posee tambin soporte para la activacin in situ ( In Place Activation ) y por supuesto soporta OLE Automation. Como vers un simple OCXs es la aplicacin mas palpable de un conjunto de tecnologas de OLE 2.0, quiz sea el objeto OLE ms complicado si exceptuamos los nuevos Controles ActiveX que permitirn emplear la tecnologa de los OCXs a travs de Internet, sencillo, NO ? La creacin de servidores OLE es una de las caractersticas ms importantes que aporta esta nueva versin, gracias a estas facilidades podemos enfrentarnos sin temor a desarrollos, tanto local como remotamente distribuidos. OLE Automation es la tecnologa subyacente y la que hace posible crear servidores OLE que en s no son ms que aplicaciones que exponen sus objetos para que sean gobernados desde aplicaciones cliente. La creacin de servidores OLE remotos slo esta disponible en la versin Empresarial de Visual Basic 4.0 y ser tratada con posteriormente con amplio detalle, no debemos olvidar que la Automatizacin Remota es sin lugar a dudas la pieza clave de la versin Empresarial y la que ha permitido a Visual Basic desembarcar con inusitada rapidez en ambientes corporativos que le haban sido vetados hasta ahora. La creacin de un servidor OLE ( local ) o de una DLL OLE es un trabajo trivial por lo que no entrar en detalles; sin embargo me gustara comentar la diferencia entre ambas posibilidades y su impacto en nuestros desarrollos.

Hasta ahora las libreras dinmicas exportaban una serie de funciones que eran llamadas por las aplicaciones en tiempo de ejecucin (dinmicamente ), la ejecucin de dichas libreras se hacia dentro del espacio del programa cliente lo que evitaba llamadas entre diferentes procesos, siendo la velocidad de ejecucin la mayor beneficiada. La incorporacin de OLE ha permitido desarrollar libreras OLE DLL desde Visual Basic que como no posee capacidades de compilacin real no poda exportar funciones para la construccin de DLLs estndar. Esta nueva versin de Visual Basic es capaz de crear estas OLE DLLs a travs del Interface IDispatch a la par que soporta llamadas a las OLE DLLs con interface dual (Interface IDispatch o a la llamada tabla virtual de funciones VTBL). Desde el punto de vista del programador de Visual Basic, la diferencia entre una DLL tradicional y una OLE DLL slo la encontrara en que con el empleo de la segunda, no necesitara crear su tabla de declaracin de Funciones, tan solo necesitara dimensionar y crear dinmicamente una instancia del objeto a utilizar, estas tareas se realizan automticamente con las sentencias DIM, SET y NEW. Pero sorprndase el lector cuando compruebe que la nica diferencia para la construccin de una OLE DLL o de un Servidor OLE es tan solo la diferente eleccin de un elemento en el men Fichero.( Crear Archivo EXE o Crear Archivo DLL de OLE ). Pero cules son las diferencias reales entre un servidor OLE y una OLE DLL ?. La respuesta es sencilla, los servidores OLE son programas que se ejecutan en procesos separados del programa cliente con la ventaja adicional de seguridad que esto conlleva pero con la desventaja dela perdida de velocidad. El tiempo de acceso a funciones que se ejecutan en procesos separados es el doble del acceso a funciones que residen en un mismo proceso. Como veremos posteriormente el Servidor OLE puede ser ejecutado remotamente lo que le da una ventaja adicional sobre la OLE DLL. Visual Basic 4.0 expone el conjunto de objetos que componen su entorno de desarrollo (IDE). As, el entorno de desarrollo se convierte en un servidor OLE, gracias al cual podremos crear aplicaciones, que denominaremos ADD-INS, que permitirn controlar casi todas las actividades relacionadas con el desarrollo. Asi podremos crear ADD INS que faciliten o automaticen tareas de desarrollo, lo que redundar en nuestra productividad final. Hay que destacar la importancia real que esta facilidad ofrece a los desarrolladores, pues ya han aparecido ADD INS comerciales de indudable ayuda y cuyo uso se restringa a grandes entornos de desarrollo de tipo CASE, generalmente desconocidos en la plataforma PC. Visual Basic 4.0 nace con vocacin de herramienta de desarrollo corporativa y la funcionalidad que ofrece la posibilidad de la creacin de ADD-INS, tanto propia como de terceros, lo acerca definitivamente a las necesidades de los grandes y complejos desarrollos corporativos. Con la facilidad de la construccin y empleo de ADD INS, podremos disponer, entre otras, de las siguientes ventajas: - Control de Cdigo fuente. - Herramientas CASE - Herramientas de modelado de datos. - Ayudas al diseo. - Diseo y generacin de cdigo.

Dada la importancia del acceso a datos en la mayora de las aplicaciones actuales y ya que dicho acceso se convierte generalmente en la parte central y a la vez en la parte mas critica de los desarrollos, quiero tan solo esbozar las grandes capacidades que, en este rea, ofrece Visual Basic 4.0. Dejo para mi siguiente articulo : "JET, DAO y RDO" ; un pormenorizado anlisis de las diferentes tcnicas/tecnologas de acceso a bases de datos de las que dispone la Edicin Empresarial de Visual Basic 4.0. Microsoft JET Database Engine es la base de las gestin de Bases de datos en Visual Basic y en muchos productos de Microsoft ( ACCESS, VISUAL C++, etc. ). Como tal gestor es el encargado de la definicin de los datos( bases de datos, tablas, campos, ndices, relaciones, consultas) , gestin de la integridad, almacenamiento, manipulacin y consulta de dichos datos as como de la seguridad ( Usuarios y Grupos) y de la gestin multiusuario. Esta nueva edicin como novedad incluye el soporte las dos ultimas versiones de JET de Microsoft y que comentare brevemente. Microsoft Jet 2.5 : Esta nueva versin viene a mejorar el soporte para recuperacin de bases de datos corruptas e incluye un soporte mejorado para los nuevos drivers ODBC. Esta nueva versin incluye el potente motor de consulta Microsoft Query Engine optimizado, as como un soporte mejorado de transacciones. Se han aadido algunos cambios necesarios para ofrecer una compatibilidad total con Visual Basic para Aplicaciones lo que nos permitir emplear este motor de acceso y gestin de datos desde cualquier herramienta que soporte OLE Automation y VBA. Microsoft Jet 3.0 : Esta nueva versin esta totalmente compilada en cdigo nativo de 32 bits lo que aumenta en gran medida su rapidez. Pero quiz sea la adopcin de las capacidades multihilo lo mas novedoso, as la nueva versin del JET usa tres hilos para realizar tareas de lectura avanzada, escritura en segundo plano y cache lo que redunda en una mayor rapidez en el manejo de los datos. No es de sorprender que esta nueva versin introduzca las funciones de replicacin y sincronizacin, pues los complejos modelos de datos y los cada vez mas enmaraados diseos corporativos as lo demandaban. La Edicin Empresarial de Visual Basic 4.0 se hace prcticamente indispensable en equipos de diseo corporativo, donde la fiabilidad y la potencia del lenguaje se hace imprescindible. Como ya mencione la edicin Empresarial tiene las mismas capacidades que la versin Profesional y adems incorpora toda una serie de nuevas capacidades de las que destacaremos las que ofrecen una mayor importancia en el diseo de grandes aplicaciones corporativas. La importancia de las redes de ordenadores es cada vez mas notoria y el acceso a los servicios remotos se hace prcticamente imprescindible. Hasta ahora la tecnologa nos haba permitido desarrollar aplicaciones cliente - servidor en los que la parte cliente realizaba servicios de peticin y presentacin de los datos y la parte servidor gestionaba la bsqueda de dichos datos. Conforme la tecnologa avanza se nos ofrece posibilidades de arquitecturas multinivel. Gracias al acceso remoto proporcionado por OLE podemos crear aplicaciones cliente servidor multinivel donde la separacin de funciones no es tan rgida como en el diseo Cliente - Servidor tradicional .

Como ya vimos cualquier servidor OLE puede ser instanciado como un servidor remoto y puede "vivir" en cualquier parte de la red y lo mas importante de todo es que la conversin Local/Remoto es totalmente transparente para el programador, tan solo hay una variacin en el registro de Windows. El acceso remoto utiliza RPC para instanciar los diferente servidores OLE remotos a lo largo de la red. Estamos ante el destierro del NET DDE y el nacimiento del OLE RPC. Los servidores OLE Remotos pueden operar tanto sincrona como asincronamente. El primer paso para la construccin de un servidor Remoto es el desarrollo y testeo del servidor OLE localmente. Una vez que aseguremos el correcto funcionamiento del servidor lo trasladaremos a la maquina remota que deseemos. Hay que aclarar que el sistema operativo del ordenador remoto en el que residir nuestro recin creado servidor tiene que ser de 32 bits ( Windows 95 o Windows NT 3.51 ). No obstante los clientes de los servidores OLE pueden ser tanto de 16 bits como de 32 bits. Para que este servidor remoto atienda todas las peticiones de los clientes debe estar ejecutndose el Automation Manager que es tan solo un proxy stub que es el encargado de redireccionar todo el trafico entre los clientes y los servidores de una forma transparente para dichos programas. Si aplicamos esta tecnologa a la gestin de datos podemos definir un sistema de tres capas en el que la fuente de datos residir en un capa ( uno o varios ordenadores ), los objetos que definen las reglas de negocio ( reglas que gestionan el manejo y adquisicin de los datos ) en una capa intermedia y por ltimo los programas clientes residirn en la ltima capa. Como veras este es una anlisis ideal y debe quedar claro que no existe un limite real entre capas y/o servicios y que tampoco existe una correspondencia directa entre capas y ordenadores remotos. RDO : Si realizamos una aplicacin directa de todo lo relacionado con OLE Remoto y el modelo multicapa con la gestin de bases de datos, veremos que Visual Basic 4.0 nos ofrece un control de datos remotos (RDO) compatible con ODBC y toda una serie de Objetos OLE para el manejo de bases de datos. Realmente el RDO es un envoltorio del API de ODBC que permite prescindir de la sobrecarga que supone la utilizacin del JET para el acceso remoto a fuentes de datos ODBC. As veremos que el JET esta especialmente indicado para la gestin de bases de datos locales mientras que el RDO esta orientado parar el acceso remoto va ODBC a SQL Server 6.x y Oracle 7.x.

1.4.1.3.- Visual Basic para DOS.

El lanzamiento de la versin de Visual Basic para DOS, no tiene otro sentido que el de actualizar y homogeneizar el mercado de Basic dentro del sistema operativo DOS. Este producto, posee una total compatibilidad de cdigo con aquellas aplicaciones que han sido diseadas con Quick Basic o con BASIC PDS. As Visual Basic para DOS servir para reconducir el mercado del Basic hacia la programacin visual y hacia la programacin conducida por eventos respetando la compatibilidad con los "viejos" programas. Es firme decisin de Microsoft, el dejar de comercializar los viejos productos como son Quick Basic y Basic PDS y promocionar el Visual Basic tanto para Windows como para DOS.

Hay que decir, que las versiones para Windows y para DOS de Visual Basic no son totalmente compatibles a nivel de cdigo, debido fundamentalmente, a la diferencia entre las funciones del DOS y de Windows. Al igual que su hermano, el Visual Basic para Windows, la versin DOS se presenta en dos productos: Standard Edition: plataforma base de este compilador, genera programas EXE, utiliza "Custom Controls", su programacin se realiza en modo de texto y genera automticamente el cdigo asociado al interface. Dada la compatibilidad con Quick Basic y PDS el programador tiene ms libertad al usar el modo de programacin conducida por eventos o el modo de programacin lineal. Professional Edition: este producto es el mismo que el anterior al que se le han aadido toda una serie de programas y caractersticas suplementarias. La versin para DOS viene acompaada de nuevos controles, que harn las delicias de los programadores profesionales. Adems, a diferencia del VB/Windows, es posible crear Custom Controls en el propio lenguaje. Recordemos, que en la versin para Windows, los Custom Controls no se podan crear en Visual Basic, sin que haba que echar mano de otros lenguajes como pueden ser el C, C++, Pascal. Evidentemente, esto otorga mucha potencia a la aplicacin, abriendo infinitas posibilidades de ampliacin. Dentro de los programas y utilidades aadidas, podemos destacar: facilidades de manejo de bases de datos (ISAM), rutinas para el manejo de grficos de datos, rutinas financieras, funciones matemticas complejas, manejo de ayuda sensitiva al contexto, etc. Visual Basic para DOS cuenta con un traductor binario que convierte las descripciones binarias de una Form entre los formatos de VBDOS y VBWin. Tambin cuenta con un Profiler que utilizaremos para optimizar el cdigo de nuestros programas. El paso siguiente de cualquier programador que inicie sus diseos en VB DOS ser el complementarlos, realizando una nueva versin para Windows. Hay que recordar que el cdigo no es compatible entre las versiones para DOS y para Windows de Visual Basic pero los cambios necesarios para transportar una aplicacin no son demasiado radicales.

CAPTULO 2 INSTALACIN Y PERSONALIZACIN DEL VISUAL BASIC 2.1.- INSTALACIN

Como bien sabemos todos los que alguna vez hemos tenido ocasin de instalar algn paquete de software ms o menos complejo, los procesos de instalacin de la mayora de programas comerciales resultan tediosos y bastante aburridos. Sin embargo, una buena instalacin suele permitir una ejecucin del programa ptima, de ah que sea importante hacer un pequeo sacrificio al principio, para evitar a la larga tener que repetir el proceso. A pesar del considerable esfuerzo realizado por las compaas de software para ofrecer una instalacin sencilla y entretenida, no deja de ser una labor poco deseable. Los procesos de instalacion bajo Windows, aunque pesados, al menos resultan ms atractivos que los desarrollados para DOS. El caso que nos ocupa, tampoco es de los ms alarmantes y aunque depende del ordenador que tengamos, en unos 30 minutos podemos tener hecha la instalacin completa del Visual Basic 3.0 en su edicin profesional. Pues bien, intentaremos en este captulo que la instalacin del VBWin 3.0 sea lo ms agradable posible. Asi que encendamos el ordenador, desempaquetemos los disquetes y empezemos a instalar el programa. Aseguro que merece la pena y que pronto se empezarn a sentir reconfortantes satisfacciones. La versin 3.0 del lenguaje de programacin Microsoft Visual Basic para Windows se distribuye, en su edicin profesional, en 9 disquetes de 1.44 Mb. En estos disquetes se ubican, de forma comprimida, la totalidad de los ficheros que el Visual Basic precisa para su funcionamiento. Junto a los disquetes, se adjuntan cuatro libros bastante manejables y en general, bastante agradables de leer para lo que se estila en los manuales de programacin: la gua del programador, las utilidades profesionales (libros 1 y 2) y el manual de referencia. El Visual Basic, como la mayora de los compiladores, y en especial las utilidades Windows, requiere un proceso de instalacin. En ese proceso de instalacin el ordenador configura el sistema para poder ejecutar la nueva aplicacin y va pidiendo al usuario la introduccin de los distintos disquetes. No basta pues con copiar los ficheros en el disco duro y ejecutar el programa, as que vayamos sin ms demora, a empezar la instalacin. El proceso de instalacin, puede iniciarse de dos formas: - desde el sistema operativo DOS, - desde el entorno de trabajo del Windows. Cuando se inicia la instalacin desde el DOS, se debe ejecutar la siguiente lnea: A:\ > WIN SETUP

Si se inicia desde Windows, la forma ms sencilla es utilizar el administrador de archivos ,y efectuar un doble click de ratn sobre el fichero SETUP.EXE del disquete de instalacin nmero 1. Se haga de una forma o de otra, el programa de instalacin necesita tener a Windows en ejecucin. La instalacin es muy sencilla y tan solo el usuario debe seguir los pasos que el programa presenta en pantalla. Despus de responder a una serie de preguntas como el nombre del usuario, el directorio en el que se instalar el programa, etc., se presenta la alternativa de elegir entre una instalacin completa o personalizada. A travs de la instalacin completa el sistema instala todas las opciones posibles, mientras que con la personalizada se puede elegir entre instalar todas o algunas.

2.1.1.- INSTALACIN COMPLETA

Cuando se elige esta opcin, el sistema instala todos los mdulos que Visual Basic contiene. El espacio de disco que se requiere para una instalacin completa es de aproximadamente 27 Mb. El propio proceso de instalacin va pidiendo la insercin de los diferentes disquetes hasta que el proceso finaliza.

2.1.2.- INSTALACIN PERSONALIZADA (Custom Installation)

Como hemos dicho, la instalacin personalizada permite elegir aquellos mdulos de Visual Basic que necesitemos. Con ella se consigue un ahorro de espacio de almacenamiento. El resto de opciones que no se instalen en un primer momento, pueden instalarse posteriormente. Visual Basic ofrece la posibilidad de elegir entre 14 mdulos u opciones. Estas opciones aparecen en pantalla cuando se elige la instalacin personalizada y quedan recogidas en la siguiente figura (Fig. 2.1) y en la tabla que la sigue (Tabla 2.1):

Fig. 2.1.- Ventana de instalacin personalizada para Visual Basic 3.0 Edicin Profesional.

OPCIN Microsoft Visual Basic

Icon Library Samples Applications Learning Visual Basic

Help Compiler

Windows API Ref.

Custom Controls

ESPACIO REQUERIDO DESCRIPCIN 3992 K Incluye todos los ficheros requeridos por Visual Basic para escribir y ejecutar programas. 3984 K Contiene una biblioteca de unos 300 iconos. 2792 K Ejemplos de aplicaciones escritos en Visual Basic. 504 K Tutorial para ensear a construir aplicaciones en Visual Basic. 1184 K Posibilidad de crear mens de ayuda en las aplicaciones. 3992 K Ayuda en lnea para las funciones del API de Windows. 808 K Contiene unos 30 controles a medida.

Knowledge Base Clipart

152 K 2624 K

Data Access Control Development Kit Visual Design Guide Crystal Reports OLE 2.0

1120 K 1256 K 608 K 4144 K 120

Artculos de caracter tcnico sobre Visual Basic. 100 Mapas de bits para mejorar la apariencia de las aplicaciones. Programacin de bases de datos (mdulo ODBC). Mdulo para el desarrollo de controles. Ayuda para el diseo del interface. Permite la elaboracin de informes en VB. Incorpora las nuevas caractersticas de OLE.

Tabla 2.1. Opciones que ofrece Visual Basic al programador.

2.2.- PERSONALIZACIN DEL ENTORNO DE TRABAJO DEL VISUAL BASIC

Una vez que tenemos instalado el programa aparecer, en el entorno de Windows, el grupo de programas de Microsoft Visual Basic 2.0. Al igual que todos los grupos de programas, consiste en una ventana llena de iconos que se corresponden con las distintas posibilidades que nos ofrece Visual Basic (ver Fig. 2.2). As tenemos diferentes programas de ayuda, tutoriales, programas de demo, y como no, el propio programa que llama al Visual Basic.

Fig. 2.2. Grupo de programas de Microsoft Visual Basic 3.0

Para ejecutar Visual Basic, hacemos un doble click sobre el icono de Visual Basic 3.0 y automticamente entramos en el entorno de trabajo de Visual Basic. Lo primero que aparece en pantalla es el interface de usuario. Como se puede ver (Fig. 2.3), se trata de un entorno en el que conviven una serie de elementos como pueden ser ventanas, barras de mens, barras de herramientas, etc. y desde el cual se accede a todas las posibilidades que ofrece Visual Basic.

Fig 2.3. Entorno de trabajo de Microsoft Visual Basic 3.0, edicin profesional. . Dicho interface consta, en lneas generales, de tres ventanas que aparecen etiquetadas con los nombres Form1, Properties y Project1. Junto a ellas hay una barra de mens, una barra de herramientas (ToolBar) y una caja de herramientas (ToolBox). En el presente captulo, vamos tan solo a definir los elementos que aparecen en el entorno de trabajo de Visual Basic e indicar algunos aspectos relacionados con la personalizacin del entorno, que al fin y al cabo, es de lo que trata el captulo. Posteriormente, dedicaremos un captulo a describir en profundidad cada uno de los elementos que componen el interface de usuario del Visual Basic.

2.2.1.- BARRA DE MENS

Situada en la parte superior de la pantalla, activa diversas opciones del programa. Como en todo men de Windows, un click de ratn despliega las opciones del men. No obstante, se puede hacer la misma operacin tecleando la combinacin ALT + LETRA, donde LETRA equivale al caracter que aparece subrayado en la barra de mens.

2.2.2.- BARRA DE HERRAMIENAS (ToolBar)

Esta situada en la parte superior de la pantalla, justo debajo de la barra de mens. Consiste en una serie de iconos distribuidos en grupos y que permite un acceso rpido a las opciones ms utilizadas en el entorno de trabajo. Hay que destacar, que son teclas redundantes, puesto que su misma accin se realiza a travs de los mens desplegables. Por tanto, su nico objetivo es proporcionar una va rpida de acceso a esos comandos.

2.2.3.- CAJA DE HERRAMIENTAS (ToolBox)

En principio consiste en una serie de iconos colocados en filas y columnas y que se sitan por defecto en la parte izquierda de la pantalla. Dicha caja es flotante y puede ser desplazada hasta la posicin que deseemos mediante un simple arrastre por ratn. En la caja de herramientas se colocan los iconos de los controles que utilizaremos en el diseo de nuestra aplicacin.

2.2.4.- VENTANAS
En el entorno de trabajo de Visual Basic 2.0 encontramos, por defecto, una ventana de gran tamao llamada Form1 y dos ventanas ms pequeas llamadas Properties y Project1.

2.2.4.1.- Forms La ventana de tipo Form, constituye la ventana sobre la que se va a desarrollar el interface de la aplicacin que estamos diseando. Esta ventana se puede cambiar de posicin y de tamao mediante las posibilidades tpicas de Windows, esto es, drag & drop, etc.y constituir la base de la aplicacin que desarrollemos.

2.2.4.2.- Properties Es una ventana en la que se encuentran colocadas todas las propiedades que se pueden aadir a cada control o form del Visual Basic. Cada propiedad tiene una serie de valores que aparecen por defecto y que pueden ser modificados en cualquier momento del diseo de la aplicacin. Dichas propiedades, tambin pueden ver modificados sus valores en tiempo de ejecucin pero esto se hace al margen de la ventana que nos ocupa.

2.2.4.3.- Project

En esta ventana aparece un listado con los nombres de los diferentes ficheros que componen el proyecto actual de aplicacin. As aparecer el nombre de los Forms, de los mdulos, custom controls, etc. que componen la aplicacin actual. La etiqueta de esa ventana que por defecto es Project1, toma el nombre del proyecto que estemos desarrollando.

2.2.6.- Ventana de Entorno

La ventana de entorno es aquella que permite realmente personalizar el entorno de trabajo de Visual Basic. Desde ella se tiene acceso a casi todas las opciones del sistema. Estas opciones son muy amplias y se irn describiendo a lo largo del curso, pero a modo de anticipo, decir que pueden ir desde personalizar el color del texto en el editor de lenguaje hasta seleccionar aspectos del sistema de ms bajo nivel. Para acceder a la ventana de entorno, se debe elegir la opcin Environment del men Options. Cuando se selecciona esta posibilidad, aparece una ventana como la que se ve en la figura 2.4. Desde esta ventana manejamos las diferentes opciones.

Fig 2.4. Ventana de opciones del entorno. Personalizacin del Visual Basic.

El ajuste de las opciones que aparecen en esta pantalla, no determinan de forma significativa el trabajo en Visual Basic, sin que son posibilidades que se le ofrecen al usuario para que cada uno ponga el entorno de trabajo a su gusto. Por tanto, de momento, dejaremos fijos los valores que vienen por defecto.

CAPTULO 3 CARACTERSTICAS GENERALES DEL ENTORNO DE PROGRAMACIN DEL VISUAL BASIC 3.1.- INTRODUCCIN
Como ya sabemos, la programacin en Windows difiere sustancialmente de la programacin bajo DOS. Con ella, aparece una nueva filosofa de trabajo, lo que implica necesariamente la utilizacin de nuevas tcnicas y conceptos. El lenguaje Visual Basic, est fundamentalmente orientado a la programacin Windows y por tanto no es ajeno a toda esa terminologa. (Aunque sabemos que existe una versin de Visual Basic bajo DOS, el presente curso centrar su atencin en el diseo de aplicaciones Windows). El objetivo de este captulo es, por un lado, definir los conceptos bsicos de esta forma de programar y por otro, describir el entorno de trabajo de Visual Basic.

3.2.- CONCEPTOS BSICOS DEL LENGUAJE VISUAL BASIC

3.2.1.- FORMS
Cuando ejecutamos el Visual Basic, lo primero que llama la atencin es la existencia de una gran ventana en el centro de la pantalla y que suele estar rellena de una matriz de puntos regularmente distribuidos. Esta ventana, que aparece etiquetada con la palabra Form1, ser la ventana sobre la que disearemos nuestras aplicaciones. El formato de esta ventana, se ajusta al formato tpico de cualquier ventana Windows. As se puede apreciar la presencia de una barra de ttulo, botones para maximizar y minimizar la ventana, cuadro de men, borde, rea de trabajo, etc. Cuando creemos nuestra aplicacin, este ser el aspecto que tendr nuestra ventana (a no ser que se indique otra cosa). Lgicamente, para que la aplicacin sea til debemos rellenar la ventana con diferentes elementos, los cuales por otro lado, se supone que son ms o menos conocidos puesto que son todos aquellos que componen el interface de Windows. As tendremos cuadros de dialogo, botones de comando, casillas de verificacin, etc. Centrndonos en el aspecto de la ventana Form, podemos ver la retcula regular de puntos. Su misin ser servir de ayuda para la correcta alineacin de los elementos que coloquemos en el rea de trabajo de la ventana.

Como parece lgico, esa retcula solo es visible en tiempo de diseo, lo que significa que cuando ejecutemos la aplicacin, los elementos de la ventana aparecern tal y como les hubiramos situado, pero la red de puntos desaparece. La posicin y el tamao de la ventana Form, se corresponder con la posicin y el tamao de la ventana de nuestra aplicacin (ya que una vez ms hay que decir que esa ventana es nuestra aplicacin). Fcilmente se pueden cambiar esos parmetros mediante las normas estndar del trabajo en Windows, es decir: - desplazamiento: colocar el puntero del ratn sobre la barra de ttulo de la ventana y pulsando el botn izquierdo arrastrar la ventana hasta la posicin deseada, - tamao: se coloca el puntero del ratn sobre el borde de la ventana. Cuando la flecha del puntero se transforme en una flecha de dos puntas, se pulsa y arrastra el ratn hasta que el tamao de la ventana sea el deseado. Esta operacin puede hacerse tanto en vertical como en horizontal, e incluso en las dos direcciones a la vez si es que el proceso se hace sobre las esquinas. Ejemplo. Supongamos que la aplicacin que queremos desarrollar hace la til misin de visualizar una ventana vaca en la pantalla. Los pasos a seguir para conseguir tal hazaa son : 1.- Colocar la ventana Form en la posicin deseada. 2.- Ajustar el tamao de la ventana. 3.- Desplegar el men Run de la barra de mens del Visual Basic. 4.- Seleccionar la opcin Start. Cuando se hace esto, la pantalla cambia y Form1 aparece como una ventana Windows, pero totalmente vaca. Podemos probar, por curiosidad, que los botones de maximizar y minimizar en efecto hacen su misin, y que al pulsar la cuadro de men se despliegan una serie de opciones.

Debemos darnos cuenta de dos cosas fundamentalmente: - la primera es que nuestra ventana de aplicacin contiene numerosos elementos que nosotros no hemos tenido que programar. As, nos hemos ahorrado el poner botones para maximizar y minimizar, el cuadro del men control, etc. Todo esto ya aparece por defecto. - Como segunda curiosidad, sealar que la retcula de puntos que apareca en la ventana form mientras disebamos la aplicacin, ha desaparecido.

3.2.2.- OBJETOS
Cuando se crea una aplicacin en Visual Basic, se est trabajando con objetos. En sentido estricto, se puede definir un objeto como un conjunto complejo de datos y programas que posee estructura y que forma parte de una organizacin. De aqu se deducen algunas propiedades importantes de los objetos. En primer lugar, un objeto no es un dato simple, sin que contiene en su interior cierto nmero de componentes bien estructurados. En segundo lugar, cada objeto no es un ente aislado, sin que forma parte de una organizacin jerrquica o de otro tipo. En Visual Basic existen varios tipos de objetos tales como Forms y Controls. Toda la filosofa de la programacin est pues, orientada a objetos, en el sentido que manejamos objetos y con ellos creamos aplicaciones.

3.2.3.- EVENTOS O SUCESOS

Windows trabaja interceptando interrupciones, por ejemplo, pulsaciones de teclas, movimientos del ratn, etc. Estos son eventos que se producen en su entorno. Por tanto, se puede definir un evento, como una accin que es reconocida por un objeto (ya sea un Form o un control) y para la cual se puede escribir cdigo que responda a ese evento. Los eventos, pueden ocurrir como resultado de una accin del usuario (bien sea una pulsacin de una tecla o un click de ratn) o puede ser el propio sistema el que provoque el evento. Los eventos, son trasladados en mensajes. Un mensaje es un pequeo paquete de informacin que se reenva a la aplicacin que est involucrada en el evento.

Ejemplo. Supongamos que realizamos una pulsacin sobre una ventana de Windows. A partir del evento "pulsacin de ratn", se desencadena el siguiente proceso: 1.- Windows intercepta la pulsacin de ratn. 2.- Se toma la posicin y las caractersticas de la pulsacin. 3.- Segn las cotas, se identifica la ventana afectada. 4.- Windows enva a la ventana un mensaje que le informa de que hubo una pulsacin sobre ella y cuales son sus caractersticas.

5.- La aplicacin que corresponde a la ventana, deber procesar el mensaje y realizar las acciones pertinentes.

C a r g a d e la a p lic a c i n T e c la d o R a t n T e m p o r iz a d o r .....

F u n c io n e s

C a p tu ra d e e v e n to s

P ro c e s o 1 P ro c e s o 2 P ro c e s o 3

S a lid a 1 S a lid a 2 S a lid a 3 . . . . . . S a lid a n

G e s ti n d e e v e n to s E n v io d e m e n s a je s

. . . P ro c e s o n

S a lid a d e la a p lic a c i n

Fig. 3.1. Programacin basada en eventos. Diagrama de flujo.

Con todos los eventos que se producen en una aplicacin se establece una cola de espera, en la cual los eventos se van procesando segn un orden temporal y segn la jerarqua de preferencias.

3.2.4.- PROPIEDADES
La ventana que hemos diseado, dista mucho de ser una aplicacin til. Consiguientemente, deberemos aadir ciertas propiedades a esa ventana para que sea ms funcional. Visual Basic trata tanto a las Forms como a las cajas de texto, botones, etc. como objetos. Cada tipo de objetos puede tener determinadas propiedades. El objeto de tipo Form tiene una serie de propiedades que por otra parte estn asociadas a cualquier ventana. Por ejemplo, el ttulo, el color, la posicin, etc. En definitiva, las propiedades de un objeto representan todos los datos que normalmente estn asociados a un objeto.

Fig. 3.2. Ventana de propiedades en Visual Basic. En la Fig. 3.2 podemos ver la ventana que Visual Basic presenta para colocar las propiedades de los objetos. Comentaremos, en breve, como se establecen las propiedades, que tipos hay, etc. Veremos ms adelante otras muchas propiedades de los Forms.

3.2.5.- CONTROLES
En Visual Basic existen, como hemos dicho, dos tipos de objetos: Forms y controles. El concepto de control hace referencia a todos los objetos grficos que pueden disearse y situarse sobre un Form. Ejemplos de controles son las cajas de texto, cajas combinadas, botones, etiquetas, etc. Dicho de otro modo, un control es cualquier objeto que el usuario puede manipular y que no es, en si mismo, una ventana. Los controles se utilizan, en general, para la entrada/salida de informacin. Los controles, como objetos que son, tienen asociadas una serie de propiedades, o lo que es lo mismo, tienen asociados una serie de datos.

Ejemplo. Vamos a colocar en la ventana de nuestra aplicacin un control. A modo de ejemplo colocaremos una caja de texto, sin importarnos, por el momento, cuales son las caractersticas de este control. Para ello hacemos un doble click sobre el icono de caja de texto que est situado sobre la caja de herramientas. Inmediatamente, aparece en el centro de la ventana un rectngulo en cuyo interior est escrito Text1. Dicho rectngulo aparece rodeado de pequeos cuadraditos. Cuando estos aparecen, quiere decir que el objeto que est activo en ese momento, es el citado control. Cuando un control est activo se pueden cambiar sus propiedades, entre otras, el tamao y posicin, cosa que se hace de la misma forma a como se cambia en una ventana.

3.2.6.- CDIGO
Para que un objeto realice determinadas acciones debe tener asociado cdigo de programacin.

En una aplicacin, todos los objetos pueden llevar cdigo asociado. Este cdigo est constituido por las sentencias propias del Visual Basic y que no difieren mucho de las que constituyen el cdigo del QuickBasic. Para aadir cdigo a un objeto se debe hacer un doble click sobre l. Automticamente se abre una ventana de texto con dos lneas de cdigo escritas. Esas lneas son las sentencias de cabecera y cierre del cdigo, de manera que cualquier otra lnea que se aada debe ir situada entre ellas.

Ejemplo. Desplegar la ventana de cdigo para el control caja de texto que hemos colocado anteriormente en pantalla. Como se puede ver, la ventana que aparece contiene las siguientes lneas: Sub Text1_Change() ......................... End Ser entre estas dos lneas donde escriba el cdigo de programa.

3.2.7.- PROCEDIMIENTOS
La base del cdigo que aparece en una aplicacin escrita en Visual Basic, est constituida por los llamados procedimientos de eventos o de sucesos (event procedures). Estos, se pueden definir como el cdigo que es invocado cuando un form o un control (esto es, un objeto) reconoce que se ha producido un determinado evento. Adems de este tipo de procedimientos, Visual Basic permite llamar a procedimientos generales. Un procedimiento general no se invoca hasta que sea llamado explcitamente por alguna sentencia de la aplicacin. Como ejemplos de procedimientos tenemos los procedimientos Sub y Function. El primero pertenece a los procedimientos de eventos y el segundo a los globales. Ambos sern estudiados con ms detalle dentro de la sintaxis del Visual Basic.

3.3.- DESCRIPCIN DEL ENTORNO DE TRABAJO DE VISUAL BASIC

Aunque ya hemos adelantado algunas caractersticas del interface de usuario del Visual Basic, vamos ahora a describir ms en profundidad los diferentes elementos que lo componen.

3.3.1.- COMPONENTES DEL INTERFACE DE USUARIO

3.3.1.1.- Barra de mens

En Visual Basic, la barra de mens est constituida por ocho comandos. De todos es sabido que para activar esos mens se debe o bien pulsar con el ratn sobre la opcin deseada, o bien teclear la combinacin ALT + LETRA, donde LETRA representa al carcter subrayado que contiene cada comando.

Fig. 3.3. Barra de mens en Visual Basic.

Esas opciones son: File Contiene todas las funciones necesarias para el manejo de ficheros, desde abrir un fichero de proyecto hasta la creacin de nuevos ficheros. New Project Open Project Save Project Save Project As ... New Form New MDI Form New Module Add File ... Remove File Save File Save File As ... Load Text ... Save Text ... Print Make EXE File ... Exit

Ctrl + D Ctrl + S Ctrl + A

Ctrl + P

Fig. 3.4. Ejemplo del men File desplegado.

Edit Presenta las posibilidades que tiene Visual Basic relativas a la edicin. En l aparecen comandos como Copy, Paste, Cut, que permiten copiar, pegar y cortar los elementos seleccionados, y otros como Link ... que establece un punto de enlace con otras aplicaciones.

View

Se activan opciones de visualizacin. Por un lado, se puede elegir la presencia o no de la barra de herramientas. Por otro, permite ir visualizando el cdigo del mdulo que elijamos e ir conmutando entre los diferentes procedimientos que en l estn escritos. Run Men de ejecucin de la aplicacin. Permite adems detener y restablecer el proceso de ejecucin. Debug Contiene todas las posibles acciones del depurador de programas. Options Establece propiedades o caractersticas del entorno de trabajo y del proyecto en el que estamos. Window Activa las diferentes ventanas que existen en el entorno de trabajo de Visual Basic. Adems permite desplegar una ventana para el diseo de los mens de una aplicacin. Activa y desactiva la paleta de colores. Help Sistema de ayuda de Microsoft Visual Basic. Activa la ayuda de la opcin elegida, inicia tutoriales para el aprendizaje de Visual Basic y contiene informacin adicional sobre artculos tcnicos, direcciones de los distribuidores de Microsoft en todo el mundo, etc.

3.3.1.2.- Barra de herramientas

Como ya sabemos, la barra de herramientas es un conjunto de pequeos iconos situados en la parte superior de la pantalla y justo debajo de la barra de mens. Su presencia no tiene ms sentido que el de agilizar la eleccin de las opciones ms utilizadas. Microsoft distribuye la barra con un total de 14 iconos repartidos en cinco grupos (Fig. 3.5): - dos relacionados con la creacin de forms y mdulos, - otros dos para grabar y abrir un proyecto, - dos relacionados con las ventanas de diseo de mens y de propiedades, - tres para gestionar la ejecucin de una aplicacin, - cinco para trabajar con el debugger.

Fig. 3.5. Barra de herramientas.

La funcin de cada icono tiene su equivalente dentro de los mens. En la Fig. 3.5, se muestran las equivalencias con la barra de mens.

3.3.1.3.- Caja de herramientas (ToolBox)

La caja de herramientas constituye un elemento importantsimo en el proceso de diseo del interface de la aplicacin. En ella se sitan las herramientas necesarias para el manejo de los controles, ms un puntero para manipularlos. Cada vez que se inicia Visual Basic, la caja de herramientas se despliega automticamente. Aunque su posicin por defecto est en el lado izquierdo de la pantalla, puede colocarse en cualquier otro lado. Tambin puede estar cerrada, volvindose a abrir mediante la opcin ToolBox del men Window. La edicin estndar de Microsoft Visual Basic 2.0, presenta una caja de herramientas constituida por 21 elementos. Si se dispone de la edicin profesional, la caja puede ser completada con otros 22 custom controls. En cualquier momento se puede comprar algn custom control nuevo y aadir a los ya existentes.

Fig. 3.6. Caja de herramientas de la versin estndar de Visual Basic 2.0. La caja de herramientas de la edicin estndar de Visual Basic 3.0 (Fig. 3.7), contiene un total de 23 controles (hay otros tantos en la edicin profesional). Como novedades con respecto a la versin 2.0, podemos destacar la presencia del control Data y del Common Dialog (Cuadros de dilogo comunes). El Common Dialog estaba incluido en la edicin profesional de Visual Basic 2.0 y ahora se incorpora en la edicin estndar. Fig.3.7.- Caja de herramientas de la versin estndar de Visual Basic 3.0

3.3.1.4.- Ventana de propiedades

Cada uno de los elementos que aparecen en los forms necesitan una serie de propiedades que determinen su funcionamiento. Estas propiedades se recogen en la llamada ventana de propiedades (Fig. 3.2). A parte de las caractersticas tpicas de cualquier ventana Windows, la ventana de propiedades contiene los siguientes elementos: - Casilla de objetos. Contiene el nombre del objeto para el cual vamos a establecer sus propiedades. Cuando seleccionamos un objeto, aparece automticamente aqu su nombre. - Caja de edicin.

En esta caja podemos editar los valores de la propiedad que estamos seleccionando. La flecha que aparece a su derecha despliega, (en algunos casos) posibles elecciones.

- Listado de propiedades. El tercer elemento de la ventana de propiedades es una lista en la que aparece, a la izquierda, el nombre de las propiedades que puede tener el objeto seleccionado y a la derecha el valor actual de esa propiedad.

Ejemplo. Cambiar el ttulo de una ventana. Para ello debemos buscar en la ventana de propiedades la propiedad Caption. Como puede verse, el valor de esa propiedad es Form1, que es precisamente el texto que aparece en la barra de ttulo. Si seleccionamos la opcin Caption (hacer click en la casilla Caption) y escribimos el texto del ttulo. Automticamente aquello que estamos escribiendo se visualiza en la barra de ttulo de la ventana de nuestra aplicacin.

3.3.1.5.- Ventana de proyecto

La ventana de proyecto, refleja el conjunto de ficheros que en un determinado momento est utilizando un proyecto. Cualquier cambio relacionado con ficheros aparece reflejado en esa ventana. Cada vez que se abre un proyecto, el sistema presenta la ventana de proyecto con los ficheros que la componen.

Fig. 3.8. Ventana de Proyectos. Existen varios tipos de ficheros: - Ficheros de proyecto (.MAK). Este tipo de ficheros contiene informacin sobre todos los dems ficheros del proyecto, sobre la ubicacin de esos ficheros y sobre el entorno del sistema para cada proyecto. - Ficheros de Forms (.FRM). Contienen informacin grfica del form al que pertenece y de los controles que existen dentro de cada form. Adems contienen el cdigo asociado a cada elemento del form, subrutinas, declaracin de variables, etc. - Ficheros de mdulos (.BAS). Contienen informacin sobre declaraciones de variables y tipos de datos tanto de carcter global como a nivel de mdulo, adems de procedimientos globales.

- Custom Controls (.VBX). Contienen la informacin necesaria para dotar al sistema de nuevos controles. Ejemplos como el GRID.VBX o el OLE.VBX aaden al sistema controles para la especificacin OLE o para el control de las celdillas.

En el men Files, aparecen todas las opciones necesarias para el manejo de estos ficheros, a excepcin de los ficheros .VBX que requieren un trato especial.

3.3.1.6.- Forms
El ltimo elemento que nos queda por tratar es aquel que constituir la ventana de la aplicacin que diseemos. Su estructura es muy sencilla (ya ha sido anticipada brevemente en este mismo captulo) y contiene todas las caractersticas de cualquier ventana Windows. Cada vez que abrimos un proyecto aparece un form nuevo y en el momento del diseo de la aplicacin iremos colocando en ella todos los controles que necesitemos. En una aplicacin pueden existir varias form las cuales sern activadas en tiempo de ejecucin. Al margen del cdigo que contenga cada control, la ventana form tambin puede contener su propio cdigo. Si hacemos un doble click sobre ella, se entra en el editor de cdigo y se abre un determinado procedimiento.

En definitiva, vemos como Visual Basic presenta un interface de usuario muy fcil de manejar y en el que crear el diseo grfico de la aplicacin es insultantemente sencillo. Otra cosa ser aadir el cdigo correspondiente a cada control y relaccionarlo todo. Sin nimo de pecar de optimistas, veremos que incluso sto ltimo es muy fcil, y en breve estaremos en condiciones de crear aplicaciones Windows que dejarn pasmado a ms de uno.

CAPTULO 4 GENERACIN DEL INTERFACE GRFICO DE APLICACIONES 4.1.- DISEO GENERAL DEL INTERFACE GRFICO DE UNA APLICACIN
Una vez que tenemos definidos los elementos que constituyen el entorno de trabajo de Microsoft Visual Basic, vamos a empezar a utilizarlos para la creacin de una aplicacin. En toda aplicacin Windows, el interface grfico ocupa un lugar preponderante. Consiguientemente, en este captulo, describiremos los pasos y tcnicas necesarias para el diseo de dicho interface grfico. El principal protagonista del diseo del interface grfico, ser la caja de herramientas, ya que de ella extraeremos los controles que van a componer el interface.

4.1.1.- VENTANAS
Como estamos programando en Windows, debemos rendir un merecido homenaje al elemento bsico de este entorno de trabajo y que es, como no, la ventana. Toda aplicacin tiene al menos una ventana, ya sea para presentar datos, imgenes, pedir al usuario que introduzca informacin, presentar un mensaje de error, etc. Todo, absolutamente todo, se basa en la ventana. Cuando ejecutamos el Visual Basic, nos encontramos con una ventana, ya diseada, la cual no es otra que la ventana Form. sta contiene todas las propiedades de las ventanas de Windows. As podemos minimizarla, podemos cambiarla de posicin, podemos cerrarla, etc. A partir de aqu, todo lo que tenemos que hacer es completar y pulir dicha ventana en funcin de las necesidades de nuestra aplicacin.

4.1.1.1.- Diseo de una ventana

Se podra decir que en Visual Basic, el diseo de una ventana es un diseo de interiores, puesto que el diseo externo de la ventana ya nos viene dado. Nos queda por tanto la misin de rellenar esa ventana para que nuestra aplicacin sea funcional. De momento vamos a contener nuestros deseos y trabajemos con una ventana vaca.

Ejemplo

Supongamos que un absurdo cliente nos encarga la ardua misin de disear una aplicacin que coloque una ventana en la esquina superior izquierda de la pantalla. Nuestro cliente quiere que la ventana tenga las siguientes caractersticas: - sea de color verde. - se titule "Ventana Ecolgica". - tenga una altura de 4000 twips, - su ancho sea de 5000 twips. - no se puedan cambiar sus dimensiones en tiempo de ejecucin. (Nota: en Visual Basic la unidad de medida por defecto es el twips, el cual equivale a 1/1440 de pulgada.)

Comencemos entrando al entorno de Visual Basic. Con solo hacer esto, ya tenemos acabado una gran parte de nuestro trabajo, puesto que la ventana que se llama Form1, va a ser la ventana de nuestra aplicacin. Como nos pide que sea verde, vamos a presentar en pantalla la paleta de colores y vamos a seleccionar el color verde. Para ello, elegimos la opcin Color Palette del men Window. Automticamente, aparece en pantalla una paleta de colores. Elegimos el color verde y vemos como en ese momento el color de fondo de la ventana se vuelve del color elegido. Coloquemos ahora el ttulo. Esto, como ocurrir con el resto de propiedades, puede hacerse desde la ventana de propiedades. La propiedad que se encarga de colocar texto en la barra de ttulo se llama Caption. Seleccionemos dicha propiedad en la ventana de propiedades y tecleemos el texto que nos han pedido, Ventana Ecolgica. Para cambiar las dimensiones de la ventana, podemos usar dos propiedades: Height y Width. La primera determina la altura y la segunda el ancho de la ventana. Seleccionemos dichas propiedades desde la ventana de propiedades y coloquemos en ellas el valor pedido, 4000 twips para la altura y 5000 twips para el ancho. Como adems nos piden que no se puedan modificar las dimensiones de la ventana en tiempo de ejecucin, seleccionamos la propiedad BorderStyle. Como puede verse, sta propiedad dispone de 4 opciones: 0.- None: la ventana no tendr ningn borde, y por tanto no se puede ni desplazar ni cambiar sus dimensiones, 1.- Fixed Single: el borde de la ventana es una lnea simple y no se permite el cambio de dimensiones aunque si se la puede desplazar, 2.- Sizeable: el borde es el tpico de Windows y la ventana puede moverse y cambiar de dimensiones, 3.- Fixed Double: idnticas caractersticas que la opcin 1 pero con el borde ms grueso. Podemos, en nuestro caso, seleccionar la opcin 3.

Por ltimo nos queda determinar la posicin de la ventana. Las propiedades que controlan la posicin de la ventana son Left y Top, las cuales determinan la distancia en twips desde el origen de coordenadas, que se corresponde con la esquina superior izquierda. Consiguientemente, debemos dar el valor Left = 0 y Top = 0. Tenemos pues todo lo que nos haban pedido. Ejecutemos la aplicacin. Para ello seleccionamos la opcin Start del men Run (o su equivalente en la barra de herramientas). En efecto, la aplicacin coloca una ventana ecolgica en el punto deseado. Para finalizar la ejecucin de la aplicacin podemos escoger la opcin End del men Window, o bien hacer un doble click en la barra de men situada en la esquina superior izquierda de la aplicacin creada.

4.2.- ADICIN DE CONTROLES AL INTERFACE

A partir de este momento, empieza lo realmente excitante del Visual Basic, crear aplicaciones verdaderamente tiles y de forma sencilla.

4.2.1.- CAJA DE HERRAMIENTAS 4.2.1.1.- Manipulacin de Controles

Como ya sabemos, la forma ms sencilla de colocar controles en el interior de una ventana consiste en hacer un doble click sobre el control elegido de la caja de herramientas. Con sta accin, el programa coloca automticamente dicho control en el centro de la ventana de la aplicacin que estamos diseando. Cada control viene con un nombre por defecto y mediante el ratn podemos colocarle en cualquier sitio de la ventana e incluso cambiar su tamao. Hay otra forma de hacer esto. En primer lugar, se hace un click sobre un determinado control. Ese control cambia de color y da la impresin de que ha sido apretado hacia abajo. A continuacin colocamos el cursor en la ventana Form. Dicho cursor aparece como una pequea cruz en lugar de la flecha habitual. Sobre la zona de la pantalla en la que pretendamos ubicar al control elegido pulsamos la tecla de ratn y la mantenemos pulsada mientras efectuamos un arrastre. El control aparece en la ventana con la dimensin que hallamos elegido. Aunque cualquiera de las formas descritas es vlida, personalmente creo que es ms rpida la primera.

4.2.1.2.- Algunos controles ms utilizados

Aunque iremos describiendo poco a poco todos los controles a lo largo del curso, merece la pena detenerse en estos momentos en alguno de los controles ms usados: las cajas de texto, las etiquetas y los botones de comandos. La pretensin es que podamos empezar lo ms rpidamente

posible a hacer ejemplos y aplicaciones y posteriormente ya tendremos tiempo de ir complicando las cosas. Como elemento de apoyo para la compresin del texto, vamos a ir desarrollando, en paralelo a la descripcin de los controles, nuestra primera aplicacin en Visual Basic. Supongamos que deseamos fervientemente que el entorno de Visual Basic nos de la bienvenida por desarrollar la primera aplicacin. Para ello, aparecer una primera ventana en la que nos pide que introduzcamos nuestro nombre. Una vez tecleado, el programa visualizar una nueva ventana en la que nos da un afectuoso saludo. La salida de esta aplicacin, llamada SALUDO.MAK, queda reflejada en la Fig. 4.1.

Fig. 4.1. Salida de la aplicacin SALUDO.MAK.

En esta sencilla aplicacin utilizaremos tres de los ms usados controles de que dispone Visual Basic: los botones de comando, las etiquetas y las cajas de texto. Vayamos pues poco a poco y empecemos a describir cada uno de estos elementos. 4.2.1.2.1.- Botones de Comando (Command Buttons) La principal misin de los botones de comando es ejecutar una determinada accin cada vez que son pulsados. Existen muchas formas de elegir un botn de comando cuando estamos ejecutando la aplicacin: - La forma ms habitual de utilizar estos controles es mediante un click de ratn. - Otra posibilidad es desplazar el focus hacia el botn mediante la tecla de tabulacin y luego pulsar Enter o la barra de espacio. El focus determina el control activo en cada momento. - Tambin es posible, etiquetar un botn de comando con un nombre en el cual una de las letras aparezca subrayada. En este caso, la combinacin de teclas ALT + Letra subrayada activa el botn. - Para un determinado botn de comando, podemos poner su propiedad Default a True. En este caso se ejecuta con solo presionar Enter.

- Desde el cdigo de la aplicacin se puede elegir el botn asignando a la propiedad Value el valor True. - Si queremos que ese botn sea el que cancela la aplicacin, entonces ponemos la propiedad Cancel a True y podemos ejecutarle mediante la tecla ESC. Los botones de comando, son sensibles a determinados eventos, por ejemplo, un click de ratn. Cuando escribimos cdigo para un botn de comando, debemos hacerlo para que responda a un determinado evento. En la ventana de cdigo (recordemos que se accede a ella en tiempo de diseo efectuando un doble click sobre el botn de comando), existe una casilla situada en la parte superior derecha y que est etiquetada con "Proc:". En ella se encuentran los distintos eventos que reconoce un botn de comando. Podemos escribir cdigo para cualquiera de ellos, e incluso para varios. Si seleccionamos un determinado evento, la ventana de cdigo cambia y aparece el procedimiento Sub cmdName_KeyDown( ... ) .............. End Sub Despus de la palabra clave Sub se sita el nombre del botn de comando seguido del nombre del evento que hayamos seleccionado. En este caso el KeyDown, que hace referencia a la pulsacin de una tecla pero que puede ser cualquiera de los que aparecen en la caja Proc. Cada control, y por tanto tambin los botones de comando, tienen una propiedad que se llama Name. Permite asignar un nombre al control que le distinga de los dems. Cada vez que se llame a un control habr que referirse a l mediante su nombre. Ejemplo La aplicacin que estamos desarrollando, dispone de dos botones de comando en la primera ventana o form y de uno en la segunda. Los botones de la primera ventana les vamos a llamar OK y Cancelar. El primero nos permitir el paso a la segunda ventana una vez que hayamos tecleado el nombre y el segundo cancela la aplicacin. En primer lugar vamos a ajustar el tamao y la posicin de las ventanas Form1 y Form2 para adaptarlo al tamao de nuestra aplicacin. Estas dos ventanas tienen su propiedad Caption puesta a "Visual Basic" para la primera y "Saludo" para la segunda. Sus propiedades Name son, respectivamente, frmInicio y frmSaludo. Despus de sto, colocamos dos botones de comando sobre ellas. Es muy importante dotar a los controles de determinadas propiedades. Visual Basic, como hemos indicado, dispone de una serie de propiedades con valores por defecto. Muchos de estos valores permanecern intocables, aunque es frecuente que otros sean cambiados. Para el caso que nos ocupa, las propiedades que hemos cambiado son: Form1

Command1 Caption = OK Default = True Name = cmdOK Form2 Command1 Caption = Fin Default = True Name = cmdFin

Command2 Caption = Cancelar Cancel = True Name = cmdCancel

La propiedad Caption nos especifica el ttulo que ponemos al botn. La propiedad Name es el nombre con el que el sistema reconoce a ese control. Default permite determinar el control que tiene el focus y Cancel permite la llamada a un control mediante la tecla ESC.

4.2.1.2.2.- Etiquetas (Labels) Las etiquetas son un tipo de control que permiten visualizar texto sobre la ventana de la aplicacin. Sin embargo y a diferencia de las cajas de texto, ese texto solo se puede leer, es decir, texto que no puede ser cambiado directamente por el usuario. Su misin principal es poner algn ttulo, anotacin, etc. a controles que no tienen la propiedad Caption, (por ejemplo las cajas de texto). En un principio, y por defecto, una etiqueta est formada nicamente por texto. Sin embargo, es posible dotar a la etiqueta de un borde rectangular poniendo la propiedad BorderStyle a 1. Ejemplo Una vez que tenemos diseados los botones de comando, podemos poner texto en la ventana de la aplicacin. Para ello, nada mejor que utilizar las posibilidades que ofrece el control Label. En este caso, solo vamos a utilizar una etiqueta en la que pondremos las siguientes propiedades (conviene recordar que mientras no se indique lo contrario, las propiedades mantendrn los valores por defecto): Caption = Por favor, escriba su nombre: Name = lblTexto

4.2.1.2.3.- Cajas de Texto ( Text Boxes ) Este tipo de control, ampliamente usado, permite la entrada/salida de texto. Establece pues un punto de comunicacin entre el ordenador y el usuario. Las cajas de texto tienen muchas propiedades. Quiz dos de las ms vistosas son MultiLine y ScrollBars. La primera permite introducir mltiples lneas de texto y la segunda coloca barras de

desplazamiento en dicha caja de texto. Cuando al introducir texto se llega al final de la lnea, automticamente se produce un salto hacia la lnea siguiente y continua el proceso. Ejemplo Por ltimo, el tercer control de nuestra aplicacin es una caja de texto, colocada en frmInicio y que permite la entrada de texto por parte del usuario. La propiedad Name para esa caja de texto es txtNombre y su propiedad Texto es "", esto es, est vaca. En estos momentos, tenemos diseado el interface de la aplicacin, pero con eso solo la aplicacin no funciona. Deberemos pues dotar al programa del cdigo pertinente para que la aplicacin sea funcional. Las aplicaciones de Visual Basic para Windows, estn conducidas por eventos y es en esa lnea en la que debemos actuar. Cada objeto en Visual Basic puede responder a un evento y para ello necesita disponer del cdigo adecuado para cada suceso. En nuestro caso, el botn OK responder al evento click de ratn con el despliegue de la segunda ventana en la que escribir adems texto. El cdigo que hace esto es: Sub cmdOK_Click () frmSaludo.Show frmSaludo.Print frmSaludo.Print " Hola " & txtNombre.Text frmSaludo.Print " Bienvenido a " frmSaludo.Print " Visual Basic 3.0" End Sub

En este cdigo hacemos uso de dos mtodos: Show y Print. El primero visualiza una form (aquella cuyo nombre precede a la palabra Show) y el segundo coloca texto sobre la ventana especificada. En nuestro caso pone el texto a un tamao de 12, puesto que as lo hemos especificado en la propiedad FontSize del form frmSaludo. Los botones de comando cmdCancel y cmdFin tan solo llevan asociados al evento Click el cdigo Sub cmdCancel_Click () End End Sub Mediante la sentencia End, se fuerza la salida de la aplicacin. Tan solo queda ya ejecutar la aplicacin.

4.2.1.2.4.- Casillas de verificacin

Las casillas de verificacin permiten determinar si una condicin particular est activada o desactivada. Este tipo de controles trabajan independientemente unos de otros, de manera que el usuario puede elegir varios a la vez (ver Fig. 4.2).

Fig. 4.2. Casillas de verificacin.

4.2.1.2.5.- Botones de opciones Sirven para presentar al usuario una serie de opciones. Los botones de opciones trabajan en grupo, de manera que de todos ellos el usuario solo puede elegir uno a la vez. Cuando se activa uno de los botones, el anteriormente seleccionado se desactiva automticamente. En la siguiente figura, se muestra tal condicin, en la que los botones de opcin estn encerrados en un contenedor creado con el control Frame.

Fig. 4.3. Ejemplo de botones de opcin.

4.2.1.2.6.- Listas y cajas combinadas Se utilizan para presentar una serie de opciones al usuario. Las listas, consisten en una caja en la que se visualizan diferentes elecciones en una o varias columnas. El tamao de la caja de listas es prefijado por el usuario. Cuando las posibles elecciones no caben en la caja, se coloca automticacamente una barra de desplazamiento que nos permite desplazarnos por todas las opciones. Las cajas combinadas reunen la potencia de las cajas de texto con la de las cajas de listas. En ellas el usuario puede elegir la opcin o bien tecleando el nombre de dicha opcin o bien seleccionndola de la lista. Tanto unas como otras disponen de numerosas propiedades y mtodos que las dotan de gran potencia. Uno de los mtodos ms interesantes es aquel que permite aadir items a una lista. Este mtodo es AddItem. La sintaxis del mtodo es: caja.AddItem item[,ndice] donde,

caja es el nombre que hayamos dado al control (tanto para las listas como para las cajas combinadas), item es una cadena de caracteres que vamos a aadir a la lista e ndice es la posicin que va a ocupar dentro de la lista (un ndice 0 representa la primera posicin). Ejemplo Sub Form_Load() List1.AddItem "dato 1", 0 List1.AddItem "dato 2", 1 End Sub

Otro mtodo muy usado se conoce como RemoveItem y permite eliminar el item especificado mediante el ndice. Su sintaxis es: control.RemoveItem ndice Dentro de las propiedades ms usadas, destacan: Text si se aplica a las cajas de listas, se refiere al item que el usuario selecciona. Con las cajas combiandas hace referencia al texto colocado en la caja de texto de la caja combinada. List Hace referencia a un item de la lista. Por ejemplo, si queremos asignar a una caja de texto el tercer elemento de una caja de lista, debemos poner, Text1.Text=List1.List(2) ListIndex Permite conocer la posicin del item de la lista que se ha selecionado. ListCount Devuelve el nmero de items que hay en una caja de listas o en una caja combinada. Sort Ordena alfabticamente los items de una caja de listas o de una caja combinada.

4.3.- EJEMPLO DE OTRA APLICACIN

Supongamos que queremos hacer un duplicador de texto. Para ello debemos disear dos ventanas de texto de manera que cuando teclee texto en la ventana 1 automticamente aparezca ese

mismo texto en la 2 y cuando haga lo propio en la ventana 2 el texto aparezca tambin en la 1. Aadimos tambin dos botones de comandos que por un lado me borren el texto de las dos ventanas y que por otro me permitan abandonar la aplicacin. Tanto la aplicacin como cada ventana de texto aparecen etiquetadas con sendas Labels. El interface de la aplicacin que estamos diseando aparece reflejado en la Fig. 4.4. En ella se observa como hemos colocado dos cajas de texto, tres etiquetas y dos botones de comando. Las cajas de texto han sido agrandadas hasta el tamao que aparece en el figura.

Fig. 4.4. Aspecto del interface grfico de la aplicacin diseada.

Vamos a describir el cdigo y las propiedades modificadas en cada control. Caja de Texto 1. Propiedades : MultiLine = True Name = txtText1 ScrollBars = 2.- Vertical Cdigo : Sub txtTexto1_Change( ) txtText2.Text = txtTexto1.Text End Sub Caja de Texto 2. Propiedades : MultiLine = True Name = txtText2 ScrollBars = 2.- Vertical Cdigo : Sub txtTexto1_Change( ) txtText1.Text = txtTexto2.Text End Sub Etiqueta 1. Propiedades : Caption = COPION BorderStyle = 1.- Fixed Single

FontSize = 12 Cdigo : Sub Label1_Click( ) End Sub Etiqueta 2. Propiedades : Caption = Texto 1 Cdigo : Sub Label2_Click( ) End Sub Etiqueta 3. Propiedades : Caption = Texto 2 Cdigo : Sub Label3_Click( ) End Sub Botn de Comando 1 Propiedades : Caption = Borrar Texto Name = cmdBorrar Cdigo : Sub cmdBorrar_Click( ) txtText1.Text = "" End Sub

Botn de Comando 2 Propiedades : Caption = Salir Name = cmdSalir Cdigo : Sub cmdSalir_Click( ) End End Sub Form Cdigo : Sub Form_Load( )

End Sub

Cuando se cambia una determinada propiedad mediante cdigo, se hace aadiendo el nombre de la propiedad al nombre del control respecto al que va a aplicarse. Por ejemplo, si queremos que el texto que aparezca en la caja se borre al pulsar el botn de comando, ponemos el nombre del control (txtText1), y el nombre de la propiedad (Text) que queremos cambiar y los conectamos con un punto (txtText1.Text). A continuacin le asignamos el nuevo valor, que en este caso y para que se borre ponemos las dos comillas. Nota : Las propiedades que aqu se reflejan son aquellas a las que se ha modificado su valor. El resto permanecen con los valores por defecto que da Microsoft Visual Basic.

CAPTULO 5 PROPIEDADES 5.1.- DEFINICIN

Aunque ya hemos ido adelantando cosas relativas a las propiedades, vamos a describir en este captulo algunas de ellas con ms detalle. Es sabido, que cada objeto (Form o control) tiene un conjunto de propiedades predefinido. Esas propiedades van a determinar la apariencia y el comportamiento del objeto. As, la propiedad Enabled de una caja de texto determina si dicha caja puede responder a eventos, o la propiedad FontSize determina el tamao del texto que se visualizar. Cuando ejecutamos Visual Basic, las propiedades de los objetos se inicializan a unos valores predeterminados y que toman por defecto. Cuando trabajemos con un objeto, no necesitamos establecer valores para todas sus propiedades, sino que solamente cambiaremos aquellas para las que necesitemos un valor distinto del que tienen por defecto. Existen dos formas de establecer propiedades para un objeto: - en tiempo de diseo, lo cual se hace a travs de la ventana de propiedades, - en tiempo de ejecucin, que se consigue, en general, utilizando cdigo. En resumen, podemos decir, que todos los controles tienen definidos por defecto un conjunto de propiedades. Si queremos afinar el aspecto de nuestra aplicacin debemos establecer valores para nuestras propiedades distintos a los que tienen asumidos por defecto.

5.2.- VENTANA DE PROPIEDADES

5.2.1.- VISUALIZACIN DE PROPIEDADES No vamos a perder mucho tiempo hablando de la ventana de propiedades (Fig. 5.1), puesto que ya ha sido tratada en anteriores captulos. Tan solo repetir, que los valores de las propiedades se visualizan en la ventana de propiedades y que cuando se ejecuta el Visual Basic, en esa ventana aparecen registrados los valores de las propiedades que por defecto presenta un determinado control.

Fig. 5.1. Ventana de Propiedades. No todos los controles tienen el mismo conjunto de propiedades, sino que tanto el nmero de ellas como el tipo, depender de la propia naturaleza del control. As, no tiene sentido que el control barra de desplazamiento tenga propiedades relativas al tipo de letra, mientras que si es lgico que las tenga una caja de texto.

5.3.- ESPECIFICACIN Y ESTABLECIMIENTO DE PROPIEDADES PARA UN DETERMINADO CONTROL

5.3.1.- EN TIEMPO DE DISEO Cuando queramos poner propiedades a un objeto en tiempo de diseo, debemos seguir los siguientes pasos : - activar la ventana de propiedades. Esto puede hacerse o bien mediante un click sobre ella o bien seleccionando la opcin Properties del men Window. - buscar la propiedad que queramos cambiar. Para movernos por la ventana podemos usar, como es lgico, las barras de desplazamiento. - en la caja de edicin, aparece el valor actual que tiene esa propiedad siendo ah donde debemos seleccionar el nuevo valor para la propiedad. En algunos casos tendremos que teclear un valor, mientras que en otros lo que haremos ser elegir uno entre varios posibles.

Ejemplo.

Cambiar el tamao de texto que aparece en un botn de comando. Para ello vamos a seguir los siguientes pasos : - seleccionar el botn de comando deseado. Para ello basta hacer click sobre l y observaremos que aparece activado (estar rodeado de los famosos cuadraditos). - activar la ventana de propiedades. Men Window, opcin Properties, o hacer un click sobre la propia ventana, si es que est en pantalla. - seleccionar la propiedad FontSize - teclear el valor deseado para el tamao del texto - proceso concluido. Ejemplo Poner borde a una etiqueta. Una etiqueta sirve fundamentalmente para poner un ttulo o adjuntar determinado texto a un control. Por defecto, el texto de la etiqueta aparece en pantalla tal y como se escribe. Ahora bien, es posible que el texto pueda aparecer encerrado en un rectngulo. Para ello se debe modificar la propiedad BorderStyle. Describamos los pasos necesarios para tal fin: - seleccionar la etiqueta, - activar la ventana de propiedades, - seleccionar la propiedad BorderStyle, - hacer click sobre la flecha de la caja de edicin, - aparecen dos opciones : 0 - None 1 - Fixed Single - elegir la opcin Fixed Single, - proceso concluido. 5.3.2.- EN TIEMPO DE EJECUCIN La especificacin de propiedades en tiempo de ejecucin puede hacerse de dos formas, aunque la primera es, sin duda, la ms utilizada.

5.3.2.1.- Utilizacin de cdigo Cuando escribimos cdigo de programa para un determinado control, podemos actuar directamente sobre una propiedad y modificar el valor que tena en esos momentos. La forma habitual de hacerlo es mediante la siguiente lnea de cdigo: NombreControl.Propiedad = Valor es decir, se hace referencia al control mediante su nombre, a continuacin se pone un punto seguido del nombre de la propiedad que deseemos cambiar. El valor que asignemos ser aquel que a partir de ese momento adopte la propiedad. Ejemplo. txtDatos.Enabled = TRUE cmdCancelar.Caption = "Cancelar" txtTexto.FontSize = 12 5.3.2.2.- Mediante entrada tecleada por el usuario Es posible hacer que la aplicacin pida al usuario que teclee los cambios que desee en la propiedad. No todos los controles permiten esta entrada, aunque si lo hacen algunos tan usados como las cajas de texto.

5.4.- EXTRACTO DE LAS PROPIEDADES MS UTILIZADAS

A continuacin, vamos a describir algunas de las propiedades ms utilizadas en los controles. Por supuesto, esto no es ms que una pequea lista de todas las posibles propiedades (algunos controles como las cajas de texto tienen ms de 30 propiedades). Para ver en detalle todas las propiedades es mejor usar el Manual de Referencia del Visual Basic o bien visualizarlas a travs del men de ayuda que viene con el programa. La utilizacin del men de ayuda (Help), permite visualizar en pantalla informacin relativa a Visual Basic. Es muy util, sobre todo si no tenemos cerca un manual, y proporciona una informacin detallada y facil de localizar. En el caso que nos ocupa, podemos tener una descripcin de todas las propiedades activando el men Help. Una vez que se ha desplegado el men, seleccionar la opcin Contents. Automticamente se visualiza una pantalla de ayuda desde donde se accede a numerosas opciones.

Para visualizar propiedades, nos colocamos sobre la palabra Properties que se encuentra en el apartado Reference. Al situarnos sobre Properties la flecha del ratn se transforma en una mano y si hacemos un click, entramos en la ventana de ayuda para las propiedades (Fig. 5.2). En esta ventana, las propiedades se colocan por orden alfabtico y haciendo un click sobre una de ellas, se presenta en pantalla la descripcin detallada de esa propiedad. Las casillas de la parte superior de la ventana sirven para colocarnos en el grupo de propiedades cuyo nombre empiece por la letra de la casilla pulsada.

Fig. 5.2. Ventana de ayuda para las propiedades. AutoSize. Controles que la utilizan: Etiquetas, cajas de dibujo. Descripcin : Determina si un control se redimensiona automticamente para fijar su contenido. BackColor.

Controles que la utilizan : Prcticamente la totalidad de los controles. Descripcin : Determina el color de fondo de un objeto. BorderStyle. Controles que la utilizan : Forms, rejilla, imagen, etiqueta, lnea, OLE, caja de dibujo, formas, cajas de texto. Descripcin : Determina el estilo de borde de un objeto. Caption. Controles que la utilizan : Form, form MDI, casillas de verificacin, botones de comando, marcos, etiquetas, men, botones de opcin. Descripcin : Determina el texto que aparece dentro o junto a un control. En el caso de las forms, determina el texto que aparece en la barra de ttulo. Cancel. Controles que la utilizan : Botones de comando. Descripcin : Determina si el botn de comando es el botn de cancelar. FontName. Controles que la utilizan : La prctica totalidad.

Descripcin : Determina la fuente usada para visualizar o imprimir texto. FontSize. Controles que la utilizan : La prctica totalidad. Descripcin : Determina el tamao de la fuente usada para visualizar o imprimir texto. ForeColor. Controles que la utilizan : La prctica totalidad. Descripcin : Determina el color usado para visualizar texto o grficos en un objeto. Height. Controles que la utilizan : Todos. Descripcin : Determina las dimensiones de un objeto. LargeChange. Controles que la utilizan : Barras de desplazamiento. Descripcin : Cantidad que el valor de una barra de desplazamiento debe cambiar cada vez que el usuario hace un click sobre la propia barra.

Left. Controles que la utilizan : Todos. Descripcin : Posicin del control con respecto a la esquina superior izquierda. Max. Controles que la utilizan : Barras de desplazamiento. Descripcin : Valor mximo que puede adoptar la barra de desplazamiento. Min. Controles que la utilizan : Barras de desplazamiento. Descripcin : Valor mximo que puede adoptar la barra de desplazamiento. MultiLine. Controles que la utilizan : Cajas de texto. Descripcin : Determina si una caja de texto acepta mltiples lneas de texto. Name. Controles que la utilizan : Todos. Descripcin :

Nombre usado en el cdigo para identificar a un objeto. ScrollBars. Controles que la utilizan : Forms MDI, rejilla, cajas de texto. Descripcin : Especifica si un objeto tiene barras de desplazamiento. SmallChange. Controles que la utilizan : Barras de desplazamiento. Descripcin : Cantidad que el valor de una barra de desplazamiento debe cambiar cada vez que el usuario hace un click sobre la flecha de la barra. Text. Controles que la utilizan : Cajas combinadas, cajas de listas, cajas de texto. Descripcin : Especifica el texto contenido en el rea de edicin. En el caso de listas, determina el tem seleccionado. Top. Controles que la utilizan : Todos. Descripcin : Posicin del control con respecto a la esquina superior izquierda. Value.

Controles que la utilizan : Barras de desplazamiento, casillas de verificacin, botones de comando, botones de opcin. Descripcin : En las casillas de verificacin y en los botones de opcin, indican el estado del control. En Los botones de comando, especifica si el botn ha sido elegido y en las barras de desplazamiento indican la posicin actual de la barra.

CAPTULO 6

DESARROLLO DE PROGRAMAS EN VISUAL BASIC

6.1.- PROYECTOS. Todo el trabajo en Visual Basic, se hace con proyectos. Un proyecto es el conjunto de ficheros necesarios para crear una aplicacin. Esos ficheros son los que hemos visto en la ventana de proyecto y tienen diferentes extensiones que identifican su carcter. El fichero de proyecto est constituido por una lista de todos los ficheros que componen la aplicacin. Tiene, como sabemos, extensin .MAK y no contiene cdigo ni Forms, tan solo una lista de otros ficheros. Con todos los ficheros que componen el proyecto se crea el fichero ejecutable de la aplicacin (Fig. 6.1).

FORM1.FRM FORM2.FRM ................... FORMn.FRM

MODULO1.BAS MODULO2.BAS ........................ MODULOn.BAS

GRD.VBX GRID.VBX ................ GRAPH.VBX

Add Files CMDDIALOG.VBX GRID.VBX GRAPH.VBX MODULO1.BAS MODULO2.BAS FORM1.FRM Make EXE File FICHERO EJECUTABLE (.EXE)

Fig. 6.1. Generacin de una aplicacin en Visual Basic.

Al igual que cualquier otro fichero, un proyecto se puede abrir, crear, grabar, etc.

Los comandos que trabajan con proyectos se encuentran situados en el men File. Su utilizacin es trivial, por lo que vamos a prescindir de describirla. Estos se agrupan en cuatro : - New Project, - Open Project, - Save Project, - Save Project As. Como sabemos, un proyecto est formado por ficheros FRM, BAS, MAK y VBX. El fichero .MAK se crea al grabar un proyecto y mientras que los VBX precisan de otras utilidades para ser creados. Los ficheros Form y mdulo, se pueden gestionar con las utilidades tpicas de gestin de ficheros y que se encuentran situadas dentro del men File. As, para la creacin de ficheros Form, tenemos las opciones NewForm y NewMDI Form, las cuales crearn una determinada Form y la aaden al proyecto. A su vez, la opcin New Module crea y aade al proyecto un mdulo nuevo. De forma anloga, opciones como Add File, Remove File, Save File, Save File As, permiten aadir, borrar y grabar un determinado fichero. La forma en que Visual Basic graba un fichero puede ser o bien en formato binario o bien en formato de texto ASCII. El que la grabacin se realice de una forma u otra depende de la opcin colocada en el men Options submen Environment Options. Cuando elegimos la opcin de grabar el fichero en formato texto, obtendremos una descripcin del cdigo que estamos utilizando en cada form y mdulo. Un fichero se puede grabar en formato texto de dos maneras : - especificndolo en la ventana de ambiente (men Options, comando Environment Options), - mediante el comando Save File As del men File, activando la casilla Save AsText.

6.2.- OPCIONES DE AMBIENTE Y DE PROYECTO. Cuando queremos establecer una serie de propiedades para el entorno de trabajo, podemos fijar esas propiedades en la ventana Environment Options del men Options. En esta ventana aparecen un montn de opciones para que el sistema las tome por defecto. Entre estas opciones (ver Fig. 6.1) tendremos desde las ya sealadas para el formato de grabacin de los ficheros, hasta otras como pueden ser el color del texto que aparece en la ventana de cdigo, el color de fondo, etc.

Fig. 6.2. Ventana de opciones del entorno.

Adems de esta ventana, tenemos otra (Fig. 6.2) que se activa mediante el comando Project del men Options. Esta ventana permite fijar las siguientes opciones: - nombre del form que aparece en primer lugar cuando se ejecuta una aplicacin, - nombre del fichero de ayuda que queremos unir a una aplicacin, - lnea de comandos que Visual Basic enva a una aplicacin.

Fig. 6.3. Ventana de opciones de proyecto.

6.3.- CREACIN DE FICHEROS EJECUTABLES. Una vez que tenemos diseada la aplicacin y hemos comprobado, mediante su ejecucin desde el propio entorno del Visual Basic, que funciona correctamente, podemos crear un fichero ejecutable para que pueda ser activado desde Windows.

Como nuestra aplicacin puede tener varios ficheros, lo primero que debemos hacer es grabar todos los ficheros que tengamos (ficheros form o ficheros de mdulo). Como ya hemos dicho, esto se consigue con la opcin Save As File del men File. Junto a esta operacin grabaremos el proyecto completo (Save Project As) generando un fichero .MAK con informacin de todos los elementos que forman e proyecto. A continuacin elegimos la opcin Make EXE File del men File y le damos el nombre deseado. En estos momentos ya tenemos creado el fichero EXE. Es habitual, aunque no obligado, poner un icono a las aplicaciones. Para ello debemos teclear el nombre de un icono dentro de la casilla Use Icon From. Hay que decir, que en el manual de referencia del Visual Basic tenemos una lista de todos los iconos que acompaan al programa. Podemos elegir uno de ellos o bien, podemos crear nuestro propio icono mediante alguna de las utilidades que existen en el mercado para crear iconos. Estamos ya en condiciones de decir a Windows que incorpore a su entorno de trabajo nuestra nueva y seguro que flamante, aplicacin.

6.4.- DESARROLLO COMPLETO DE UNA APLICACIN En este apartado, vamos a describir todos los pasos necesarios para crear una aplicacin en Visual Basic, desde que entramos en el entorno de trabajo hasta que obtengo un ejecutable de la aplicacin. Este ejemplo, puede servir como modelo para el desarrollo de aplicaciones ms complicadas. Ejemplo Elaboracin de un visor de imgenes. Supongamos que queremos disear una aplicacin que nos permita visualizar en pantalla el contenido de una serie de ficheros de imagen. En esta aplicacin vamos a utilizar algunos controles nuevos, como son el cuadro de imagen y los botones de opciones. La aplicacin va a constar de dos ventanas: 1.- Ventana de presentacin. En ella el programa mostrar un amistoso saludo y nos invitar a entrar en el maravilloso mundo de las imgenes. 2.- Ventana de visualizacin. Una vez que hemos superado la ventana anterior, entramos en una nueva en la que se nos permite visualizar una serie de imgenes que vamos a ir seleccionando.

Dado que por el momento no conocemos en profundidad la sintaxis del cdigo de Visual Basic, se procurar que la aplicacin utilice el menor cdigo posible. Vayamos, sin ms demora, a empezar la aplicacin.

6.4.1.- Diseo del interface

El primer paso en la elaboracin de una aplicacin ser el diseo del interface de usuario. El programador, debe dedicar todo el tiempo necesario a esta labor, puesto que muchas veces el xito de una aplicacin se debe al correcto diseo del interface de usuario. La primera ventana de nuestra aplicacin, presenta un diseo muy elemental en el que como se puede ver en la Fig. 6.4, tan solo tenemos dos botones de comando y una etiqueta a la que hemos puesto un borde.

Fig. 6.4. Ventana 1 del programa VISOR.MAK.

La nica novedad a resaltar es la utilizacin de las propiedades BorderStyle = 1. Fixed Single y ForeColor = &H000000FF& y FontSize = 12 de la etiqueta, para producir, por un lado, una etiqueta rodeada de un borde y por otro, para modificar el color y tamao del texto de esa etiqueta.

Un poco ms interesante es la segunda ventana que compone la aplicacin. En la parte izquierda de la ventana tenemos un conjunto de 5 botones de opciones encerrados en un Frame. La parte derecha muestra un cuadro de imagen que es el lugar donde se visualizarn las imgenes. En la parte inferior est colocado un botn de comando que permite abandonar la aplicacin. Los nombres de estos controles son: cmdSalir para el botn de comando, picDisplay para el cuadro de imagen, fraImagen para el frame y opt1, opt2, opt3, opt4, opt5 para los botones de opciones.

Fig. 6.5. Interface de la segunda ventana de la aplicacin VISOR.MAK.

6.4.2.- Generacin de cdigo

El cdigo asociado a estas ventanas es trivial y pasa por ser: Cdigo para la ventana 1. Sub cmdContinuar_Click () frmVisor.Show End Sub Sub cmdSalir_Click () End End Sub donde cmdContinuar y cmdSalir son los nombres de los botones de comando y frmVisor es el nombre del Form que constituir la segunda ventana. Cdigo para la ventana 2. Sub cmdSalir_Click () End End Sub Sub opt1_Click () picDisplay.Picture = LoadPicture("c:\windows\arcos.bmp") End Sub Sub opt2_Click ()

picDisplay.Picture = LoadPicture("c:\windows\escocia.bmp") End Sub Sub opt3_Click () picDisplay.Picture = LoadPicture("c:\windows\agua.bmp") End Sub Sub opt4_Click () picDisplay.Picture = LoadPicture("c:\windows\escalera.bmp") End Sub Sub opt5_Click () picDisplay.Picture = LoadPicture("c:\windows\hojas.bmp") End Sub

Cabe destacar la utilizacin de la funcin LoadPicture() que carga una imagen en el cuadro de imagen. Entre los parntesis de la funcin se escribir el path completo del fichero imagen que queremos visualizar. En este ejemplo, los cinco ficheros imagen escogidos se suministran con la versin 3.1 de Windows. (Nota: el cdigo completo de esta aplicacin, junto con alguna mejora, se suministra en el captulo siguiente).

6.4.3.- Creacin de un fichero ejecutable

El ltimo paso en el desarrollo de una aplicacin consiste en crear el fichero ejecutable de dicha aplicacin. Este fichero que contiene la extensin .EXE ser el que realmente ejecuta la aplicacin. La forma de crear un fichero ejecutable en Visual Basic es muy sencilla. Se selecciona la opcin Make EXE File del men File. Al hacer esto sale un cuadro de dilogo como el que se muestra en la Fig. 6.6.

Fig. 6.6. Cuadro de dilogo para la creacin de un fichero .EXE.

Como se puede ver, nos piden el nombre para el fichero ejecutable y al teclearlo se crea automticamente el fichero. Es posible tambin elegir el icono de la aplicacin. Una vez que tenemos un primer icono, se puede cambiar por alguno de los muchos que se distribuyen con Visual Basic 3.0. Decir que en estos momentos disponemos en nuestra aplicacin de los siguientes ficheros: FRMINI.FRM FRMVISOR.FRM VISOR.MAK VISOR.EXE Los dos primeros, son los ficheros de cada una de las forms de que consta la aplicacin, el tercero es el fichero de proyecto y el ltimo es el fichero ejecutable. Todos ellos, componen la aplicacin Windows diseada en Visual Basic.

CAPTULO 7

GENERACIN DE CDIGO EN VISUAL BASIC

7.1.- INTERFACE GRFICO Y CDIGO DE LA APLICACIN Generalmente, el primer paso a la hora de desarrollar una aplicacin en Visual Basic, consiste en construir el interface grfico. Una vez que ste ya ha sido creado, estaremos en condiciones de aadir cdigo a los objetos del interface con el fin de que puedan responder a eventos. La ventana en la que se escribe el cdigo de la aplicacin, se llama (sorprendentemente), ventana de cdigo. (Fig. 7.1).

Fig. 7.1. Ejemplo de ventana de cdigo para un Form.

Un aspecto ciertamente interesante, es saber cuando hay que aadir cdigo y cuando no es necesario. En la programacin tradicional, el cdigo era el nico elemento que constitua la aplicacin. Sin embargo, en Visual Basic, a parte del cdigo, est el interface grfico que como ya sabemos, est constituido por objetos. No debe olvidarse que al disear el interface grfico no es necesario aadir ni una sola lnea de cdigo. Si que ser necesario hacerlo, cuando queramos que el interface responda ante determinadas peticiones del usuario o del propio sistema. Por lo tanto, seguiremos la siguiente norma a la hora de escribir cdigo : slo es necesario escribir cdigo para activar el interface, no para crearlo.

7.2.- PROCEDIMIENTOS

7.2.1.- Procedimientos de eventos

Cuando alguno de los objetos reconoce que ha ocurrido un evento, automticamente llama al procedimiento de evento correspondiente. El nombre de ese procedimiento establece una asociacin entre el objeto y el cdigo. As, un procedimiento de evento para un determinado control combina el nombre del objeto con el nombre del evento : NombredelObjeto_NombredelEvento( ) Supongamos que hemos pulsado una tecla de ratn sobre un determinado control, por ejemplo, sobre un botn de comando. Inmediatamente el objeto botn de comando reconoce el evento e invoca al procedimiento de evento, en este caso, al procedimiento Click. Para el caso de arriba, el procedimiento de evento tendra el pertinente cdigo asociado, pero indefectiblemente contendra el siguiente esquema : Sub cmdBoton1_Click () ......... Cdigo ......... End Sub donde, cmdBoton1 es un nombre arbitrario que damos al botn de comando para identificarle. Los procedimientos de evento pueden ser de dos tipos : - eventos de control, - eventos de form. Los primeros hacen referencia a aquellos procedimientos que se invocan cuando ocurre un evento sobre un control, mientras que los segundos hacen lo propio pero cuando el evento ocurre sobre un form. Segn sea para unos o para otros, la sintaxis cambia ligeramente. Para los eventos de control la sintaxis es: Sub NombredelControl_NombredelEvento() ........................ Cdigo ........................ End Sub

Los eventos de forms, presentan la sintaxis : Sub Form_NombredelEvento()

........................ Cdigo ........................ End Sub

Cada evento comienza por la palabra Sub y termina con End Sub. Entre esas dos lneas se situar el cdigo asociado. Ejemplo. Sub cmdOK_Click() cmdOK.FontSize = 12 cmdOK.Caption = "Botn de comando" End Sub Sub Form1_Load() Form1.Caption = "Ventana inicial" End Sub

7.3.- IMPLEMENTACIN DE CDIGO EN LOS DIFERENTES ELEMENTOS DE UNA VENTANA Supongamos que disponemos de la aplicacin VISOR.MAK creada en el captulo 6. Vamos a complicar poco a poco dicha aplicacin aadiendo nuevas ventanas y aadiendo nuevas lneas de cdigo. De momento, y a la espera de un posterior captulo en el que comentemos la sintaxis del cdigo de Visual Basic, empezaremos aadiendo sentencias muy sencillas y fciles de comprender por cualquiera que tenga unas nociones elementales de programacin. El objetivo ser aadir al programa VISOR.MAK una ventana de identificacin de usuario, de manera que para poder acceder a las opciones de visualizacin de imgenes se necesite teclear una clave de acceso. La propia aplicacin puede rechazar el acceso dependiendo de cual sea la clave introducida. Para ello vamos a disear una ventana muy sencilla y la vamos a dotar del cdigo necesario para determinar el acceso a otras pantallas de unos u otros usuarios. El aspecto de la nueva ventana ser tal y como se muestra en la Fig. 7.2.

Fig. 7.2. Aspecto de la nueva ventana.

En esta pantalla tenemos dos botones de comando, una caja de texto y una etiqueta. El usuario teclear su password en la caja de texto y pulsar el botn OK para que el programa evale la clave y decida su aceptacin. El otro botn me permite salir de la aplicacin. A partir de la versin 2.0, Microsoft ha incorporado la posibilidad de que las cajas de texto dispongan de unas propiedades llamadas PasswordChar y MaxLength, que hacen muy fcil la creacin de una caja de texto con un password incorporado. PasswordChar especifica el carcter que se visualizar en la caja de texto cuando el usuario teclee el password mientras que MaxLength determina el nmero mximo de caracteres para el password. Cuando ese nmero se sobrepasa se genera un pitido y se rechazan los caracteres que sobren. El resto no queda ms remedio que dejrselo al cdigo de la aplicacin. En este caso, vamos a incorporar todo el cdigo al botn de comando etiquetado con OK. La caja de texto no lleva cdigo asociado mientras que el botn Salir tan solo lleva la sentencia End asociada al evento Click. El cdigo para el botn OK, cuyo nombre es cmdOK, es el siguiente: Sub cmdOK_Click () If txtPassword.Text <> "visor" Then txtPassword.Text = "" frmPassword.Show txtPassword.SetFocus Else frmVisor.Show End If End Sub

En este caso hemos puesto, para la caja de texto, la propiedad Name=txtPassword. El cdigo incorpora algunos elementos que no hemos descrito pero que sin duda alguna van a ser entendidos por todos.

En primer lugar tenemos una estructura de decisin (ver captulo 8) If...Then...Else. Como seguro que muchos ya saben, esta estructura evala una primera condicin y si es cierta ejecuta una serie de sentencias. En caso contrario ejecuta otras. Lo que la decimos que evale es si el valor tecleado en la caja de texto coincide o no coincide con la palabra "visor". Esta palabra ser la clave de acceso. Si la palabra que hay sobre la caja de texto no coincide con la palabra "visor", entonces el programa ejecuta las lneas de cdigo: txtPassword.Text = "" frmPassword.Show txtPassword.SetFocus Por el contrario si lo que se introduce en la caja de texto coincide con la palabra clave, el programa ejecuta la lnea: frmVisor.Show Cuando introducimos un password incorrecto, el programa borra ese password (lo que hace realmente es escribir un carcter nulo ""), visualiza nuevamente la pantalla (mtodo Show) y pasa de nuevo el focus del programa a la caja de texto (mtodo SetFocus). Si hemos tecleado el password correcto, se visualiza la pantalla siguiente que era aquella en la que se mostraban las imgenes. El cdigo al completo del programa VISOR.MAK se muestra a continuacin.

MICROSOFT VISUAL BASIC VERSION 3.00 Begin Form frmInicio Caption = "Visor de Imgenes" Height = 3045 Left = 2235 LinkTopic = "Form1" ScaleHeight = 2640 ScaleWidth = 2970 Top = 1650 Width = 3090 Begin CommandButton cmdSalir Caption = "Salir" Height = 495 Left = 1680 TabIndex = 1 Top = 1920 Width = 975 End Begin CommandButton cmdContinuar Caption = "Continuar" Default = -1 'True Height = 495 Left = 240 TabIndex = 0 Top = 1920 Width = 975 End Begin Label lblSaludo

Alignment = 2 'Center BorderStyle = 1 'Fixed Single Caption = "Bienvenido al programa Visor de Imgenes." FontBold = -1 'True FontItalic = 0 'False FontName = "MS Sans Serif" FontSize = 12 FontStrikethru = 0 'False FontUnderline = 0 'False ForeColor = &H000000FF& Height = 975 Left = 360 TabIndex = 2 Top = 480 Width = 2175 End End Sub cmdContinuar_Click () frmPassword.Show End Sub Sub cmdSalir_Click () End End Sub Sub Command2_Click () End End Sub Begin Form frmPassword Caption = "Password" Height = 3045 Left = 2700 LinkTopic = "Form1" ScaleHeight = 2640 ScaleWidth = 2925 Top = 2790 Width = 3045 Begin CommandButton cmdSalir Cancel = -1 'True Caption = "Salir" Height = 495 Left = 1800 TabIndex = 3 Top = 1920 Width = 735 End Begin CommandButton cmdOK Caption = "OK" Height = 495 Left = 360 TabIndex = 2 Top = 1920 Width = 735 End Begin TextBox txtPassword Height = 285 Left = 600 MaxLength = 12 PasswordChar = "*" TabIndex = 1

Top = 1200 Width = 1695 End Begin Label lblPassword Caption = "Por favor, introduzca su palabra de identificacin." Height = 495 Left = 360 TabIndex = 0 Top = 480 Width = 2295 End End Sub cmdOK_Click () If txtPassword.Text <> "visor" Then txtPassword.Text = "" frmPassword.Show txtPassword.SetFocus Else frmVisor.Show End If End Sub Sub cmdSalir_Click () End End Sub Begin Form frmVisor Caption = "Visor de Imgenes" Height = 4425 Left = 2130 LinkTopic = "Form2" Picture = FRMVISOR.FRX:0000 ScaleHeight = 4020 ScaleWidth = 4905 Top = 1800 Width = 5025 Begin OptionButton opt5 Caption = "Hojas" Height = 495 Left = 480 TabIndex = 7 Top = 2640 Width = 1215 End Begin OptionButton opt4 Caption = "Escalera" Height = 495 Left = 480 TabIndex = 6 Top = 2160 Width = 1215 End Begin OptionButton opt3 Caption = "Agua" Height = 495 Left = 480 TabIndex = 5 Top = 1680 Width = 1215 End Begin OptionButton opt2

Caption = "Escocia" Height = 495 Left = 480 TabIndex = 4 Top = 1200 Width = 1215 End Begin OptionButton opt1 Caption = "Arcos" Height = 495 Left = 480 TabIndex = 3 Top = 720 Width = 1215 End Begin Frame fraImagen Caption = "Imgenes" Height = 2895 Left = 360 TabIndex = 2 Top = 360 Width = 1455 End Begin PictureBox picDisplay Height = 2175 Left = 2640 ScaleHeight = 2145 ScaleWidth = 1785 TabIndex = 1 Top = 480 Width = 1815 End Begin CommandButton cmdSalir Caption = "Salir" Height = 495 Left = 2880 TabIndex = 0 Top = 3120 Width = 1215 End Begin Image Image1 Height = 15 Left = 1320 Picture = FRMVISOR.FRX:043E Top = 1200 Width = 15 End Begin Image img1 Height = 15 Left = 360 Picture = FRMVISOR.FRX:087C Stretch = -1 'True Top = 360 Width = 15 End End Sub cmdSalir_Click () End End Sub Sub Command1_Click ()

End End Sub Sub opt1_Click () picDisplay.Picture = LoadPicture("c:\windows\arcos.bmp") End Sub Sub opt2_Click () picDisplay.Picture = LoadPicture("c:\windows\escocia.bmp") End Sub Sub opt3_Click () picDisplay.Picture = LoadPicture("c:\windows\agua.bmp") End Sub Sub opt4_Click () picDisplay.Picture = LoadPicture("c:\windows\escalera.bmp") End Sub Sub opt5_Click () picDisplay.Picture = LoadPicture("c:\windows\hojas.bmp") End Sub

CAPTULO 8 EL LENGUAJE DEL VISUAL BASIC 8.1.- INTRODUCCIN

Aunque la filosofa de diseo de programas de Visual Basic para Windows es totalmente distinta a la de sus antepasados QuickBasic Basic PDS, el lenguaje del Visual Basic sigue manteniendo un estrecho lazo con ellos, sobre todo en lo relativo al cdigo de programacin. Consiguientemente, nos vamos a encontrar con un cdigo muy conocido para los que hayan programado en Basic y muy fcil de aprender para los que no lo hayan hecho.

8.2.- VARIABLES

8.2.1.- DEFINICIN

En Visual Basic, como en la mayora de los lenguajes de programacin, el almacenamiento temporal de datos se realiza en variables. Cada variable est identificada por un nombre y por un tipo de dato. El nombre sirve para referirnos a ella y el tipo de dato determina la clase de datos que la variable almacena. En Visual Basic, no necesitamos hacer una declaracin explcita de las variables, cosa que puede chocar a aquellos programadores que procedan de otros lenguajes como el C. Simplemente, cuando necesitemos usar una variable la asignamos un nombre y un dato. Esto no significa que no se puedan declarar previamente, es ms, se aconseja hacerlo. Para ello se utiliza la sentencia Dim seguida del nombre de la variable. Un aspecto ciertamente importante en la declaracin de variables es el lugar en que se declaran. Dependiendo de que se declare en uno u otro sitio el alcance de la variable es diferente. Si declaramos una variable dentro de un procedimiento, esa variable afecta nicamente a ese procedimiento. La sentencia general para la declaracin de variables en un mdulo es: Dim NombreVariable As TipoDato donde NombreVariable es el nombre que damos a la variable y TipoDato, obviamente, es el tipo de dato que almacena la variable. La especificacin de tipo de dato es opcional. Cuando no se especifica tipo de dato, Visual Basic asume el tipo de dato por defecto, esto es, el tipo de dato Variant. Este tipo de dato se

present por primera vez con la versin 2.0 y es muy interesante, porque permite almacenar cualquier clase de datos, ya sean nmeros, cadenas, formato fecha/hora, etc. La declaracin de variables puede realizarse de forma implcita o explcita. Cuando se hace implcitamente, no se necesita declarar la variable, solo se pone su nombre y se le asigna un valor. Esta flexibilidad, puede jugarnos a veces malas pasadas puesto que si en algn lugar del programa tenemos que llamar a una variable existente, debemos tener mucho cuidado de no equivocarnos al escribir su nombre. Un fallo en la escritura hace que el programa lo entienda como una nueva variable y la inicialice a cero. Este problema se puede solventar mediante la declaracin explcita, indicando a Visual Basic que genere un mensaje de error cuando se encuentre un nombre que no haya sido declarado explcitamente como variable. Esto se consigue mediante la sentencia Option Explicit que se situar en la seccin de declaraciones de un form o mdulo. Para que afecte a todo nuestro cdigo es posible definirlo con el comando Environment del men Options (poner a Yes la casilla Require Variable Declaration).

8.2.2.- TIPOS DE VARIABLES Cuando declaramos una variable, debemos tener claro el alcance que deseemos que tenga esa variable. Esto quiere decir, que debemos saber de antemano si esa variable estar restringida a un determinado procedimiento o quiz pretendamos que esa variable pueda ser reconocida en todo el cdigo del programa. Atendiendo a este criterio, podemos encontrar tres tipos de variables: variables locales, variables a nivel de mdulo y variables globales.

8.2.2.1.- Variables locales Las variables locales son aquellas que son reconocidas nicamente dentro del procedimiento en el que se declaran. De esa forma, una variable declarada como local en un procedimiento A no puede ser llamada desde otro procedimiento B. Supongamos que tengo una variable llamada Fecha y que est declarada en el procedimiento A. Qu ocurrira si declaro otra variable con el mismo nombre en un procedimiento B? La respuesta es clara. Puesto que cada variable solo es reconocida por el procedimiento en que est declarada, no hay ningn inconveniente en utilizar variables con el mismo nombre en diferentes procedimientos. Cada variable aunque tenga el mismo nombre har referencia a una direccin de memoria distinta, con lo cual es como si los nombres fueran diferentes. La forma de declarar una variable local es mediante la utilizacin, dentro de un procedimiento, de la sentencia Dim NombreVariable As TipoDato

Tambin es posible utilizar la declaracin implcita. En este sentido, podemos decir, que todas las variables declaradas implcitamente tienen un alcance local.

8.2.2.2.- Variables de mdulo Las variables de mdulo son aquellas que son reconocidas en todos los procedimientos que forman un mdulo. Se define mdulo como aquel conjunto de procedimientos y declaraciones de datos almacenados juntos en un nico fichero y que no estn unidos a ningn form. Ni que decir tiene que esas variables no son reconocidas fuera de ese mdulo en que han sido declaradas. La forma de declarar estas variables sigue la pauta habitual, es decir, se declaran en la seccin de declaraciones de un mdulo mediante la sentencia Dim.

8.2.2.3.- Variables globales Son aquellas que pueden ser reconocidas a lo largo de todo el programa. Su alcance se extiende a todos los procedimientos, mdulos y forms que componen la aplicacin. Al igual que las variable de mdulo, las variables globales se declaran en la seccin de declaraciones de un mdulo pero utilizando la sentencia Global en lugar de Dim. No se puede declarar una variable Global dentro de un procedimiento.

8.2.2.4.- Variables estticas Se entiende por tiempo de vida de una variable, el tiempo transcurrido desde que se inicializa hasta que desaparece de memoria. Las variables globales y las de mdulo se mantienen en memoria durante todo el tiempo que dura la aplicacin, sin embargo, las locales lo hacen solo mientras se est ejecutando el procedimiento desde el que fueron declaradas. Cuando se vuelve a llamar a ese procedimiento, la variable se inicializa nuevamente. Para hacer que una variable local preserve su valor a lo largo de la vida de la aplicacin, Visual Basic admite declarar las variables locales como variables estticas. La forma de hacer esto es sustituyendo la sentencia Dim por Static.

8.3.- TIPOS DE DATOS

Como hemos indicado antes, toda variable lleva asignado un nombre y un tipo de dato. Esto significa que la variable debe estar preparada para almacenar uno u otro tipo de dato. En Visual Basic 3.0, cuando a una variable no se le asigna un tipo de dato, automticamente esa variable pasa a recibir el tipo de dato por defecto, que no es otro que el tipo de dato Variant. Sin embargo,

asignando un determinado tipo de dato a una variable, sta ser capaz de almacenar aquellos y slo aquellos datos que correspondan al tipo que ha sido definido. Existen dos formas de declarar una variable. Por un lado se escribe el nombre del tipo de dato seguido del nombre de la variable (Dim Dato As Integer) y por otro se puede hacer una declaracin implcita mediante el carcter de declaracin (Dato%).

8.3.1.- TIPOS DE DATOS NUMRICOS

Como en la mayora de los lenguajes de programacin, los tipos de datos numricos se clasifican en 4 tipos bsicos: enteros, enteros largos, punto flotante y doble precisin. En Visual Basic, esos valores adoptan los siguientes nombres y propiedades: 8.3.1.1.- Tipo Integer Almacena nmeros enteros de 2 bytes de longitud. El rango de valores que pueden adoptar vara entre -32768 y +32767. El carcter de declaracin es "%".

8.3.1.2.- Tipo Long Almacena enteros de 4 bytes de longitud. Su rango de valores oscila en el intervalo (147483648,+2147483647). Su carcter de declaracin es "&".

8.3.1.3.- Tipo Single Almacena nmeros en punto flotante de 4 bytes. El rango de valores oscila en el intervalo (3.402823E38,-1.401298E-45) para valores negativos y (1.401298E-45,3.402823E38) para los positivos. Su carcter de declaracin es "!".

8.3.1.4.- Tipo Double Tiene las mismas caractersticas que Single pero almacena nmeros de 8 bytes. Su carcter de declaracin "#". Su rango de valores es aproximadamente potencia de E324.

8.3.1.5.- Tipo Currency Almacena nmeros decimales de 8 bytes pero con un nmero fijo de decimales. Su carcter de declaracin es "@".

8.3.2.- TIPOS DE DATOS DE CARACTERES

8.3.2.1.- Tipo String Almacena cadenas de caracteres que van aproximadamente desde 0 a 65500 caracteres. Su carcter de definicin es "$".

8.3.3.- TIPO DE DATOS VARIANT

Visual Basic ha adoptado, a partir de la versin 2.0, un tipo de dato de la mxima flexibilidad. El tipo de dato Variant puede almacenar varias clases de datos. En ese sentido podemos almacenar en una variable Variant una cadena de caracteres, un entero, un nmero decimal, una determinada fecha, etc. Quiz ms importante que el hecho de almacenar distintos tipos de datos, es la capacidad de realizar conversiones automticas entre uno y otro tipo. Podemos pues olvidarnos del tipo de datos de la variable y realizar casi las operaciones que deseemos. De todas formas no todo va a ser tan fcil, y si bien es cierto que se gana mucha potencia con este nuevo tipo de datos, se debe tener en cuenta alguna restriccin.

Ejemplo Para explicar como funciona este nuevo tipo de datos sigamos el desarrollo del siguiente ejemplo. Dim Dato Dato = InputBox("Introduzca un nmero.") Dato = Dato & "AAA" En primer lugar definimos una variable de tipo Variant puesto que no la hemos asignado ningn tipo de dato y consiguientemente toma el tipo por defecto. A continuacin pedimos al usuario que introduzca un nmero que ser asignado a la variable Dato. Por ejemplo, el usuario introduce el entero 8 con lo que Dato = 8. En estos momentos, Dato almacena un entero. Aprovechando la flexibilidad del tipo de dato Variant vamos a aadir la cadena de caracteres "AAA" a la variable Dato. Automticamente, se convierte el entero 8 en la cadena "8" y se fusiona con la cadena "AAA" de manera que en ese momento la variable Dato se convierte en una variable capaz de almacenar un string cuyo valor ser Dato = "8AAA".

Dentro de las restricciones a las que hacamos referencia anteriormente destacan aquellas en las que se intenta hacer una operacin imposible como puede ser realizar una operacin aritmtica sobre un carcter. Veamosl con unos ejemplos.

Ejemplo Dim Dato Dato = InputBox$("Introduzca un valor numrico") Dato = Dato + 100

En este ejemplo, el usuario introducir un valor numrico, pero el programa lo entender como una cadena de caracteres, (Dato = "200"). La siguiente operacin suma el entero 100 a la cadena "200". En este caso, el tipo de dato Variant realiza la conversin y el resultado ser que Dato = 300. En este caso, ha sido posible efectuar la operacin puesto que la cadena de caracteres tena una expresin numrica. Si hacemos una pequea modificacin en nuestro ejemplo y en vez de asignar Dato = "200" hacemos Dato = "PEPE20", podemos ver que la sentencia Dato = Dato + 100 no tiene sentido y por tanto el programa no aceptar semejante lnea de cdigo. Todas estas operaciones que hemos hecho con variables de tipo Variant, nos conducen a pensar que este tipo de dato debe tener una representacin interna que le relacione con los tipos de datos habituales. As cuando asignamos una cadena a una variable de tipo Variant aunque externamente no notamos nada, el programa trata a esa variable como si fuera un string. Existe una funcin en Visual Basic que nos va a devolver un valor que corresponde a la representacin interna de una variable tipo Variant. Se trata de la funcin VarType. Esta funcin acepta como argumento una variable y devuelve un entero. Dependiendo del valor devuelto, as estar tratando internamente a la variable (Tabla 8.1). Valor devuelto 0 1 2 3 4 5 6 7 8 Representacin interna Empty Null Integer Long Single Double Currency Date/Time String

Tabla 8.1. Valores devueltos por la funcin VarType.

Al hilo de esto ltimo, reseemos un poco de pasada, que Visual Basic contiene una serie de funciones que chequean el valor de la variable Variant e indican si ese valor puede ser convertido a los distintos tipos de datos. As la funcin IsNumeric(variant) devuelve el valor lgico TRUE si la variable Variant puede ser convertida a un tipo de dato numrico. Las funciones IsDate, IsNull, IsEmpty hacen lo propio con sus respectivos tipos de datos. Nota: una variable Variant tiene el valor Empty antes de que haya sido asignada a un valor y tiene un valor Null si su valor es desconocido.

8.4.- MDULOS

Cuando tenemos una aplicacin compleja, generalmente estar constituida por varias forms. No es nada extrao, que esas forms ejecuten una serie de lneas de cdigo comunes. En ese sentido, cabe la posibilidad de escribir esas lneas en cada form con la consiguiente duplicidad de cdigo que ello implica, o bien agrupar ese cdigo en un fichero para que pueda ser compartido por todas las forms que lo necesiten. Cuando hacemos esto ltimo, estamos utilizando un mdulo. Un mdulo es un conjunto de declaraciones y procedimientos almacenados en un fichero y que pueden ser invocados desde cualquier lugar de la aplicacin. Dentro de los procedimientos que pueden aparecer en un mdulo estn los procedimientos generales y los de eventos. Los procedimientos de eventos, son aquellos que son invocados cuando un objeto reconoce un evento. En ese instante, automticamente se produce una llamada al procedimiento del evento que ha ocurrido. Se establece as una asociacin entre el objeto y el cdigo que llama. Los procedimientos de eventos pueden ser definidos tanto para controles como para forms (puesto que como ya sabemos son los tipos de objetos que tenemos). Cuando se definen para un control, la sintaxis es la siguiente: Sub NombreControl_NombreEvento() sentencias de cdigo End Sub donde NombreControl es el nombre del control correspondiente (aquel que se especifica en la propiedad Name) y NombreEvento es el nombre del evento que ha ocurrido. Los eventos pueden ser de muchos tipos y dependen del control. Cuando se define un procedimiento de evento para un form, la sintaxis es: Sub Form_NombreEvento() sentencia de cdigo End Sub

Los procedimientos generales no son invocados cuando ocurre un evento, sino que son llamados explcitamente desde alguna parte del programa. Agrupan sentencias de cdigo que son utilizadas repetidas veces evitando la duplicidad de cdigo y facilitando el mantenimiento de la aplicacin. La forma de crear un mdulo es muy sencilla y basta seleccionar la opcin New Module del men File.

8.5.- PROCEDIMIENTOS
Al margen de que puedan aparecer en un mdulo o en otro sitio, los procedimientos en Visual Basic se agrupan en dos: - procedimientos Sub - procedimientos Function

8.5.1.- PROCEDIMIENTOS SUB

Ya hemos definido lo que es un procedimiento Sub. Su sintaxis general se ajusta al formato siguiente: Sub nombreProcedimiento(lista de argumentos) sentencias de cdigo End Sub Quiz la parte ms novedosa de esta sintaxis sea la lista de argumentos. En ella se pueden colocar uno o ms argumentos que sern nombres de variables con su correspondiente tipo de dato. Cuando se llama a un procedimiento con argumentos, se debe indicar en la sentencia de llamada, el valor de esos argumentos, de modo que cuando se ejecute el procedimiento esos argumentos sean sustituidos por sus respectivos valores.

Ejemplo Supongamos que tenemos un procedimiento Sub como el que aparece a continuacin: Sub Estadstica(NumDatos As Integer) ... End Sub Cuando invoquemos a este procedimiento debemos hacerlo de una de las siguientes formas: Estadstica 200 Call Estadstica(200) En este caso el valor 200 es el valor del argumento del procedimiento. Se puede llamar a un procedimiento Sub simplemente mediante su nombre seguido del valor de los argumentos. Otra forma es, preceder el nombre del procedimiento con la palabra Call y en este caso, introducir entre parntesis los valores de los argumentos.

Ejemplo Supongamos que queremos imprimir en pantalla todas las letras del alfabeto. Asociamos este procedimiento a un evento de tipo Click, de modo que cuando efectuemos un click sobre algn lugar de la ventana form, aparezca un cuadro de mensaje con las citadas letras. Sub Form_Click() Dim I As Integer, Letras As String For I = Asc("A") To Asc("Z") Letras = Letras & Chr(I) Next I

MsgBox Letras End Sub

El procedimiento tipo Sub aparece asociado a la ventana Form. Justo por debajo del nombre del procedimiento, tenemos una lnea de cdigo en la que hacemos una definicin de variables locales, una que almacenar nmeros enteros y otra que se encargar de almacenar la cadena de caracteres que forman el alfabeto. Como cosas ms nuevas, tenemos las funciones Asc() y Chr(). La primera toma el caracter que tiene como argumento y devuelve el valor ANSI correspondiente a ese caracter. La segunda realiza la tarea inversa, es decir, dado el cdigo ANSI devuelve la cadena de caracteres correspondiente a ese valor. Por ltiimo y como veremos con ms detalle en un prximo captulo, MsgBox crea una caja de dilogo donde se visualizar la salida de la aplicacin.

8.5.2.- PROCEDIMIENTOS FUNCTION

Su sintaxis es: Function NombreDelProcedimiento(argumentos) As TipoDeDato sentencias de cdigo End Function A parte de la palabra Function, la novedad que se incorpora aqu con respecto a los procedimientos Sub, es la introduccin de un tipo de dato para el propio procedimiento. El tipo de dato de un procedimiento Function determina el tipo de dato del valor devuelto por ese procedimiento. La forma de llamar a un procedimiento Function es mediante su nombre seguido de la lista de argumentos encerrados entre parntesis. Cuando se llama a un procedimiento de este tipo, se debe hacer desde una sentencia de programa que contenga otros elementos de manera que el valor que devuelve la funcin se asigne a alguna variable u otro elemento del programa. Ejemplo Supongamos que defino un procedimiento Function tal que, Function Media(Datos) Dim I, Suma As Integer, Media As Single For I = 1 To Datos Suma = Suma + I Next I Media = Suma / Datos End Function

Cuando vaya a invocar a este procedimiento lo debo hacer de la forma: X = Media(100) Text1.Text = Media(100) es decir, invocamos a la funcin desde una expresin ms compleja.

8.5.2.1.- Tipos de datos de los argumentos de funciones Al igual que cualquier otra variable, los argumentos de los procedimientos deben tener asociados un tipo de dato. Si no se especifica nada, stos toman el tipo de dato que Visual Basic tiene por defecto y que no es otro que el tipo de dato Variant. Cuando se quiere asignar a un argumento algn tipo de dato distinto del Variant, se debe declarar dentro de los parntesis y siguiendo la forma tradicional del Visual Basic. Ejemplo Function Gauss(Q As Single, E As Double) Se debe tener especial cuidado a la hora de trabajar con argumentos. Si definimos un argumento como perteneciente a un determinado tipo de dato, cuando vayamos a pasar a la funcin un valor para ese argumento, deber ser del mismo tipo de dato que el definido. Tampoco es posible pasar un dato de tipo Variant. Si en la funcin del ejemplo, pretendemos hacer: Dim Carga As Variant Carga="electrn" X=Gauss(Carga, E2) el programa genera un mensaje de error puesto que hemos pretendido pasar un dato de tipo Variant a un argumento definido como Single.

8.5.2.2.- Paso de argumentos a las funciones Existen dos formas de pasar argumentos a una funcin: - por referencia, - por valor. Cuando pasamos una variable a un procedimiento por referencia, lo que estamos haciendo es enviar al procedimiento la direccin de esa variable, no su valor. Esto implica que cualquier cambio que sufra la variable en el procedimiento se traduce en un cambio en el valor original de sta. Sin embargo, si pasamos ese argumento por valor, lo que estamos pasando es una copia de esa variable

y por tanto cualquier cambio que el procedimiento efecte sobre esa variable afectar a la copia y no a la variable original. Esto es, cuando el subprograma termine, el argumento tendr exactamente el mismo valor que cuando el subprograma comenz, con independencia de lo que haya sucedido al parmetro formal. La forma de pasar argumentos por valor es mediante la palabra ByVal. La sintaxis consiste en anteponer esta palabra al nombre de la variable. Ejemplo Function Superficie(ByVal Curva As Integer)

8.6.- ESTRUCTURAS DE CONTROL EN VISUAL BASIC

Al igual que en todos los lenguajes de programacin estructurados, Visual Basic tiene una serie de estructuras para controlar la ejecucin del cdigo. Estas estructuras se pueden dividir en estructuras de decisin y en estructuras de repeticin.

8.6.1.- ESTRUCTURAS DE DECISIN O SELECTIVAS

Un algoritmo, en general, suele necesitar elegir entre varias alternativas posibles. Esto se puede hacer gracias a las estructuras de decisin o estructuras selectivas. En ellas se evala una condicin y en funcin del resultado de la misma se realiza una opcin u otra. Esas condiciones se especifican usando expresiones lgicas. Dentro de las estructuras de decisin podemos encontrar tres tipos: - simples (estructura If ... Then) - dobles (estructura If ... Then ... Else) - mltiples (Select Case) 8.6.1.1.- Estructura If ... Then Su misin es la de ejecutar condicionalmente una o ms sentencias. La sintaxis de este tipo de estructuras es: If condicin Then sentencia o bien If condicin Then bloque de sentencias End If

Cuando se cumple la condicin entonces se ejecutan las sentencias, de lo contrario el programa contina su curso como si esas sentencias no existieran. Dentro de lo que aqu hemos llamado condicin podemos tener cualquier expresin o comparacin. Ejemplo If Edad < 12 Then Text1.Text = "Es muy pequeo" Text2.Text = "No puede ir al cine" End If

8.6.1.2.- Estructura If ... Then ... Else Su funcin es la misma que la anterior, solo que permite un control de varios bloques de sentencias. Su sintaxis es: If condicin1 Then bloque de sentencias 1 ElseIf condicin2 Then bloque de sentencias 2 .............................................. Else bloque de sentencias n End If Como todo el mundo puede deducir, si la condicin es cierta, se ejecuta el bloque de sentencias correspondiente. De lo contrario, contina el chequeo de condiciones hasta que analiza todas. Si todas son falsas, el programa sale de la estructura sin ejecutar ninguna sentencia. Si hay alguna condicin verdadera, el programa la ejecuta y busca en las siguientes.

Ejemplo If Semforo = 0 Then Text1.Text = "Puede pasar" ElseIf Semforo = 1 Then Text1.Text = "Vaya frenando" ElseIf Semforo = 2 Then Text1.Text = "Detngase" End If

8.6.1.3.- Estructura Select Case Permite la ejecucin selectiva de un bloque de sentencias entre varios posibles. Su sintaxis es: Select Case expresin

Case lista1 bloque de sentencias 1 Case lista2 bloque de sentencias 2 .......................................................... Case Else bloque de sentencias n End Select

El programa evala el valor de expresin. Si ese valor coincide con alguno de los que se encuentran en las listas, entonces se ejecuta el correspondiente bloque de sentencias y el programa abandona la estructura. La lnea Case Else se ejecuta si ninguna de las listas coincide con el valor de expresin. Cada lnea Case, puede contener ms de un valor, en cuyo caso estarn separados por comas. Hay que decir que solo se ejecutar un bloque de sentencias aunque el valor de expresin coincida con el valor presente en ms de una lnea Case. En este caso, siempre se ejecuta el bloque de sentencias de la primera lnea que cumpla la condicin.

Ejemplo Select Case Color Case Verde Text1.Text = "Puede pasar" Case Ambar Text1.Text = "Vaya frenando" Case Rojo Text1.Text = "Detngase" Case Else Text1.Text = "Esto no es un semforo, amigo" End Select

En este ejemplo se comprueba el valor de la cadena Color y ejecutar una u otra accin dependiendo de su valor. Si el color no es ni verde, ni rojo, ni mbar entonces se ejecuta la sentencia asociada a la lnea Case Else.

8.6.3.- ESTRUCTURAS REPETITIVAS

Si para algo estn hechos los ordenadores, eso es para repetir muy rpidamente una operacin o conjunto de ellas. Esto es misin de las estructuras repetitivas, las cuales repiten una accin un determinado nmero de veces. Las estructuras que repiten una secuencia de instrucciones un nmero determinado de veces se llaman bucles y se denomina iteracin al hecho de repetir la ejecucin de una secuencia de acciones.

Este tipo de estructuras, son de sobra conocidas por todos aquellos que han realizado algn programa por pequeo que ste haya sido. La forma general de los bucles es idntica en casi todos los lenguajes y tan slo surgen pequeas variaciones en la sintaxis. Visual Basic tiene dos tipos de estas estructuras: - los bucles Do ... Loop - los bucles For ... Next

8.6.2.1.- Bucles Do ... Loop La caracterstica esencial de esta estructura, es que se repite un nmero indefinido de veces, es decir, el programador no sabe a priori cuantas iteraciones van a producirse. Existen varias modalidades de bucles Do ... Loop. La primera que vamos a ver es la estructura, Do While condicin sentencias Loop Cuando Visual Basic se encuentra con una estructura de esta guisa, lo primero que hace es fijarse en la condicin. Si la condicin es verdadera, entonces ejecuta las sentencias que hay dentro del cuerpo de la estructura. Una vez ejecutadas vuelve a chequear la condicin. Cuando la condicin es falsa, el proceso abandona el bucle y contina la ejecucin normal del programa. De esto se deduce que el bucle se ejecutar mientras la condicin sea verdadera. Otra variacin de esta estructura es, Do sentencias Loop While Condicin Aqu la primera vez que el proceso se encuentra el bucle, ejecuta las sentencias que hay en su interior. Despus de hacer sto, lee la lnea Loop While condicin. El programa chequea la condicin y si es verdadera vuelve a ejecutar el cuerpo del bucle, pero si es falsa abandona y sigue la ejecucin normal del programa. Hay que destacar que independientemente del valor de la condicin, el programa ejecuta, al menos una vez, las sentencias del interior del bucle. Como estructuras "opuestas" a estas dos primeras, Visual Basic ofrece otras dos, Do Until Condicin Sentencias Loop y Do

Sentencias Loop Until

Ambas estructuras se ejecutarn repetitivamente mientras la condicin sea falsa. Una vez que condicin es verdadera, se abandona el bucle.

8.6.2.2.- Bucles For ... Next Pero si alguna estructura repetitiva se lleva la palma en Basic, esta es sin duda el famoso bucle For Next. Este bucle es herencia directa de las primeras versiones del Basic, y Visual Basic lo incorpora en toda su plenitud. La principal caracterstica de este bucle, es que el programador conoce de antemano el nmero de veces que va a repetirse. La sintaxis del bucle es, For contador = inicio To fin Step incremento Sentencias Next contador El bucle fija unos valores iniciales y finales. A partir del valor inicial y mediante un incremento o decremento de este valor el bucle se ejecuta hasta que se alcance el valor final. El contador va cambiando hasta llegar a contador = fin. En ese momento, se abandona el bucle y contina la ejecucin del programa. Ni que decir tiene que en cada iteracin se ejecutan las sentencias del interior del bucle. El grado de crecimiento o disminucin del contador, viene determinado por el valor de incremento. El incremento por defecto es 1, pero puede tomar cualquier valor ya sea positivo o negativo.

8.7.- DESARROLLO DE UNA APLICACIN

En estos momentos deberamos estar lo suficientemente preparados para poder escribir muchos programas en Visual Basic. Aunque todava nos falta definir algunos conceptos avanzados, con lo visto en este captulo se pueden crear aplicaciones ciertamente interesantes. Vayamos con una de ellas. Calcular la suma de los n primeros nmeros naturales. La aplicacin debe contener dos ventanas de texto, debidamente etiquetadas, una para la entrada del nmero de trminos y otra para la salida del resultado. Adems colocaremos tres botones de comando, uno para cancelar la aplicacin, otro para reinicializarla y otro para iniciar el clculo. Vamos a demostrar inmediatamente que esto es ms difcil plantearlo que hacerlo. El diseo del interface grfico puede ser algo como lo que aparece en la siguiente ventana (Fig. 8.1).

Fig. 8.1. Interface grfico de la aplicacin.

En la primera caja de texto se introduce el nmero de trminos que queremos sumar. Una vez escrito el nmero se hace click sobre el botn OK y automticamente aparece el resultado de la suma en la casilla Resultado. Si queremos volver a efectuar otra suma sin abandonar la aplicacin pulsamos el botn Continuar y se inicializa la ventana. Para abandonar la aplicacin pulsaremos el botn Salir. A continuacin vamos a dar el cdigo de la aplicacin, del cual cabe destacar alguna cosilla. En primer lugar observar el bucle For Next asociado al botn de comando OK (cmdOK). En segundo lugar comentar dos funciones que hemos utilizado las cuales son Val() y Str$(). La primera devuelve el valor numrico de una cadena de caracteres y la segunda convierte en cadena de caracteres un valor numrico. La misin de estas funciones en el programa es convertir a un nmero el texto que introduce el usuario, puesto que todo lo que se escribe en una casilla de texto, sea numrico o no, el programa lo entiende como carcter. As mismo, convertimos el resultado de la suma en carcter para que igualmente pueda ser visualizado en la caja de texto txtResult. En tercer lugar, hemos usado el comando SetFocus para que cuando se inicialice la aplicacin la caja de texto 1 aparezca dispuesta para recoger la entrada de usuario. Por ltimo destacar el comando Show, cuya misin es presentar en pantalla nuevamente el form de la aplicacin. Su sintaxis es Form.Show. El resto del cdigo que aparece corresponde a la situacin de las propiedades para cada propiedad y alguna sentencia muy elemental.

VERSIN 3.00 Begin Form Form1 Caption = "Nmeros Naturales" Height = 4635 Left = 1725 LinkTopic = "Form1" ScaleHeight = 4230 ScaleWidth = 4155 Top = 1140 Width = 4275 Begin CommandButton cmdOK Caption = "OK" Height = 735 Left = 240 TabIndex = 7 Top = 3240 Width = 975 End Begin TextBox txtResult Height = 495 Left = 1800 TabIndex = 6 Top = 2160 Width = 2055 End Begin CommandButton cmdSalir Caption = "Salir" Height = 735 Left = 2880 TabIndex = 2 Top = 3240 Width = 975 End Begin CommandButton cmdCont Caption = "Continuar" Height = 735 Left = 1560 TabIndex = 1 Top = 3240 Width = 975 End Begin TextBox txtTerm Height = 495 Left = 1800 TabIndex = 0 Top = 1320 Width = 2055 End Begin Label Label3 Caption = "Suma de nmeros enteros positivos." FontBold = -1 'True

FontItalic = 0 'False FontName = "MS Sans Serif" FontSize = 12 FontStrikethru = 0 'False FontUnderline = 0 'False Height = 615 Left = 960 TabIndex = 5 Top = 120 Width = 2295 End Begin Label Label2 Caption = "Resultado :" Height = 255 Left = 360 TabIndex = 4 Top = 2280 Width = 1095 End Begin Label Label1 Caption = "Introduzca el nmero de trminos :" Height = 615 Left = 360 TabIndex = 3 Top = 1200 Width = 1215 End End Sub cmdCont_Click () txtTerm.Text = "" txtResult.Text = "" Show Fibona txtTerm.SetFocus End Sub Sub cmdOK_Click () Dim I, Suma, Lim As Integer Lim = Val(txtTerm.Text) For I = 1 To Lim Suma = Suma + I Next I txtResult.Text = Str$(Suma) End Sub Sub cmdSalir_Click () End End Sub

8.7.- ARRAYS
No vamos a perder mucho tiempo en la definicin de esta clase de estructura de datos puesto que su concepto terico se supone conocido. Lo que si haremos, es estudiar la forma en que Visual Basic trata a los arrays y que sintaxis tienen. La definicin tradicional de array lo sita como un conjunto finito y ordenado de elementos homogneos. Es finito, para poder ser tratado por un computador, es ordenado porque sus elementos estn perfectamente identificados por unos ndices y es homogneo puesto que todos los elementos que componen el array sern del mismo tipo de dato. Ya que Visual Basic aporta el tipo de dato Variant, cuando un array se defina de tipo Variant todos los elementos sern de ese tipo. Esto implica que al tener datos de tipo Variant, puedan coexistir dentro del array cadenas de caracteres, enteros, etc. La utilidad de los arrays es clara: nos permite referirnos a una serie de variables por el mismo nombre. Ser pues un ndice el que identifique a cada una de las variables. Este hecho hace que los arrays sean idneos para su tratamiento dentro de bucles y otras estructuras repetitivas. La primera diferenciacin que surge dentro de los arrays hace referencia a su dimensin. Es ese sentido, podemos hablar de arrays unidimensionales y de arrays multidimensionales. Los arrays unidimensionales o vectores, estn formados por matrices de una dimensin. Vienen identificados por un slo ndice. Los arrays multidimensionales se pueden asimilar a matrices de dimensin mayor que uno. Cada elemento del array estar identificado por tantos ndices como dimensiones tenga. As el array Minkowsky(x,y,z,t) ser un array tetradimensional. Una clasificacin ms interesante para el programador es aquella que divide a los arrays en estticos y dinmicos.

8.7.1.- ARRAYS ESTTICOS

Son aquellos cuyo tamao aparece indicado en la declaracin del array. Dim Celdas(100) As Integer El sistema reserva la suficiente cantidad de memoria para almacenar 100 variables de tipo Integer. Este tipo de definicin tiene varios inconvenientes, que seguro que no se escapan a nadie. En primer lugar necesitamos conocer cuantos elementos vamos a almacenar, cosa que no siempre es posible saber antes de ejecutar el programa. Otro inconveniente es que si reservamos un nmero de elementos y luego no los utilizamos todos, estamos desperdiciando un bien precioso de todo ordenador, la memoria. Por otro lado, tambin nos podemos quedar cortos en el nmero de elementos que hemos reservado.

Cuando trabajemos con arrays pequeos, los arrays estticos son una cmoda alternativa, pero cuando el volumen de datos es grande y desconocido veremos que hay mejores opciones. Ya que los arrays son variables, tambin necesitan ser declarados de la misma forma que estas. As no solo conviene precisar el tipo de dato, sino que es importante establecer el mbito o alcance del array. As podemos clasificarlos en globales, de mdulo y locales dependiendo de que queramos que su alcance abarque respectivamente a toda la aplicacin, a todos los procedimientos de un mdulo o al procedimiento en que se definen. Arrays globales: se declaran en la seccin de declaraciones de un mdulo y se utiliza la palabra Global seguida del nombre del array. Global Tringulo(100,200) As Single Arrays de mdulo: se declaran en la seccin de declaraciones del mdulo con la sentencia Dim seguida del nombre del array. Dim Tringulo(100,200) As Single Arrays locales: se declaran mediante la sentencia Static seguida del nombre del array. Esta declaracin ir ubicada en el procedimiento deseado. Static Tringulo(100,200) As Single

Todos los arrays locales de tamao prefijado son estticos.

8.7.2.- ARRAYS DINMICOS

Cuando hacemos desarrollos complejos, es vital mantener un control sobre la memoria del ordenador. Hemos visto antes, que con los arrays estticos necesitbamos saber de antemano su tamao. Como esto no siempre se consigue, una prctica comn era reservar por exceso, lo que se traduca en un absurdo gasto de memoria. Visual Basic siguiendo la lnea de otros lenguajes como por ejemplo el C, permite modificar en tiempo de ejecucin el tamao del array permitiendo una mejor gestin de la memoria del sistema. Los pasos necesarios para declarar un array dinmico son: 1.- declarar el array con las sentencias habituales segn su alcance, pero dejar vaco el contenido de los parntesis. Dim Tringulo() As Single 2.- Una vez que sepamos el nmero de elementos se redimensiona el array mediante la sentencia ReDim.

ReDim Tringulo(98,115) Una de las ms importantes ventajas de todo esto es que se puede redeclarar el array mediante variables, con lo cual no necesito conocer su valor. ReDim Tringulo(X,Y) La dimensin mxima de un array global y de mdulo es 8. Es posible definir arrays de mayor dimensin (hasta 60), mediante la sentencia ReDim, pero estos sern forzosamente locales. ReDim Coordenadas(X,Y,Z,U,V,W,T,R,S) As Integer

Ejemplo Supongamos que tenemos N datos de temperaturas. - Introducir los datos, - Calcular la media - Determinar cuantas son superiores a la media, cuantas inferiores y cuantas son iguales. A continuacin se introduce el interface de la aplicacin (Fig. 8.2 y Fig. 8.3)y el cdigo del programa.

Fig. 8.2. Ventana para la introduccin de datos.

Fig. 8.3. Ventana de presentacin de resultados.

CDIGO DE LA APLICACIN. VISUAL BASIC VERSIN 3.00 Begin Form frmTemp Caption = "Temperaturas" Height = 2385 Left = 1080 LinkTopic = "Form1" ScaleHeight = 1980 ScaleWidth = 4605 Top = 2115 Width = 4725 Begin CommandButton cmdCancel Caption = "Cancelar" Height = 495 Left = 3120 TabIndex = 3 Top = 1320 Width = 1215 End Begin CommandButton cmdFin Caption = "Fin de entrada de datos" Height = 495 Left = 240 TabIndex = 2 Top = 1320 Width = 2295 End Begin TextBox txtDato Height = 285 Left = 3120 TabIndex = 0 Top = 600 Width = 1215 End Begin Label lblDato Caption = "Introducir dato:" Height = 255 Left = 480 TabIndex = 1 Top = 600 Width = 1575 End End Dim NumDatos As Integer Dim Datos(100) As Double Sub cmdCancel_Click () End End Sub Sub cmdFin_Click () For I = 1 To NumDatos Total = Total + Datos(I) Next I

Media = Total / NumDatos

frmResult.Show frmResult.txtMedia.Text = Str$(Media) frmResult.txtNumDatos.Text = Str$(NumDatos) 'Clculo del nmero de datos que se separan de la media For I = 1 To NumDatos If Datos(I) = Media Then Igual = Igual + 1 ElseIf Datos(I) < Media Then Debajo = Debajo + 1 ElseIf Datos(I) > Media Then Encima = Encima + 1 End If Next I frmResult.txtIgual.Text = Str$(Igual) frmResult.txtDebajo.Text = Str$(Debajo) frmResult.txtEncima.Text = Str$(Encima) End Sub Sub cmdOk_Click () NumDatos = NumDatos + 1 Datos(NumDatos) = Val(txtDato.Text) txtDato.Text = "" txtDato.SetFocus End Sub Sub OKButton_Click () NumDatos = NumDatos + 1 Datos(NumDatos) = Val(txtDato.Text) txtDato = "" txtDato.SetFocus End Sub Sub txtDato_KeyPress (KeyAscii As Integer) If KeyAscii = 13 Then NumDatos = NumDatos + 1 Datos(NumDatos) = Val(txtDato.Text) txtDato.Text = "" End If End Sub

Begin Form frmResult Caption = "Anlisis" Height = 3480 Left = 2385 LinkTopic = "Form1" ScaleHeight = 3075 ScaleWidth = 3240 Top = 2460 Width = 3360 Begin TextBox txtNumDatos Height = 285 Left = 2400 TabIndex = 9 Top = 840 Width = 735 End Begin TextBox txtIgual Height = 285

Left = 2400 TabIndex = 7 Top = 2250 Width = 735 End Begin TextBox txtDebajo Height = 285 Left = 2400 TabIndex = 6 Top = 1770 Width = 735 End Begin TextBox txtEncima Height = 285 Left = 2400 TabIndex = 5 Top = 1290 Width = 735 End Begin TextBox txtMedia Height = 285 Left = 2400 TabIndex = 4 Top = 120 Width = 735 End Begin Label lblTotal Caption = "Nmero de datos" Height = 255 Left = 120 TabIndex = 8 Top = 840 Width = 1575 End Begin Label lblIgual Caption = "Igual que la media" Height = 255 Left = 120 TabIndex = 3 Top = 2280 Width = 1935 End Begin Label lblDebajo Caption = "Por debajo de la media" Height = 255 Left = 120 TabIndex = 2 Top = 1800 Width = 2055 End Begin Label lblEncima Caption = "Por encima de la media" Height = 255 Left = 120 TabIndex = 1 Top = 1320 Width = 2055 End Begin Label lblMedia Caption = "Media" Height = 255

Left = 120 TabIndex = 0 Top = 120 Width = 615 End End

8.8.- ESTRUCTURAS
Hemos visto que las variables simples pueden almacenar un nico elemento de informacin y que los arrays pueden guardar un cierto nmero de elementos de informacin del mismo tipo de dato. Estos dos mecanismos de almacenamiento de datos pueden funcionar en una gran variedad de situaciones. Pero, a menudo, es necesario almacenar en una nica unidad datos de diferentes tipos. En este caso ni las variables ni los arrays son adecuados. Es claro, que el tipo de dato que va a resolver este problema es la estructura. Este concepto, de gran utilizacin en otros lenguajes como C y Pascal, le otorgan gran potencia a nuestro lenguaje. Las estructuras, son un tipo de datos que el propio usuario debe definirse. Visual Basic utiliza la sentencia Type para tal fin. La definicin de una estructura, debe hacerse siempre a nivel global y situarse en la seccin de Declaraciones de un mdulo. La sintaxis de este tipo de datos se explica en el siguiente ejemplo: Type Alumnos Nombre As String Apellidos As String Edad As Integer Notas As Single End Type

Las variables de tipo datos estructura, pueden tener cualquier alcance y pueden igualmente definirse en varios sitios. Dim Master As Alumnos, Doctorado As Alumnos

Las variables Master y Doctorado pertenecen al tipo de datos Alumnos. La forma de asignar un dato a esas variables es mediante el nombre de la variable seguido del nombre del elemento de la estructura conectado con un punto: Master.Edad = 25

CAPTULO 9

DISEO DE MENS 9.1.- INTRODUCCIN

Cuando adquirimos una aplicacin desarrollada para Windows, es prcticamente seguro que va a constar de una serie de nombres colocados justo debajo del ttulo de la aplicacin. Estos nombres forman la llamada barra de mens y constituyen uno de los elementos bsicos de cualquier aplicacin Windows. Ya que Visual Basic disea fundamentalmente aplicaciones para Windows, no poda ser ajeno a los mens y por tanto incorpora una ventana para el diseo de mens que permite su creacin de forma muy sencilla. Podemos definir a los mens como la forma grfica escogida para lograr la comunicacin entre la aplicacin y el usuario a travs de una serie de comandos de fcil acceso. La Fig. 9.1 muestra todos los elementos de un men.

Fig. 9.1. Elementos de un men.

Intentando buscar una mejor asimilacin de todos los conceptos definidos en el captulo, incluimos una aplicacin ejemplo, denominada MENUS.MAK. El cdigo completo se incluye al final del captulo. Iremos comentando los distintos pasos en la creacin de la aplicacin a lo largo del captulo.

9.2.- CREACIN DE MENS

La creacin de mens se realiza, generalmente, en la fase de diseo de la aplicacin. Para ello, Visual Basic incluye una herramienta especfica denominada ventana de diseo de mens. Esta ventana se despliega a travs de la opcin MenuDesign del men Window del entorno de trabajo de Visual Basic. La ventana de diseo de mens aparece reflejada en la Fig. 9.2.

Fig. 9.2. Ventana de diseo de mens.

Esta ventana contiene una serie de elementos que iremos viendo a lo largo del captulo, pero de momento vamos a detenernos en dos de ellos que tienen especial trascendencia. Estos elementos corresponden a las casillas etiquetadas con las palabras Caption y Name. Se tratan de dos propiedades ya conocidas y que esta vez se incorporan a los mens. La propiedad Name representa el nombre con el que nos referiremos a ese elemento de men mientras que la propiedad Caption representa el texto que aparece en el men. Las otras propiedades correspondientes a este control se mostrarn posteriormente. En la caja de listas de la ventana de diseo de mens, figuran los ttulos de las diferentes opciones del men. Seleccionado un elemento de men desde esa caja, podemos editar todas sus propiedades. Como puede verse en la figura 9.2, la caja de listas contiene una serie de nombres colocados uno debajo de otro y a distintos niveles de indentacin. Cuando un nombre no est indentado quiere decir que ese elemento ser el nombre genrico del men, es decir, lo que hemos llamado en la Fig. 9.1 Ttulo de Men. El siguiente nivel de indentacin corresponde al elemento del men. Podemos ir creando diferentes submens sin ms que ir indentando nombres a la derecha.

Ejemplo La Fig. 9.2 corresponde a la ventana de diseo del men de la Fig. 9.1. Como puede verse, existe un ttulo de men denominado Fichero y que est colocado en la izquierda de la ventana. Un nivel a su derecha tienen las opciones Cargar, Salvar y Salir, lo que quiere decir que estas tres opciones son los tres elementos de men del men Fichero.

Anlogamente, se puede explicar el desarrollo del men Opciones.

Todos los elementos del men que aparecen pegados al margen izquierdo de la caja de listas se les denomina Ttulo del men y son los que el usuario puede observar en la barra de mens de sus aplicacin. Cuando los elementos del men estn indentados una sola vez, se muestran al usuario cuando este selecciona cualquiera de los ttulos de men precedentes. Cuando un elemento de men est seguido por una serie de elementos de men indentandos respectos al primero, se le denomina Ttulo de submen. Todos los elementos indentados bajo un ttulo de submen sern considerados elementos del submen. Si queremos crear un men determinado para una Form concreta, primero debemos seleccionar la Form y despus activar la ventana de diseo de mens. En la caja de texto etiquetada como Caption introduciremos el nombre pblico del men que ser copiado automticamente a la caja de listas. En la caja de texto del nombre introduciremos la referencia con la que nos referiremos a ese men en nuestro cdigo. Si queremos, tambin podemos validar y establecer cualquiera de las otras propiedades: Window List, Ckecked, Enabled, Visible, HelpContextID. Manipulando los botones de la caja de listas podemos ir creando mens anidados y de diversos niveles de profundidad. En la figura siguiente (Fig. 9.3), correspondiente al ejemplo, podemos ver mens anidados en varios niveles.

Fig. 9.3. Anidacin de mens.

Arrays de mens. Un array de men es un conjunto de elementos de un men que comparten el mismo nombre y el mismo cdigo asociado. El empleo de arrays de mens simplifica el cdigo necesario para manejar las opciones reseadas por dichos mens. Tambin sirven para crear, en tiempo de ejecucin, nuevos mens, con la posibilidad de crecimiento/decrecimiento dinmico de un men asignado a un array. Cada elemento de un array de men est identificado con un nombre que es idntico en todos los miembros del array y con un ndice que es distinto para cada elemento. Este ndice ser el que nos servir para identificar cual ha sido el elemento del men seleccionado por el usuario.

Para crear un array de men en la ventana de diseo de mens, primero tenemos que rellenar las propiedades Caption y Name del primer elemento del array. Acto seguido tenemos que poner en la propiedad Index el valor 0 (correspondiente al primer elemento de dicho array). Posteriormente iremos creando otros miembros del array, con el mismo nombre e iremos aumentando el valor numrico de la propiedad Index con cada nuevo elemento.

9.3.- CDIGO ASOCIADO A LOS MENS

Cuando ya tenemos definidos todos los mens de nuestra aplicacin, debemos escribir el cdigo asociado a ellos, el cual ser el encargado de ejecutar las funciones que tiene asignadas cada men. Vamos a estudiar el cdigo asociado al men Fichero de nuestro programa ejemplo. Los mens se han creado utilizando arrays de mens. Si nos fijamos en la ventana de diseo de mens, podemos ver que este men consta de 4 elementos (Cargar, Salvar, Barra Separadora y Salir) cuyos ndices son respectivamente 0,1,2,3. La barra separadora es en si misma un elemento del array pues posee un determinado ndice (2), pero el usuario no podr realizar ninguna seleccin sobre este elemento. Para referirnos a un elemento de men de un array, utilizaremos su ndice. As por ejemplo, en el programa que nos ocupa, el elemento Salvar ser referido como TtuloMenu1(1), es decir, el nombre del array de men, seguido del ndice del elemento correspondiente entre parntesis. Como veremos en el cdigo siguiente, cuando el usuario selecciona un determinado elemento del men Fichero, el ndice correspondiente es pasado como argumento al procedimiento NombreArrayMenu _Click (Index), pues hay que recordar, que los arrays de mens comparten el mismo cdigo en los procedimientos para responder a los eventos que se produzcan. Sub ArrayMenu_Click (Index As Integer) Select Case Index Case 0 MsgBox " El usuario ha seleccionado el men Cargar ", 0, "Atencin" Case 1 MsgBox " El usuario ha seleccionado el men Salvar ", 0, "Atencin" Case 3 a% = MsgBox("El usuario ha seleccionado el men Salir, si no quiere salir aun y quiere crear un men dinmico pulse Cancelar", 33, "Atencin") Select Case a% Case 1 End

Case 2 MaxIndice% = MaxIndice% + 1 Load ArrayMenu(MaxIndice%) ArrayMenu(MaxIndice%).Caption = "Intento de Salida Abortado n " + Str$ (MaxIndice% - 3) End Select Case Else MsgBox "El usuario ha seleccionado opciones del men dinmico", 0, "Atencin" End Select End Sub

En el cdigo anterior utilizamos la sentencia Select Case para seleccionar el cdigo que debe ser ejecutado, en base al valor que es pasado como argumento de ArrayMenu_Click.

9.4.- MENS DINMICOS

La facilidad que tienen los mens de poder "crecer" en tiempo de ejecucin es muy aprovechada, por ejemplo, en los programas de edicin de textos, donde nos ofrecen la posibilidad de elegir entre los ltimos documentos abiertos, gracias a la insercin de los ttulos de dichos documentos a un men determinado en tiempo de ejecucin. Como ya hemos visto, nuestro programa MENU.MAK ofrece esta posibilidad y el cdigo encargado de generar los mens dinmicos fue mostrado anteriormente. Los principales elementos del cdigo que acabamos de presentar para la creacin de mens dinmicos son: 1- MaxIndice% = MaxIndice% + 1 2- Load ArrayMenu(MaxIndice%) 3-ArrayMenu(MaxIndice%).Caption="Intento de Salida Abortado n" + Str$(MaxIndice% 3) Mediante la primera sentencia, buscamos el ndice mas alto del array de men correspondiente (la creacin y manipulacin de mens dinmicos es competencia exclusiva del correspondiente array de men) y lo aumentamos en una unidad, es decir, buscamos un nuevo ndice para nuestro nuevo men. En la segunda lnea, y mediante la sentencia Load se crea dinmicamente, un nuevo elemento de dicho array. En caso de que se le suministre un ndice correspondiente a un elemento ya existente, generar un error. Por ltimo, la tercera lnea de programa, asigna un nuevo ttulo al elemento de men recin creado. En caso que no se le asigne ninguno, automticamente tomar el ttulo del primer elemento de men del array.

Todos los controles creados dinmicamente en tiempo de ejecucin pueden ser manipulados de diferentes maneras: - escondidos, utilizando el mtodo Hide o simplemente asignando a la propiedad Visible del control en cuestin el valor Falso. - Borrados de la memoria con la sentencia Unload que descargara de la memoria el objeto especificado.

9.5.- SUBMENS
Cada men puede incluir hasta cuatro niveles de submens. La utilizacin de submens se hace, generalmente, para no recargar demasiado la barra de mens o cuando un men es poco usado o cuando pretendamos indicar al usuario una serie de relaciones jerrquicas de las operaciones a realizar, etc. En la figura siguiente (Fig. 9.4), podemos ver una serie de submens en diferentes niveles.

Fig. 9.4. Diferentes niveles de mens y submens.

Conviene decir que el excesivo uso de submens es poco recomendable tanto desde un punto de vista esttico como operativo, por lo que se aconseja no utilizar ms de dos niveles de submens. Para la creacin de submens tan solo hay que utilizar las tabulaciones en la ventana de diseo de mens. Cada tabulacin supone un nuevo nivel de submens. En la figura siguiente (Fig. 9.5) a parecen las tabulaciones de los mens correspondientes a la figura anterior:

Fig. 9.5. Diseo de submens en la ventana de diseo de mens.

9.6.- ELEMENTOS DE LOS MENS

9.6.1.- BARRAS SEPARADORAS

Las barras separadoras son lneas horizontales que sirven como separacin entre los elementos de un mismo men , dividiendo a este en grupos lgicos.

Para crear las barras separadoras tan solo hace falta poner en la ventana de diseo de mens la propiedad Caption = "-".

9.6.2.- TECLAS DE ACCESO Y TECLAS DE ACCESO RPIDO

Las teclas de acceso son aquellas que nos permiten abrir un men, presionando la tecla ALT y la tecla correspondiente al carcter que aparezca subrayado en el men. Como vemos en la Fig. 9.6, las teclas de acceso aparecen subrayadas. As la tecla de acceso del elemento del men Salvar ser: ALT + S. Para asignar teclas de acceso a los mens, tan solo tenemos que poner delante de la letra que queramos que sea la tecla de acceso el signo &. Esto har que en tiempo de ejecucin dicha letra aparezca subrayada, indicndonos que es una tecla de acceso. Las teclas de acceso rpido ejecutan un men inmediatamente cuando son presionadas. Estas teclas incluyen combinaciones de las teclas de funcin y de la tecla CTRL. En la Fig. 9.6, podemos ver dos teclas de acceso rpido: Ctrl+C y Ctrl+S. Para asignar una tecla de acceso rpido a un men determinado, seleccionaremos la combinacin de teclas de acceso rpido de la caja combinada que aparece etiquetada con la palabra Sortcut en la ventana de diseo de mens.

Fig. 9.6. Teclas de acceso y teclas de acceso rpido.

9.7.- CONTROL DE MENS EN TIEMPO DE EJECUCIN

Como ya hemos visto antes, los mens pueden crecer en tiempo de ejecucin, pero tambin pueden modificar su apariencia en funcin de las necesidades del programador. De ese modo, es posible poner una marca en una opcin para indicar al usuario que ha validado dicha opcin, deshabilitar un men que no pueda estar operativo en un determinado momento del programa, o incluso, hacer invisibles mens a voluntad del programador. En la siguiente figura (Fig. 9.7) podemos ver un ejemplo que muesta estos casos:

Fig. 9.7. Control de mens en tiempo de ejecucin.

9.7.1.- HABILITACIN / DESHABILITACIN DE MENS

Todos los mens tienen una propiedad denominada Enabled. Esta propiedad puede tener tan solo dos valores, verdadero o falso. Si tiene el valor falso, el men ser deshabilitado, no pudiendo responder a las acciones del usuario. Visualmente el men que ha sido deshabilitado aparece en un tono gris para indicar precisamente esa situacin al usuario. Como ocurre con el resto de propiedades, es posible modificar su valor en tiempo de ejecucin. En el caso de nuestra aplicacin MENU.MAK, hemos deshabilitado el men Courier desde el comienzo del diseo. Para ello tan solo tenemos que marcar la caja de verificacin Enabled de la ventana de diseo de mens.

9.7.2.- MENS CON MARCAS DE VERIFICACIN

Gracias a estas marcas, es posible que el programador pueda indicar al usuario en tiempo de ejecucin cual ha sido su ultima eleccin en un determinado men. As por ejemplo, en los programas de edicin de textos, se utilizan las marcas de verificacin para recordar al usuario cual es el tamao de letra que ha utilizado o simplemente cual es el tipo de letra en uso. El manejo de las marcas de verificacin depende nicamente de la propiedad Cheked comn a todos los mens. Es posible modificar su valor tanto en tiempo de diseo, (casilla Checked), como en tiempo de ejecucin. El cdigo siguiente, es un extracto del cdigo de nuestro ejemplo y muestra la posibilidad de poner marcas de verificacin en tiempo de ejecucin. Sub Submenu1_Click () If Submenu1.Checked = 0 Then Submenu1.Checked = -1 Submenu2.Checked = 0 End If End Sub Esta rutina testea el valor de la propiedad Checked. Si es falsa, la cambia a verdadera y asigna un valor falso en la propiedad Checked de su men vecino (Submenu2). La siguiente rutina hace justamente lo contrario, permitiendo al usuario marcar o desmarcar un men u otro. Sub Submenu2_Click () If Submenu2.Checked = 0 Then Submenu2.Checked = -1 Submenu1.Checked = 0 End If

End Sub

9.7.3.- VISIBILIDAD DE MENS

En la ventana de diseo de mens existe una casilla de verificacin que nos permite asignar en tiempo de diseo la propiedad de visibilidad de dicho men. Tambin es posible cambiar el valor biestable de dicha propiedad en tiempo de ejecucin. El siguiente cdigo modifica la propiedad Visible. If Menu1.Visible = Verdadero then Menu.Visible = Falso End If

Cuando hacemos un men invisible en tiempo de ejecucin, el lugar ocupado por dicho men es cubierto por el siguiente y dicho men no es accesible para el usuario.

9.8.- DISEO DE MENS POP-UP

La ltima versin de Visual Basic para Windows, incorpora, junto a los mens ya conocidos, un nuevo tipo de men llamado "pop-up". La caracterstica fundamental de este tipo de mens es que pueden aparecer sobre cualquier form, independientemente de que esa form ya posea su propia barra de mens. Los mens pop-up pueden colocarse en cualquier lugar de la ventana form. Se puede usar como men pop-up, cualquier men que tenga al menos, un submen. La forma de visualizar un men de este tipo es mediante el mtodo PopupMenu. La sintaxis de este mtodo es la siguiente: [form] PopupMenu NombreDelMenu [, Flags[, X[, Y]]] donde, form NombreDelMenu X, Y Flags indica el nombre del form sobre el que se visualizar el men, especifica el nombre que vamos a dar al men coordenadas en las que se colocar el men, relativas al form definen la posicin y el comportamiento del men.

Los mens pop-up permiten la visualizacin rpida de un men. Es costumbre asociar el botn derecho del ratn con la posibilidad de visualizar un men pop-up. Esta posibilidad debe ser usada junto con los eventos MouseUp y MouseDown los cuales detectan el botn de ratn que ha

sido pulsado. (La utilizacin de estos dos eventos se describe con ms detalle en el captulo dedicado al ratn). Cuando estamos trabajando sobre una determinada form, slo se puede visualizar, a la vez y sobre ella, un men de este tipo.

Fig. 9.8.- Ejemplo de un men Pop-Up sobre la ventana de una form.

En general, un men de esta ndole no debe ser uno de los que estn disponibles en la barra de mens, ya que no tendra demasiado sentido hacer tal cosa. Estos mens permanecen invisibles hasta que se mandan activar mediante el ratn u otro mecanismo. La forma de crear los mens pop-up es idntica a como se hace con los dems mens, es decir, se abre la ventana de diseo de mens y se colocan los correspondientes items. El men se hace invisible y se invoca al mtodo desde el cdigo en tiempo de ejecucin. Podemos colocar los mens pop-up en cualquier lugar de la pantalla sin ms que especificar las coordenadas X, Y. Estas coordenadas estarn referenciadas al form sobre el que se visualizar el men. Cuando no especifiquemos las coordenadas, el men se colocar donde indique el puntero del ratn. El parmetro Flag indicar la posicin del men respecto a las coordenadas X, Y. As tenemos las siguientes posibilidades segn sea el valor de Flag: POPUPMENU_LEFTALIGN (0) la X define la esquina izquierda del men. POPUPMENU_CENTERALIGN el men aparece centrado respecto a la X especificada. POPUPMENU_RIGHTALIGN la X define el borde derecho del men. POPUPMENU_LEFTBUTTON el men reconoce la seleccin de un item cuando se presiona el pulsador izquierdo del ratn. POPUPMENU_RIGHTBUTTON el men reconoce la seleccin de un item tanto al pulsar el botn izquierdo del ratn como el derecho.

Es posible la combinacin de varias de estas opciones mediante el operador Or.

Ejemplo PopupMenu mnuTBO, POPUPMENU_CENTERALIGN Or POPUPMENU_RIGHTBUTTON, 100, 100 Con esta sentencia el men se coloca con su parte superior centrada en la ventana form. Los items se seleccionan mediante la pulsacin de cualquiera de los dos botones del ratn.

9.9.- LISTADO DEL PROGRAMA MENU.MAK

MICROSOFT VISUAL BASIC VERSIN 3.00
Begin Form Form1 BackColor = &H00C0C0C0& Caption = "MENUS" Height = 1680 Left = 2295 LinkTopic = "Form1" ScaleHeight = 990 ScaleWidth = 3735 Top = 1605 Width = 3855 Begin Menu TtuloMenu1 Caption = "&Fichero" Begin Menu ArrayMenu Caption = "&Cargar" Index = 0 Shortcut = ^C End Begin Menu ArrayMenu Caption = "&Salvar" Index = 1 Shortcut = ^S End Begin Menu ArrayMenu Caption = "-" Index = 2 End Begin Menu ArrayMenu Caption = "Sa&lir" Index = 3 End End Begin Menu TtuloMenu2 Caption = "&Opciones" Begin Menu Articulo1Menu2 Caption = "&Color" Begin Menu Articulo1Submenu1 Caption = "&Rojo" End Begin Menu Articulo2Submenu1 Caption = "&Amarillo" Begin Menu Submenu1 Caption = "&Claro" Checked = -1 'True End Begin Menu Submenu2 Caption = "&Obscuro" End End End Begin Menu Articulo2Menu2 Caption = "&Fuentes" Begin Menu Articulo1Submenu2 Caption = "&Times Roman "

Checked = -1 'True End Begin Menu Articulo2Submenu2 Caption = "&Arial " End Begin Menu Articulo3Submenu3 Caption = "&Courier" Enabled = 0 'False End End End End

Sub ArrayMenu_Click (Index As Integer)

Select Case Index

Case 0 MsgBox " El usuario ha seleccionado el menu Cargar ", 0, "Atencion" Case 1 MsgBox " El usuario ha seleccionado el menu Salvar ", 0, "Atencion" Case 3 a% = MsgBox(" El usuario ha seleccionado el menu Salir , si no quiere salir aun y quiere crear un menu dinamico pulse Cancelar ", 33, "Atencion") Select Case a% Case 1 End Case 2 MaxIndice% = MaxIndice% + 1 Load ArrayMenu(MaxIndice%) ArrayMenu(MaxIndice%).Caption = "Intento de Salida Abortado n" + Str$(MaxIndice% - 3) End Select Case Else MsgBox " El usuario ha seleccionado opciones del menu dinamico ", 0, "Atencion" End Select End Sub Sub Form_Load () MaxIndice% = 3 End Sub Sub Submenu1_Click () If Submenu1.Checked = 0 Then Submenu1.Checked = -1 Submenu2.Checked = 0 End If

End Sub Sub Submenu2_Click () If Submenu2.Checked = 0 Then Submenu2.Checked = -1 Submenu1.Checked = 0 End If End Sub

CAPTULO 10 CUADROS DE DILOGO 10.1.- INTRODUCCIN

Las cajas de dilogo o tambin llamadas cuadros de dilogo, constituyen una de las formas habituales que tiene Windows de presentar una determinada informacin al usuario o bien de pedirle la confirmacin de una accin para que la aplicacin contine. En la figura 10.1 se muestra una de las cajas de dilogo ms conocidas, la cual nos avisa de que vamos a salir de Windows y nos pide confirmacin de este hecho. En ella se pueden ver perfectamente las caractersticas de los cuadros de dilogo, esto es, un pequeo mensaje y dos botones de comandos, uno para continuar y otro para anular la orden que provoc el despliegue de la caja de dilogo.

Fig. 10.1. Ejemplo de caja de dilogo.

Al igual que hicimos en el captulo anterior, vamos a desarrollar un programa para la creacin de cajas de dilogo. El programa se llama CD.MAK, su cdigo completo se aade al final del captulo, y nos va a permitir ir construyendo diferentes tipos de cuadros de dilogo. En las dos figuras que vienen a continuacin se muestran los dos tipos de cuadros de dilogo. La Fig. 10.2 se encarga de presentar un mensaje de aviso al usuario. En este caso se trata de una de las aplicaciones ms famosas para el diseo de presentaciones, el CorelDraw. Se indica la versin del programa y datos de Copyright y adems informacin sobre el espacio libre en el disco duro. Dispone de un botn de comando para abandonar el cuadro de dilogo y continuar con la aplicacin.

Fig. 10.2. Cuadro de dilogo para presentacin de un mensaje o datos de inters.

La Fig. 10.3 pide al usuario que introduzca una determinada informacin. Esa informacin que debe introducir el usuario sirve al sistema para realizar una determinada accin. Concretamente

es la caja de dilogo que se despliega en el procesador de textos Microsoft Word para Windows, cuando se elige la opcin Ir a... del men Edicin.

Fig. 10.3. Cuadro de dilogo para solicitar al usuario que introduzca una determinada informacin.

10.2.- TIPOS DE CUADROS DE DILOGO

Los cuadros de dilogo se clasifican en dos tipos: Modales: son aquellos en los que se hace necesaria la intervencin del usuario para que se pueda continuar trabajando. La ventana permanece en pantalla hasta que el usuario la cierre y mientras no lo haga es imposible continuar trabajando. As pues, en la Fig. 10.2, el usuario debe hacer un click en el botn OK del cuadro About del programa Corel Trace para poder seguir con su trabajo. Como ya habrs adivinado, este tipo de Cajas de Dilogo, se utilizan para forzar al usuario a leer o responder al mensaje que le es presentado. La ventana About Visual Basic del entorno de trabajo de Visual Basic, es un claro ejemplo de Cajas de Dilogo Modales. No modales: permiten al usuario cambiar el foco entre el cuadro de dilogo y cualquier otra ventana del sistema. Este tipo de cajas de dilogo es utilizado normalmente para mostrar informacin. La ventana Project del Visual Basic es un buen ejemplo de este tipo de cajas de dilogo. Nuestro programa CD.MAK, presenta en pantalla una ventana (Fig. 10.4) en la que podemos probar todos estos conceptos que acabamos de definir. La aplicacin nos permite crear cajas de dilogo modales y no modales.

Fig. 10.4. Salida de la aplicacin CD.MAK para el diseo de cuadros de dilogo.

10.3.- CUADROS DE DILOGO PREDEFINIDOS

Visual Basic ofrece como facilidad adicional, la posibilidad de utilizar cuadros de dilogo predefinidos. Estos liberan al programador del diseo y de la carga y descarga de tales cuadros de dilogo, aunque el control que nos ofrecen sobre su diseo es limitado. A pesar de ello son muy utilizados puesto que son suficientes para la mayora de los casos.

El manejo de estos cuadros de dilogo est a cargo de las funciones InputBox y MsgBox y de la sentencia MsgBox. En nuestro programa ejemplo se presentan estas tres posibilidades (Fig. 10.5).

Fig. 10.5. Programa CD.MAK. Cuadros de dilogo predefinidos.

10.3.1.- FUNCIN INPUTBOX

Usaremos la funcin InputBox cuando queramos presentar una caja de dialogo modal que obtenga una serie de datos del usuario. Ya que InputBox es una funcin, debe devolver un determinado valor. El valor devuelto no es otro que el contenido de la caja de texto que la acompaa. Dependiendo de que el dato que devuelve la funcin sea de tipo Variant o sea de tipo String la sintaxis es, respectivamente: Datos_de_Retorno = InputBox(Texto, Ttulo, Valor_defecto, X, Y) Datos_de_Retorno$ = InputBox$(Texto, Ttulo, Valor_defecto, X, Y) La figura 10.6 explica grficamente la sintaxis que acabamos de comentar.

Fig. 10.6. Descripcin grfica de la funcin InputBox[$].

10.3.2.- SENTENCIA MSGBOX

La sentencia MsgBox nos permite presentar al usuario una serie de pequeos mensajes, como errores o avisos. Junto a esto, la sentencia visualiza pequeos iconos predefinidos, que aclaran visualmente el sentido del texto contenido en la caja de dilogo. Tambin nos va a permitir escoger entre una serie de combinaciones de botones predefinidos.

Al tratarse de una sentencia no nos va a devolver informacin sobre el botn que hemos pulsado. La sintaxis de dicha sentencia es: MsgBox Mensaje , Tipo , Ttulo Nuevamente vamos a recurrir a una figura (Fig. 10.7) para describir grficamente la sintaxis de esta sentencia.

Fig. 10.7. Descripcin grfica de la sentencia MsgBox.

10.3.3.- FUNCIN MSGBOX

La funcin MsgBox solo se diferencia de la sentencia del mismo nombre, en que nos devuelve un valor (como es de rigor en todas las funciones). Este valor corresponde al nmero asignado a los botones que hayamos definido en nuestra caja de dilogo. En el ejemplo CD.MAK podemos observar, que segn cual sea nuestra eleccin al pulsar uno de los botones (Aceptar, Cancelar), la funcin devolver el entero 1 o el 2 respectivamente, valores que corresponden a las constantes IDOK e IDCANCEL. La sintaxis de esta funcin es prcticamente igual a la de la sentencia anterior, con la particularidad de que todos los argumentos van entre parntesis. ValorRetorno% = MsgBox(Mensaje, Tipo, Ttulo)

10.4.- CUADROS DE DILOGO A MEDIDA

Como ya hemos visto Visual Basic nos permite utilizar funciones y sentencias para mostrar cajas de dilogo predefinidas, pero a veces necesitamos disear cajas de dilogo ms complejas. En estas cajas de dilogo podemos incorporar cualquier objeto del Visual Basic como por ejemplo botones de opcin, cajas de texto, controles para el manejo de ficheros, etc. Como primer paso para el diseo de nuestra cajas de dilogo, tendremos que crear el "contenedor" que ser una nueva Form. Habr pues que crear una ventana form y moldear su apariencia externa mediante la manipulacin de sus propiedades. Las propiedades que modificaremos sern: Caption: donde figurar el titulo de nuestra cajas de dilogo.

BorderStyle: podemos escoger entre un borde doble o borde nico lo que imposibilitar el cambio de tamao de nuestra cajas de dilogo en tiempo de ejecucin. MaxButon y MinButon: que indicarn la existencia de los botones de maximizacin y minimizacin de nuestra Form. ControlBox: indica la existencia o no del men del sistema. Icon: seala el icono escogido para cuando el usuario iconize nuestra Form (esta capacidad que se le ofrece al usuario solo es posible si MinButon = True o si ControlBox=True). Height, Width, Left y Top: que nos permitirn escoger la anchura y altura de nuestra caja de dilogo as como su desplazamiento desde la esquina superior izquierda de la pantalla. Una vez que hayamos definido las propiedades de la Form recin creada, procederemos a incorporar cualquier clase de objetos en su interior. En la figura 10.8, se muestra una caja de dilogo con una serie de objetos (botones de comando, cajas de texto, botones de opcin) que nos permitirn escoger la apariencia de otra caja de dilogo que sigue a esta.

Fig. 10.8. Programa CD.MAK. Diseo de cuadros de dilogo.

Cuando pulsemos OK todos los datos introducidos, nos mostrarn una nueva caja de dilogo, que como hemos especificado en los datos introducidos ser Modal. Vamos a titularla "CAJA DE DIALOGO DE PRUEBA" y el texto que nos mostrar ser el siguiente: "ESTE TEXTO

ES TAN SOLO UN EJEMPLO". Adems, la caja presentar 3 botones cuyos ttulos sern respectivamente BOTON 1, BOTON 2 y BOTON 3. Inicialmente el botn 3 aparecer deshabilitado. En la figura 10.9 podemos ver el resultado de nuestro diseo.

Fig. 10.9.- Programa CD.MAK. Diseo de un cuadro de dilogo.

Otro punto importante surge al controlar la aparicin y desaparicin de nuestras cajas de dilogo. El siguiente cdigo muestra la aparicin de las dos cajas de dilogo anteriores: Form n1 Sub Diseo_Click () Form2.Show 1 End Sub

Como vemos en el cdigo asociado al Form n1, cuando el usuario selecciona el men "Diseo de Cuadros de Dilogo" se ejecuta el mtodo Form2,Show 1, el cual cargar y mostrar la Form n2 con estilo Modal (1). Form n2 Sub Command2_Click () Form3.Caption = Text4.Text

Form3.Label1.Caption = Text1.Text If Text2.Text = "" Then Form3.Command1.Visible = 0 Else Form3.Command1.Caption = Text2.Text End If If Text3.Text = "" Then Form3.Command2.Visible = 0 Else Form3.Command2.Caption = Text3.Text End If If Text5.Text = "" Then Form3.Command3.Visible = 0 Else Form3.Command3.Caption = Text5.Text End If If Option11.Value = -1 Then Form3.Command1.Enabled = -1 Else Form3.Command1.Enabled = 0 End If If Option13.Value = -1 Then Form3.Command2.Enabled = -1 Else Form3.Command2.Enabled = 0 End If If Option3.Value = -1 Then Form3.Command3.Enabled = -1 Else Form3.Command3.Enabled = 0 End If If Option1.Value = -1 Then Form3.Show 1 Else Form3.Show 0 End If End Sub Sub Command1_Click () Unload Form2 End Sub

En el cdigo asociado a la Form n 2 podemos ver como cuando el usuario selecciona el botn " OK" se recogen todos los valores que ha introducido, y se pasan a las propiedades de los objetos pertenecientes a la Form n3. Cuando este proceso se ha realizado, utilizamos el mtodo Show de nuevo para cargar y mostrar la caja de dilogo de tipo modal. Si el usuario escogiera el botn "Cancelar" se ejecutara la sentencia UnLoad, la cual descargara de memoria la Form n2 .

En este cdigo podemos observar como se alteran las propiedades de los objetos de una Form en tiempo de ejecucin. As por ejemplo, podemos habilitar o deshabilitar los botones de la caja de dilogo de acuerdo a las elecciones que el usuario hace en tiempo de ejecucin en la Form n2. Para deshabilitar un objeto tan solo debemos validar la propiedad Disable (Objeto.Disable = True). Tambin podemos controlar la visibilidad de un objeto validando o no, la propiedad Visible (Objeto.Visible=True).

Form n3 Sub Command4_Click () Unload Form3 End Sub Como podemos ver, el cdigo asociado a la Form n3 tan solo se ocupa de descargar de la memoria a esta caja de dilogo y por tanto ceder el control a la Form n2 .

10.5.- CUADROS DE DILOGO MS COMUNES

La edicin estndar de Visual Basic 3.0, incluye un nuevo Custom Control que permite la creacin de aquellos cuadros de dilogo que ms se utilizan en el entorno Windows. Hay que decir, que este mismo control se suministraba con la edicin profesional de Visual Basic 2.0. Estos cuadros son: - apertura de un fichero (Open) - grabar como (Save As) - imprimir (Print) - color (Color) - fuentes (Fonts) La misin fundamental de este control es facilitar y agilizar la creacin de los cuadros de dilogo antes citados. La forma de utilizacin de estos cuadros de dilogo es realmente simple. Por un lado, se coloca el control en la ventana del form correspondiente, y por otro, se deben dar diferentes valores a la propiedad Action del propio control. Este control es invisible en tiempo de ejecucin. La forma habitual de utilizarle es mediante su llamada desde un botn de comando o un men. Segn sea el valor de Action, as es el cuadro de dilogo que aparece. En ese sentido podemos describir la siguiente tabla:

Valor de Action 0 1 2 3 4 5 6

Cuadro de dilogo que aparece No aparece ninguno Open Save As Color Font Print Invoca al Help de Windows

Tabla 10.1.- Valor de la propiedad Action.

10.5.1.- CUADROS DE DILOGO Open (Abrir) Y Guardar Como (Save As)

Su misin es permitir al usuario la apertura de un fichero (para el cuadro Open) y la posibilidad de almacenar informacin en un fichero y dotar a ste de un nombre (para Save As). Tanto uno como otro son de sobra conocidos por todos. Su uso est mpliamente difundido en todas las aplicaciones Windows y se emplean desde los procesadores de texto hasta cualquier otra aplicacin que trabaje de alguna manera con ficheros. Para hacer eso, se ofrecen todas las facilidades posibles como pueden, ser la seleccin del disco y directorio en que se encuentra el fichero que vamos a abrir o el lugar en que vamos a guardar el fichero. Estas cajas, incorporan tambin la posibilidad de abrir o guardar un fichero para operaciones de slo lectura. Junto a la determinacin del valor de la propiedad Action, se debe determinar el valor de la propiedad Filter. Mediante ella, se especifica la extensin de los ficheros que aparecen en la lista de ficheros.

Fig. 10.10.- Cuadro de dilogo Abrir (Open).

Fig. 10.11.- Cuadro de dilogo Guardar Como (Save As).

10.5.2.- CUADRO DE DILOGO Color.

Permite al usuario seleccionar un color desde la paleta de colores o bien crear un color a medida. El color seleccionado pasa a formar parte de la propiedad Color una vez que hayamos cerrado el cuadro de dilogo. Ejemplo

Disear una aplicacin que permita visualizar el cuadro de dilogo Color y cambiar el color de fondo de la ventana form eligiendo el color deseado en dicho cuadro de dilogo. Este programa es muy sencillo, tan slo hay que poner un botn de comando en la ventana form junto al control de cuadros de dilogo. Para desplegar el cuadro Color se debe inicializar la propiedad Action a 3. El secreto para cambiar el color de fondo de la ventana form es establecer la propiedad BackColor del form con el valor de la propiedad Color de la caja de dilogo.

Sub Command1_Click() CMDialog1.CancelError = True On Error GoTo GestionDeErrores CMDialog1.Action = 3 Form1.BackColor = CMDialog1.Color GestionDeErrores: Exit Sub End Sub

Fig. 10.12.- Cuadro de Dilogo Color.

10.5.3.- CUADRO DE DILOGO Fuente

La Fig. 10.13, muestra el aspecto de salida del cuadro de dilogo Font (Fuente).

Fig. 10.13.- Cuadro de dilogo Fuente.

Como es de todos sabido, la misin de este cuadro de dilogo es la de permitir definir el tipo de letra, el tamao, el estilo y el color del texto. En ella aparecen tambin unas casillas de verificacin que permiten indicar efectos especiales sobre el texto, tales como tachar o subrayar. Todas la opciones que elijamos se reflejan en el marco etiquetado con Muestra, el cual nos indica la salida definitiva del texto con todas las opciones de tipo de letra, color, tamao, etc.

10.5.4.- CUADRO DE DILOGO Imprimir

No hace falta ser muy listo para darse cuenta que la caja de dilogo que aparece en la Fig. permite especificar las diferentes opciones de impresin. Entre ellas, est la seleccin de la impresora, el nmero de copias que queremos imprimir, la calidad de impresin de acuerdo a las posibilidades de nuestra impresora, la posibilidad de lanzar la impresin a un archivo en vez de hacerlo directamente a la impresora, etc.

Fig. 10.14.- Cuadro de dilogo Imprimir.

La forma de trabajar con este cuadro de dilogo es idntica a como lo hacamos con todas las dems. Algunas de las propiedades importantes de este cuadro son: - Copies: especifica el nmero de copias a imprimir. - FromPage: indica la pgina de comienzo de la impresin. - ToPage: indica la pgina en que debe finalizar la impresin.

Ejemplo CMDialog.FromPage=10 CMDialog.ToPage=20

10.6.- CDIGO DEL PROGRAMA EJEMPLO CD.MAK

A continuacin ofrecemos el listado completo del cdigo que constituye la aplicacin que hemos desarrollado para explicar los cuadros de dilogo. El cdigo aparece para cada una de las tres forms que hemos utilizado.

VISUAL BASIC VERSIN 3.00 Begin Form Form1 Caption = "CAJAS DE DIALOGO"

Height = 1980 Left = 1530 LinkTopic = "Form1" ScaleHeight = 1290 ScaleWidth = 6225 Top = 2490 Width = 6345 Begin Label Label2 Caption = "VARIABLE Texto$ =" Height = 255 Left = 120 TabIndex = 1 Top = 840 Width = 1815 End Begin Label Label1 BorderStyle = 1 'Fixed Single Height = 255 Left = 2040 TabIndex = 0 Top = 840 Width = 4095 End Begin Menu CP Caption = "&Cuadros Predefinidos" Begin Menu CPInput Caption = "&InputBox" End Begin Menu CPMsg Caption = "&MsgBox" Begin Menu Funcion Caption = "&Funcion" End Begin Menu Sentencia Caption = "&Sentencia" End End End Begin Menu Diseo Caption = "&Diseo de Cuadros de Dialogo" End End Sub CPInput_Click () Texto$ = InputBox("Esto es una prueba de la funcion InputBox. " + Chr$(13) + " El texto que el usuario introduca sera asisgnado a la variable Texto$ si el usuario selecciona el boton OK , si selecciona el boton CANCEL, la variable Texto$ estara vacia ", " Funcion InputBox ") Label1.Caption = Texto$ End Sub Sub Diseo_Click ()

Form2.Show 1 End Sub Sub Funcion_Click () p% = MsgBox("Ejemplo de la Funcion MsgBox." + Chr$(13) + Chr$(10) + " Si el usuario selcciona Aceptar la funcion devuelve 1 ." + Chr$(13) + Chr$(10) + "Si el usuario selcciona Cancelar la funcion devuelve 2. ", 49, " Funcion MsgBox ") If p% = 1 Then Texto$ = " El usuario ha selccionado Aceptar " Else Texto$ = " El usuario ha selccionado Cancelar " End If Label1.Caption = Texto$ End Sub Sub Sentencia_Click () MsgBox "Ejemplo de la Sentencia MsgBox." + Chr$(13) + Chr$(10) + " No podemos obtener la selecin del usuario ." + Chr$(13) + Chr$(10) + "Solo podemos presentar datos al usuario.", 49, " Sentencia MsgBox " Label1.Caption = " No hay constancia de la eleccin del usuario" End Sub Begin Form Form2 BackColor = &H00C0C0C0& BorderStyle = 1 'Fixed Single Caption = "DISEO DE CUADROS DE DIALOGO" ControlBox = 0 'False Height = 5535 Left = 2070 LinkTopic = "Form2" MaxButton = 0 'False MinButton = 0 'False ScaleHeight = 5130 ScaleWidth = 7425 Top = 1485 Width = 7545 Begin Frame Frame2 BackColor = &H00C0C0C0& Caption = "BOTON 3" Height = 2055 Left = 4920 TabIndex = 19 Top = 2160 Width = 2295 Begin TextBox Text5 Height = 285 Left = 120 TabIndex = 23

Top = 1560 Width = 2055 End Begin OptionButton Option4 BackColor = &H00C0C0C0& Caption = "DISABLED" Height = 255 Left = 360 TabIndex = 21 Top = 840 Width = 1335 End Begin OptionButton Option3 BackColor = &H00C0C0C0& Caption = "ENABLED" Height = 255 Left = 360 TabIndex = 20 Top = 360 Width = 1695 End Begin Label Label5 BackColor = &H00C0C0C0& Caption = "TITULO DEL BOTON " Height = 255 Left = 120 TabIndex = 22 Top = 1200 Width = 2055 End End Begin Frame Frame1 BackColor = &H00C0C0C0& Caption = "CAJA DE DIALOGO" Height = 1095 Left = 120 TabIndex = 16 Top = 960 Width = 2175 Begin OptionButton Option2 BackColor = &H00C0C0C0& Caption = "Modeless" Height = 255 Left = 480 TabIndex = 18 Top = 720 Width = 1215 End Begin OptionButton Option1 BackColor = &H00C0C0C0& Caption = "Modal"

Height = 255 Left = 480 TabIndex = 17 Top = 360 Width = 975 End End Begin TextBox Text4 Height = 405 Left = 3480 TabIndex = 15 Top = 120 Width = 3495 End Begin CommandButton Command2 Caption = "OK" Height = 495 Left = 3960 TabIndex = 5 Top = 4440 Width = 3255 End Begin CommandButton Command1 Caption = "CANCELAR " Height = 495 Left = 240 TabIndex = 4 Top = 4440 Width = 3255 End Begin TextBox Text1 Height = 975 Left = 2400 MultiLine = -1 'True TabIndex = 3 Top = 1080 Width = 4695 End Begin Frame Frame6 BackColor = &H00C0C0C0& Caption = "BOTON 2" Height = 2055 Left = 2520 TabIndex = 1 Top = 2160 Width = 2295 Begin TextBox Text3 Height = 285 Left = 120 TabIndex = 13 Top = 1560

Width = 2055 End Begin OptionButton Option14 BackColor = &H00C0C0C0& Caption = "DISABLED" Height = 255 Left = 240 TabIndex = 9 Top = 840 Width = 1815 End Begin OptionButton Option13 BackColor = &H00C0C0C0& Caption = "ENABLED" Height = 255 Left = 240 TabIndex = 8 Top = 360 Width = 1815 End Begin Label Label3 BackColor = &H00C0C0C0& Caption = "TITULO DEL BOTON" Height = 255 Left = 120 TabIndex = 11 Top = 1200 Width = 2055 End End Begin Frame Frame5 BackColor = &H00C0C0C0& Caption = "BOTON 1" Height = 2055 Left = 120 TabIndex = 0 Top = 2160 Width = 2295 Begin TextBox Text2 Height = 285 Left = 120 TabIndex = 12 Top = 1560 Width = 2055 End Begin OptionButton Option12 BackColor = &H00C0C0C0& Caption = "DISABLED" Height = 255 Left = 120 TabIndex = 7

Top = 840 Width = 1695 End Begin OptionButton Option11 BackColor = &H00C0C0C0& Caption = "ENABLED" Height = 255 Left = 120 TabIndex = 6 Top = 360 Width = 1935 End Begin Label Label2 BackColor = &H00C0C0C0& Caption = "TITULO DEL BOTON" Height = 255 Left = 120 TabIndex = 10 Top = 1200 Width = 1935 End End Begin Label Label4 BackColor = &H00C0C0C0& Caption = "TITULO DE LA CAJA DE DIALOGO" Height = 255 Left = 240 TabIndex = 14 Top = 240 Width = 3135 End Begin Label Label1 Alignment = 2 'Center BackColor = &H00C0C0C0& Caption = "TEXTO A MOSTRAR EN NUESTRA CAJA DE DIALOGO" Height = 255 Left = 2400 TabIndex = 2 Top = 720 Width = 4815 End End Sub Command1_Click () Unload Form2 End Sub Sub Command2_Click () Form3.Caption = Text4.Text Form3.Label1.Caption = Text1.Text If Text2.Text = "" Then

Form3.Command1.Visible = 0 Else Form3.Command1.Caption = Text2.Text End If If Text3.Text = "" Then Form3.Command2.Visible = 0 Else Form3.Command2.Caption = Text3.Text End If If Text5.Text = "" Then Form3.Command3.Visible = 0 Else Form3.Command3.Caption = Text5.Text End If If Option11.Value = -1 Then Form3.Command1.Enabled = -1 Else Form3.Command1.Enabled = 0 End If If Option13.Value = -1 Then Form3.Command2.Enabled = -1 Else Form3.Command2.Enabled = 0 End If If Option3.Value = -1 Then Form3.Command3.Enabled = -1 Else Form3.Command3.Enabled = 0 End If If Option1.Value = -1 Then Form3.Show 1 Else Form3.Show 0 End If End Sub Sub Form_Unload (Cancel As Integer) Label1.Caption = Texto$ End Sub Begin Form Form3 Caption = "Form3" Height = 4320 Left = 2415 LinkTopic = "Form3" ScaleHeight = 3915 ScaleWidth = 7545 Top = 3480 Width = 7665

Begin CommandButton Command4 Caption = "SALIR" Height = 615 Left = 240 TabIndex = 4 Top = 3120 Width = 7095 End Begin CommandButton Command3 Height = 615 Left = 5040 TabIndex = 3 Top = 2280 Width = 2295 End Begin CommandButton Command2 Height = 615 Left = 2640 TabIndex = 2 Top = 2280 Width = 2295 End Begin CommandButton Command1 Height = 615 Left = 240 TabIndex = 1 Top = 2280 Width = 2295 End Begin Label Label1 Alignment = 2 'Center Caption = "Label1" Height = 2055 Left = 120 TabIndex = 0 Top = 120 Width = 7215 WordWrap = -1 'True End End Sub Command4_Click () Unload Form3 End Sub

CAPTULO 11 GRFICOS 11.1.- INTRODUCCIN

Como sabemos, Windows ofrece al usuario final toda una serie de ventajas relacionadas con su interface grfico. Por tanto, parece lgico que debamos aprovecharnos de las facilidades grficas que el sistema nos ofrece, para enriquecer visualmente nuestros desarrollos. Visual Basic dispone de toda una serie de controles, funciones y propiedades que nos permitirn utilizar una amplia serie de primitivas grficas con relativa facilidad y sin gran sobrecarga para el sistema. El captulo, viene acompaado de un programa, denominado GRAFICO.MAK, que nos servir de ayuda para la comprensin de los conceptos tericos explicados. Este programa est dividido en mdulos. Cada mdulo se corresponde con algn concepto expuesto en los apartados del captulo. Al final del captulo se presenta el cdigo del programa completo.

11.2.- DIBUJAR EN VISUAL BASIC., GENERALIDADES

11.2.1.- COORDENADAS

Podemos definir un sistema de coordenadas como un sistema bidimensional, en el que cualquier punto queda definido por un par de nmeros (x,y). Gracias a esto, podemos situar cualquier objeto en la pantalla, en un Form o en un contenedor de objetos. El valor x corresponde a la localizacin de un punto a lo largo del eje horizontal o eje X, cuyo punto inicial (0) est situado en el extremo izquierdo de dicho eje. El valor y corresponde a la localizacin de un punto a lo largo del eje vertical o eje Y, cuyo punto inicial (0) est situado en el extremo superior de dicho eje. Cuando movemos o cambiamos el tamao de cualquier objeto, el sistema de coordenadas que manejamos corresponder al del contenedor de dicho objeto si este existe. En caso contrario corresponder al de la Form que lo contiene.

11.2.2.- ESCALAS

Podemos definir el trmino escala como la unidad de medida basada en las divisiones de los ejesXeY. Visual Basic ofrece la posibilidad de definir diferentes escalas para cada eje. Gracias al concepto de escala es posible cambiar el sistema de coordenadas para un objeto en particular o para todo el sistema. Cada Form y cada Caja de Dibujo (Picture Box) tiene varias propiedades relacionadas con la definicin y empleo de escalas (ScaleLeft, ScaleTop, ScaleWidth, ScaleHeigh y ScaleMode) y un slo mtodo (Scale). La escala por defecto en Visual Basic sita el origen de coordenadas en la esquina superior izquierda. La medida patrn de dicha escala son los Twips. Por definicin un Twip es 1/1440 de pulgada. Visual Basic permite el uso de una serie de escalas predefinidas o el empleo de escalas definidas por el usuario.

11.2.2.1.- Escalas Predefinidas Gracias a la asignacin de diferentes valores a la propiedad ScaleMode es posible utilizar las 8 escalas predefinidas en Visual Basic. La siguiente tabla (Tabla 11.1) muestra dichos valores:

ScaleMode Descripcin 0 Escala definida por el usuario mediante el uso de diferentes propiedades: ScaleLeft, ScaleTop, ScaleWidth, ScaleHeigh. 1 La medida patrn es el Twip 2 La medida patrn es el Punto 3 La medida patrn es el pixel (medida de resolucin del monitor) 4 La medida patrn es el Carcter 5 La medida patrn es la Pulgada 6 La medida patrn es el Milmetro 7 La medida patrn es el Centmetro

Tabla 11.1. Escalas predefinidas en Visual Basic.

11.2.2.1.-Escalas definidas por el usuario

Si las necesidades de nuestro desarrollo as lo aconsejan, el programador puede definir su propia escala para cualquier objeto del sistema y por tanto cambiar su sistema de coordenadas. La implementacin de las escalas definidas por el usuario se realiza con la asignacin de valores a las siguientes propiedades: ScaleLeft: define el origen del eje X. ScaleTop: define el origen del eje Y. ScaleWidth: define la anchura. ScaleHeight: define la altura. A modo de ejemplo, seguidamente asignamos una serie de valores a las propiedades de una Form: ScaleLeft =500 ScaleTop = 500 ScaleWidth = 2500 ScaleHeight = 2500 Con las dos primeras asignaciones anteriores, hemos cambiado el sistema de coordenadas de nuestra Form. As el origen de la esquina superior izquierda ahora lo hemos situado en el punto (500,500) frente a su localizacin por defecto (0,0). Con las otras dos asignaciones hemos determinado su anchura y altura. As pues, cualquier posicionamiento de un objeto dentro de nuestra Formestar situado en un rea definida por el nuevo sistema de coordenadas que previamente hemos diseado. Las esquinas superior izquierda e inferior derecha de dicho rea son (500,500) y (3000,3000) respectivamente. Es posible la asignacin de valores negativos a las anteriores propiedades para lograr la definicin de un nuevo sistema de coordenadas que sea conveniente para nuestros propsitos. Gracias al mtodo Scale podemos redefinir tambin el sistema de coordenadas de cualquier objeto. Su sintaxis es : Objeto.Scale (x1,y1)-(x2,y2) Los valores x1,y1,x2,y2 tienen una correspondencia biunvoca con las propiedades ScaleLeft, ScaleTop, ScaleWidth, ScaleHeigh: x1 = ScaleLeft y1 = ScaleTop x2-x1 = ScaleWidth y2-y1 = ScaleHeight

11.2.3.- EL COLOR: TRATAMIENTO Y ASIGNACIN

Visual Basic incluye dos funciones que nos permitirn escoger tonalidades de color para posteriormente asignarlas, a travs de las propiedades, a los diferentes objetos del sistema. Cada color es representado internamente por Visual Basic como un entero largo, en el que se encuentra codificada informacin relativa al porcentaje de los tres colores primarios que contiene el color referenciado. Visual Basic ofrece una facilidad adicional para asignar colores a los diversos Objetos y Forms: la paleta de colores (Color Palette). Esta paleta es accesible a travs de la opcin Color Palette del men Windows. Con esta facilidad podemos asignar colores visualmente a nuestros diseos. La figura siguiente (Fig. 11.1) muestra la ventana de la Paleta de Colores.

Fig. 11.1. Paleta de colores en Visual Basic.

El usuario tambin puede asignar colores utilizando las constantes que se encuentran definidas en el fichero CONSTANT.TXT que acompaa a Visual Basic. Global Const BLACK = &H0& Global Const RED = &HFF& Global Const GREEN = &HFF00& Global Const YELLOW = &HFFFF& Global Const BLUE = &HFF0000 Global Const MAGENTA = &HFF00FF Global Const CYAN = &HFFFF00 Global Const WHITE = &HFFFFFF

11.2.3.1.- Funcin RGB Una de las funciones ms utilizadas en el tratamiento del color es la funcin RGB. La sintaxis de esta funcin es: Color& = RGB( Rojo%, Verde%, Azul%) Los argumentos de esta funcin son nmeros enteros comprendidos entre 0 y 255, y especifican la cantidad que aportar cada uno de los colores primarios (rojo, verde y azul) al color que estamos eligiendo. Ejemplo

Supongamos que queremos disear una aplicacin que muestre la mezcla aditiva de colores primarios. Para ello vamos a utilizar las barras de desplazamiento con el fin de ir asignando distintos grados de color. El resultado se mostrar en el interior de un crculo (ver Fig. 11.2).

Fig. 11.2. Programa GRAFICO.MAK. Empleo de la funcin RGB.

Cada una de estas barras representan el contenido de cada uno de los tres colores primarios en un rango que va de 0 a 255, segn el porcentaje de color. En el siguiente cdigo podemos observar como lograr que cuando el usuario desplaza una barra de desplazamiento, el color del interior del crculo cambie. Sub HScroll1_Change () Shape1.FillColor = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value) Form2.Caption = "COLOR:RGB( " + Str$(HScroll1.Value) + " , " + Str$ (HScroll2.Value) + " , " + Str$(HScroll3.Value) + " )" End Sub Sub HScroll1_Scroll () HScroll1_Change End Sub

Hemos elegido la propiedad FillColor del control Shape para que nos vaya mostrando el color elegido.

11.2.3.2.- Funcin QBColor Visual Basic incluye la funcin QBColor como deferencia a los miles de programadores que han utilizado el archiconocido Quick Basic, y que estaban acostumbrados a utilizar los cdigos de los 16 colores disponibles en este entorno. La sintaxis de esta funcin es: Color& = QBColor ( ColorQB% )

El argumento es un entero cuyo rango va de 0 a 15, correspondiente a los cdigos de color de Quick Basic,(Microsoft Basic Professional Development System). El valor devuelto por esta funcin es un entero largo que corresponde al cdigo del color especificado por el argumento.

11.2.3.3.- Propiedad: BackColor Esta propiedad contiene el cdigo de color de fondo de una Form o Control determinado. Su sintaxis es: [Form] [Control].BackColor = [CodigoColor&] Como ya sabemos gracias a esta propiedad podemos asignar u obtener el color de fondo de cualquier Control o Form en tiempo de ejecucin. Si asignamos un valor a esta propiedad en tiempo de ejecucin, para una form o para una caja de dibujo, todos los grficos o salida de texto que incluyan los objetos anteriores sern borrados.

11.2.3.4.- Propiedad ForeColor Esta propiedad contiene el cdigo de color del primer plano de una Form o Control. Este color es el utilizado para dibujar el texto. Su sintaxis es: [Form] [Control].ForeColor = [CodigoColor&]

11.2.3.5.- Propiedad BorderColor Mediante esta propiedad definimos el cdigo de color del borde de un control Shape. Su sintaxis es: [Control].BorderColor = [CodigoColor&]

11.2.3.6.- Propiedad FillColor. Esta propiedad contiene el cdigo de color que servir para rellenar el interior de crculos y elipses creados con el mtodo Circle y paralelogramos creados con el mtodo Line. Su sintaxis es: [Control].FillColor = [CodigoColor&]

11.2.3.7.- Paleta de Colores. Windows utiliza las paletas de colores para guardar los cdigos de los diversos colores que son utilizados por las aplicaciones. La paleta de colores que Windows usa para soportar las demandas de colores de las aplicaciones se denomina Paleta del Sistema y puede contener hasta 256 colores.

Cuando un programa utiliza una paleta de 16 colores, est utilizando 16 colores puros y en el caso de que necesite representar ms colores utilizar la tcnica del Dithering. Dithering es la tcnica utilizada para simular colores que no estn disponibles para un determinado adaptador grfico. La simulacin de colores se consigue empleado combinacin de patrones de colores puros. Un ejemplo de Dithering, son los cientos de colores obtenidos en cualquier programa de dibujo con el empleo de un adaptador grfico de solo 16 colores. La Paleta del Sistema puede contener hasta 256 colores, pero 20 de ellos son llamados colores estticos y no pueden ser cambiados por ninguna aplicacin. Por lo tanto cada aplicacin puede definir 236 colores adicionales. Cada bitmap que se muestra en el sistema tiene definida su paleta lgica y Windows utiliza los colores definidos en esta paleta para rellenar la paleta del sistema. Cuando utilizamos paletas mltiples en una misma aplicacin podemos sobrecargar el sistema y no obtener los resultados deseados. Imaginemos que en nuestra aplicacin mostramos un determinado bitmap con su paleta lgica asociada y a la vez utilizamos una caja de dibujo con una paleta diferente. Como la paleta del sistema slo tiene capacidad para 256 colores (236 colores a disposicin de las aplicaciones), Windows tendr que escoger que paleta lgica va a utilizar.

11.2.4.- CONTROLES GRFICOS VERSUS MTODOS GRFICOS

Aunque posteriormente trataremos en profundidad cada una de las dos formas de diseo e implementacin de grficos que Visual Basic ofrece al programador, vamos a realizar una pequea disquisicin sobres los pros y contras del empleo de los controles grficos y de los mtodos grficos. Cualquier tipo de control en Visual Basic nace con la filosofa de sencillez de uso y para facilitar la existencia al programador. Pero todos los avances en sencillez en el mundo de la informtica van acompaados de restricciones en su uso. La primera ventaja indudable de los controles es que el programador puede ver los resultados de su empleo en tiempo de diseo, frente a la necesidad de ejecucin de los mtodos grficos para comprobar su correcto funcionamiento. Sin embargo, los mtodos grficos nos permiten obtener resultados que resultaran imposibles con el uso de controles. As podemos manejar desde un simple pixel hasta dibujar un arco, etc. Imaginemos por un momento que tenemos que dibujar una tabla de valores, que tiene que ser susceptible de ser desplazada por el usuario. En la fase de diseo debemos decidir si emplear el mtodo Line o el control Shape. Si utilizamos este ltimo caeremos en un exceso de complejidad que poda haber sido resuelto con mucha mas facilidad con el uso del mtodo Line. La limitaciones ms importantes de los controles grficos son: - no pueden recibir el foco en tiempo de ejecucin.

- no pueden servir como contenedor de cualquier otro control. Hay que mencionar que Visual Basic durante el proceso de visualizacin mantiene 3 capas diferentes y superpuestas. As, en una primera capa que ser la ms cercana al espectador se mostrarn los controles no grficos: botones de comando, cuadros de lista, casillas de verificacin, controles de fichero, etc. En la segunda capa se mostrarn los controles grficos y etiquetas de texto. En la tercera capa se mostrar la salida correspondiente a los mtodos grficos. Gracias a esta estratificacin tenemos que tener en cuenta que las capas se superpondrn unas a otras, y los objetos que estn en una capa de orden superior cubrirn a los que se encuentren en otra capa inferior. Los mtodos grficos estn especialmente indicados como elementos grficos de fondo, que sern ocultados por cualquier objeto de las dos capas superiores. La figura 11.3 ilustra el hecho anterior.

Fig. 11.3. Superposicin de capas en Visual Basic.

11.3.- MTODOS GRFICOS

Todos los mtodos grficos que vamos a comentar se aplican a todo tipo de forms y cajas de dibujo.

11.3.1.- CLS

Este primer mtodo es sin lugar a dudas el ms conocido y cuyo cometido resulta difcil que pase desapercibido. Heredado del antiguo Basic, el mtodo Cls limpia el objeto referenciado (forms o cajas de dibujo)de cualquier salida grfica o de texto. As; Form1.Cls borrar la salida grfica de la form1. Picture1.Cls borrar la salida grfica de Picture1 y si aparece tan solo Cls entonces borrar la salida grfica de la form actual. Los Bitmaps de fondo que han sido asignados por la propiedad Picture y los controles que han sido incluidos en tiempo de diseo no se vern afectados por el mtodo Cls.

11.3.2.- LINE

El mtodo grfico Line nos permite dibujar lneas y rectngulos. Su sintaxis es la siguiente: [Objeto].Line [[Step] (x1,y1)] - [Step] (x2,y2)[,[color][,B[F]]] Pero veamos con ms detalle la sintaxis anterior que aunque parece complicada no lo es tanto y sin embargo ofrece amplias posibilidades. El objeto al que califica el mtodo Line puede ser incluido o no dentro de la sentencia. En este ltimo caso la lnea o rectngulo ser dibujada en la form actual. Si queremos tan solo dibujar una lnea entre dos puntos ((100,100) y (200,200)) podemos optar por las construcciones siguientes: A.- Line (100,100) - (200,200) Dibuja una lnea ente los puntos especificados, el color de dicha lnea ser el especificado por la propiedad ForeColor.Hay que mencionar que las propiedades de escala del objeto referenciado marcaran la unidad de medida. B.- Line (100,100) - (200,200), RGB(0,0,0) Dibuja la misma lnea pero en color negro ( RGB(0,0,0)) C.- Line (200,200), RGB(0,0,0) Dibuja la lnea negra entre el punto indicado por las propiedades CurrentX y CurrentY del objeto referenciado y el punto (200,200). D.- Line Step (100,100) - (200,200), RGB(0,0,0) Dibuja la lnea negra, especificando que el primer punto es relativo a la posicin grfica en curso, que est determinada a su vez por las propiedades CurrentX y CurrentY. Si estas ltimas tienen como valores 50 y 50 el mtodo anterior ser igual a Line (150,150) - (200,200), RGB(0,0,0) E.- Line (100,100) - Step(200,200),RGB(0,0,0) Dibuja la lnea de color negro, especificando que el segundo punto es relativo al primero. El mtodo anterior ser igual a Line (100,100) - (300,300),RGB(0,0,0).

Como hemos visto, las posibilidades del mtodo Line para crear lneas son muy variadas y hay que destacar la funcionalidad de la palabra clave Step que califica al punto que le sigue como relativo a la posicin grfica o al anterior. Vamos a ver todas las posibilidades que nos ofrece este mtodo para crear rectngulos.

Podemos dibujar rectngulos con la utilizacin de cuatro mtodos Line seguidos. As para dibujar un rectngulo de 400 unidades de ancho y 200 de largo, podramos emplear: Line (100,100) - ( 500,100 ) Line (500,100) - ( 500,300 ) Line (500,300) - ( 100,300 ) Line (100,300) - ( 100,100 )

O bien podemos utilizar una opcin suplementaria del mtodo Line. Para realizar el mismo rectngulo anterior utilizaremos la siguiente construccin: Line (100,100) - ( 500,300 ), , B Como podrs observar la opcin suplementaria B hace que el mtodo Line tome dos puntos que corresponden a una diagonal del rectngulo y lo dibuja. Existe una segunda opcin, F, que siempre acompaa a la anteriormente descrita, y que tiene como funcin el rellenar el rectngulo con el color especificado por la propiedad FillColor. As el siguiente ejemplo representara el rectngulo anterior que ser rellenado con el color especificado por ForeColor. Line (100,100) - ( 500,300 ), , BF

Hay que mencionar que podemos controlar el color y la forma de relleno de cualquier rectngulo asignando los valores a las propiedades FillStyle y FillColor. La siguiente tabla (Tabla 11.2) muestra los diferentes valores de la propiedad FillStyle: Valor: Descripcin: 0 Rellena el rectngulo con el color especificado en FillColor. 1 Transparente. Valor por defecto. 2 Lneas Horizontales. 3 Lneas Verticales. 4 Lneas Diagonales hacia arriba.. 5 Lneas Diagonales hacia abajo. 6 Cuadriculado. 7 Cuadriculado en diagonal.

Tabla 11.2. Valores de FillStyle.

11.3.3.- CIRCLE

Mediante el uso del mtodo Circle es posible dibujar toda una serie de formas circulares, elpticas, arcos y sectores circulares.

La sintaxis general del mtodo Circle es: [Object.] Circle [Step] ( x , y ),Radio[,[Color] [,[Principio] [,[Fin] [, aspecto ]]]] Si nuestra meta es dibujar un crculo en un punto, determinado por el par (x,y) y de un dimetro y de color determinado, tan solo debemos emplear la siguiente sintaxis del mtodo Circle. Circle ( 750, 750 ), 500, RGB (0,0,0 ) El mtodo anterior mostrar un crculo de radio 500, cuyo centro se encuentra en el punto (750,750 ) y con el color negro especificado por la funcin RGB(0,0,0). Pero como ya indicamos anteriormente, el mtodo Circle nos permite dibujar tambin elipses, arcos y sectores circulares. Para dibujar una elipse (recordemos que un crculo es una elipse de excentricidad 0) emplearemos la sintaxis casi completa del mtodo. As definiremos el centro de dicha elipse mediante un par de puntos, y su radio y color como en el ejemplo anterior. El argumento Aspecto es un nmero entero o fraccional que nos permite especificar la relacin entre el eje vertical y el eje horizontal de la elipse. As cuando el argumento Aspecto = 1 los ejes vertical y horizontal son iguales y por tanto estamos dibujando un crculo, cuando Aspecto >1 el eje vertical es mayor que el horizontal y cuando Aspecto<1 el eje horizontal es mayor que el vertical. Si queremos representar arcos o sectores circulares debemos emplear toda la sintaxis del mtodo Circle. As manipulando los argumentos Principio y Fin podemos especificar el arco o sector a dibujar. Como ya sabrs Visual Basic utiliza el radian para medir ngulos (recuerda que 360 grados son 2 radianes). Para medir los ngulos deberemos seguir las siguientes reglas: - los arcos crecen en sentido contrario a las agujas del reloj - todas las medidas de los ngulos sern dadas en radianes. As el siguiente ejemplo dibujar un arco de 90 o /2 radianes y de 1000 unidades de radio, que va desde los 180 o radianes a los 270 o 2/3 radianes: Circle (500,500),1000 , , Pi , 2Pi/3 Si queremos dibujar el sector circular correspondiente tan solo habr que poner en negativo los valores de los argumentos Principio y Fin. Visual Basic conectar el centro del crculo con los puntos finales del arco especificado, por tanto, dibujar el sector circular correspondiente. El siguiente ejemplo muestra lo dicho anteriormente: Circle (500,500),1000 , , - , -2/3 Hay que recordar que para proceder a pintar el interior de cualquier crculo, elipse o sector circular tan solo hay que asignar los valores correspondientes a las propiedades FillStyle y FillColor.

11.3.4.- PUNTOS

Vamos a tratar en este apartado los mtodos PSet y Point que tan solo colorean y obtienen el color de pixeles individuales. La sintaxis de PSet es: [Object.] PSet ( x , y ) [,Color] El mtodo PSet pintar del color determinado por el argumento Color, el pixel referenciado por el par de puntos (x,y). Si en esta funcin no se incluye valor para el argumento Color, PSet utilizar el color definido en la propiedad ForeColor. El mtodo Point complementa al mtodo PSet, pues obtiene el cdigo del color del pixel referenciado por el par (x, y) y su sintaxis es la siguiente: [Object,] Point ( x,y) El siguiente ejemplo pinta un determinado pixel (500 ,500) de color negro, posteriormente lo borra (ponindolo del color de fondo) y por ltimo obtiene el cdigo de color del pixel adyacente. PSet ( 500 , 500 ) , RGB (0,0,0) PSet ( 500 , 500 ) , BackColor CodigoColor = Point ( 501 , 501 )

11.4.- CONTROLES GRFICOS

Como ya vimos anteriormente los controles grficos ofrecen una serie de ventajas y desventajas frente a los mtodos grficos descritos en el captulo anterior. Podemos observar dichos controles en la caja de herramientas de Visual Basic. En la Fig. 11.4 se muestran dichos controles.

Fig. 11.4. Controles grficos en Visual Basic 2.0.

11.4.1.- IMAGE CONTROL Y PICTURE BOX CONTROL

El control Image nos permite mostrar en nuestros desarrollos ficheros grficos cuyos formatos sean:

- Bitmaps : es el formato con extensiones .BMP o .DIB. - Icon : es el formato propio de los iconos que podemos ver en cualquier aplicacin, cada icono tiene un mximo de 32*32 pixels. la extensin de formato es .ICO . - Metafile : es el formato con extensin .WMF.

este

Llegados a este punto hay que mencionar la existencia de un "hermano mayor" del control Image, como ya habrs adivinado se trata del control Picture Box. Este control ya fue incorporado en la versin 1.0 de Visual Basic. Picture Box posee otras capacidades no grficas como es su capacidad de contenedor de otros objetos y de texto. Puede mostrar los mismos ficheros grficos que el control Image, pero slo mostrar la parte de dicha imagen que quepa en el rea definida por este control (el control Image puede estrechar la imagen para poder mostrar la en su integridad, gracias a su propiedad Stretch). Este control puede mantener conversaciones va DDE con cualquier otro control, y es el nico control que podemos situar en el rea del cliente de una ventana MDI. El control Image usa menos recursos y realiza el repintado de su superficie ms rpidamente que el control Picture Box, aunque soporta un subconjunto reducido de propiedades, mtodos y eventos. La tabla 11.3, muestra una comparacin entre los controles Picture Box y Image.

CONTROL IMAGE PICTURE BOX

PROPIEDADES EVENTOS MTODOS 16 50 7 19 18

Tabla 11.4. Tabla comparativa de los controles Image y Picture Box.

Con la manipulacin de propiedades y eventos de estos controles podemos conseguir efectos muy interesantes para nuestros diseos.

11.4.2.- CONTROL LINE

Este control es el encargado de mostrar lneas verticales, horizontales y diagonales. Como observars duplica la funcin del mtodo Line, pero ofrece una facilidad adicional que es la posibilidad de "dibujar" y ver las lneas en tiempo de diseo. Sin esta facilidad adicional, no habra razones objetivas para duplicar el mtodo Line y el control del mismo nombre. Las lneas que dibujamos con el control Line permanecern tras el repintado de la ventana incluso si la propiedad AutoRedraw esta deshabilitada. Tampoco es posible utilizar el mtodo Move para producir el efecto de movimiento de una lnea dibujada con el control Line, pero podemos variar sus propiedades X1, X2, Y1, Y2 para conseguir ese mismo efecto.

Mediante la manipulacin de las propiedades BorderStyle, BorderColor, BorderWidth podemos controlar de una forma total la apariencia de las lneas.

11.4.3.- CONTROL SHAPE

El propsito de este control es el permitirnos dibujar rectngulos, cuadrados, crculos y elipses en nuestras aplicaciones durante el tiempo de diseo. Este control como los mencionados anteriormente, puede ser utilizado en otro control que acte como contenedor, pero el control Shape no puede actuar como contenedor de otros controles. Mediante la manipulacin de las propiedades BorderStyle, BorderColor, BorderWidth, FillColor, FillStyle, podemos controlar de una forma total la apariencia y color de todas las diferentes formas que pueden ser realizadas con este control. La propiedad Shape nos permite escoger la forma de la figura que deseemos realizar entre las siguientes opciones: 0. - Rectngulo. 1. - Cuadrado. 2. - Elipse. 3. - Circulo. 4. - Rectngulo con esquinas redondeadas. 5. - Cuadrado con esquinas redondeadas.

11.4.4.- EFECTOS ESPECIALES EN EL USO DE CONTROLES

Vamos a describir toda una serie de tcnicas y trucos que nos permitirn incluir efectos grficos en nuestras aplicaciones. 11.4.4.1.- Cambio de propiedades en tiempo de ejecucin Como ya vimos anteriormente, podemos manipular y cambiar en tiempo de ejecucin las propiedades de nuestros controles grficos. Esta posibilidad nos permitir incluir efectos grficos atrayentes en nuestros diseos. Ejemplo Supongamos que nos piden una aplicacin que visualice en una ventana diferentes figuras. Se desea adems modificar en tiempo de ejecucin propiedades de esas figuras tales como el grosor de lnea, el color de fondo e incluso modificar tambin el tipo de figura. La Fig. 11.5 muestra un posible interface para esta aplicacin.

Fig. 11.5. Programa GRAFICO.MAK. Cambio de propiedades en tiempo de ejecucin.

El cdigo de programa que viene a continuacin, realiza la tarea pedida. Aunque aqu se presente de forma aislada, forma parte de una de la rutinas de la aplicacin GRAFICO.MAK. ' Permite la salida del programa cuando se pulsa el botn de comando. Sub Command1_Click () End End Sub

' La primera barra de desplazamiento genera el cambio del control Shape. Sub HScroll1_Change () Shape1.Shape = HScroll1.Value End Sub

' La segunda barra de desplazamiento cambia el color de fondo de la figura. Sub HScroll2_Change () Shape1.BackColor = QBColor(HScroll2.Value) End Sub ' La tercer barra de desplazamiento cambia la anchura del borde de la figura, esto es, el grosor de la lnea. Sub HScroll3_Change () Shape1.BorderWidth = HScroll3.Value

End Sub

Como podrs observar, esta sencilla rutina tan solo modifica los valores de las propiedades Shape, BackColor y BorderWidth. El nico misterio de este programa consiste en darse cuenta que el cambio de las barras de desplazamiento (propiedad Value) puede provocar un cambio en los valores de otras propiedades si as se indica. La salida de la aplicacin es muy vistosa y el cdigo necesario para realizarla es, como has visto, muy sencillo. Podrs comprobar esta rutina dentro del programa ejemplo GRAFICO.MAK.

11.4.4.2.- Movimiento Otra de las rutinas que incorpora la aplicacin GRAFICO.MAK provoca el movimiento de una pelota dentro de la ventana de la aplicacin (Fig. 11.6). Con este ejemplo, podemos explicar claramente, las tcnicas de movimiento de elementos grficos en nuestras aplicaciones.

Fig. 11.6. Programa GRAFICO.MAK. Rutina de movimiento.

En esta rutina empleamos un control Timer, que ser el encargado de generar la llamada a la subrutina cada 30 milisegundos. Sub Timer1_Timer () Movimiento End Sub La subrutina Form_Load es la encargada de calcular las coordenadas de las esquinas superior izquierda (l%, t%) e inferior derecha (r%, b%) del botn de comando, as como inicializar la variable interruptor que actuar como variable semforo.

Sub Form_Load () interruptor = 1 Command1.Caption = "Comenzar" l% = Command1.Left r% = Command1.Left + Command1.Width T% = Command1.Top B% = Command1.Top + Command1.Height End Sub El cdigo que sigue es el encargado de manejar el estado del botn de comando y de habilitar/deshabilitar el Timer. Sub Command1_Click () If interruptor = 1 Then interruptor = 0 Command1.Caption = "Terminar" timer1.Enabled = -1 Else timer1.Enabled = 0 End End If End Sub Pero es sin lugar a dudas el cdigo siguiente, el corazn de esta rutina. Para conseguir el control del movimiento utilzamos una estructura de control Select Case. Hay que aclarar que el objeto grfico en movimiento rebotar cambiando de direccin cuando intersecciona con cualquiera de los cuatro lados de la Form as como cuando alcanza los lados superior e inferior del botn de comando. La implementacin del cdigo necesario para que rebote en los laterales del botn de comando se deja como ejercicio al alumno. Esta estructura de control nos ofrece 4 posibilidades de movimientos: - Case 1: Gestiona el movimiento hacia la derecha y hacia arriba. La estructuras If - Then que le siguen gestionan respectivamente la interseccin del objeto grfico con los lados derecho y superior de la ventana, as como el lado inferior del botn de control. Recordemos que el botn de control se encuentra en un plano de representacin superior al del propio objeto grfico, lo que indica que si nosotros no incluimos cdigo para gestionar el rebote al contacto con sus lados, el objeto grfico "pasar" por debajo. - Case 2: Gestiona el movimiento hacia la derecha y hacia abajo. Las estructuras If - Then que le siguen gestionan respectivamente la interseccin del objeto grfico con los lados derecho e inferior de la ventana, as como el lado superior del botn de control. - Case 3: Gestiona el movimiento hacia la izquierda y hacia arriba. Las estructuras If - Then que le siguen gestionan respectivamente la interseccin del objeto grfico con los lados izquierdo y superior de la ventana. as como el lado inferior del botn de control.

- Case 4: Gestiona el movimiento hacia la izquierda y hacia abajo. Las estructuras If - Then que le siguen gestionan respectivamente la interseccin del objeto grfico con los lados izquierdo e inferior de la ventana. as como el lado superior del botn de control. Sub Movimiento () Select Case direccin Case 1 Shape1.Move Shape1.Left + 80, Shape1.Top - 80 If Form2.Width - Shape1.Left - 120 <= Shape1.Width Then direccion = 3 If Shape1.Top <= 0 Then direccion = 2 If Shape1.Top <= B% And Shape1.Top >= T% And Shape1.Left > l% And Shape1.Left < r% Then direccion = 2 Case 2 Shape1.Move Shape1.Left + 80, Shape1.Top + 80 If Form2.Width - Shape1.Left - 120 <= Shape1.Width Then direccion = 4 If Shape1.Top + Shape1.Height + 400 >= Form2.Height Then direccion = 1 If Shape1.Top + Shape1.Height >= T% And Shape1.Top + Shape1.Height <= B% And Shape1.Left >= l% And Shape1.Left <= r% Then direccion = 1 Case 3 Shape1.Move Shape1.Left - 80, Shape1.Top - 80 If Shape1.Left <= 0 Then direccion = 1 If Shape1.Top <= 0 Then direccion = 4 If Shape1.Top <= B% And Shape1.Top >= T% And Shape1.Left > l% And Shape1.Left < r% Then direccion = 4 Case 4 Shape1.Move Shape1.Left - 80, Shape1.Top + 80 If Shape1.Left <= 0 Then direccion = 2 If Shape1.Top + Shape1.Height + 400 >= Form2.Height Then direccion = 3 If Shape1.Top + Shape1.Height >= T% And Shape1.Top + Shape1.Height <= B% And Shape1.Left > l% And Shape1.Left < r% Then direccion = 3 Case Else direccion = 1 End Select End Sub

11.4.4.3.- Animacin Podemos incluir pequeas animaciones con la ayuda de un sencillo cdigo. En nuestro ejemplo vamos a intentar representar una pequea animacin de la imagen que aparece en la figura 11.7. Como vemos, nuestro ejemplo parece un vdeo que nos ofrece posibilidades de edicin continua de la animacin o paso a paso hacia delante o hacia atrs.

La materia prima de cualquier animacin son las imgenes que forman una secuencia y que al ser representadas secuencialmente dan impresin de movimiento. En nuestro ejemplo hemos empleado 7 imgenes que han sido cargadas en tiempo de diseo a un array de controles Image. Hemos incluido un control Timer que ser el encargado de manejar la animacin continua. Sub Timer1_Timer () Static y% Image2.Picture = Image1(y%).Picture If y% = 6 Then y% = 0 y% = y% + 1 End Sub El cdigo correspondiente a cada uno de los cuatro botones de comando que aparecen en la ventana se muestra a continuacin.

Fig. 11.7. Programa GRAFICO.MAK. Rutina de animacin.

El botn de comando Command1 es el que nos permite ver la animacin paso a paso tras sucesivas pulsaciones de este botn de comando. Sub Command1_Click () If x% = -1 Then x% = 6 x% = x% + 1 If x% > 6 Then x% = 0 Image2.Picture = Image1(x%).Picture End Sub El botn de comando Command2 es el que nos permite ver la animacin paso a paso pero en direccin contraria a como lo haca el botn 1. Sub Command2_Click () x% = x% - 1 If x% = -1 Then x% = 6

Image2.Picture = Image1(x%).Picture End Sub

El botn de comando Command3 nos permite ver la animacin de forma continua. Deshabilita a los botones anteriores y a el mismo para que el usuario slo pueda pulsar el botn 4 que es el encargado de parar y habilitar de nuevo todos los botones. Utiliza una llamada al control Timer para que ste, a su vez muestre las imgenes cada un determinado lapso de tiempo.

Sub Command3_Click () Timer1.Enabled = -1 Command1.Enabled = 0 Command2.Enabled = 0 Command3.Enabled = 0 End Sub Sub Command4_Click () Timer1.Enabled = 0 Image2.Picture = Image1(6).Picture Command1.Enabled = -1 Command2.Enabled = -1 Command3.Enabled = -1 End Sub

11.4.4.4.- Apariencia tridimensional Casi todos los nuevos entornos operativos a excepcin de Windows ofrecen una apariencia tridimensional en sus controles, aunque parece ser que la versin 4.0 de Windows ofrecer ya este nuevo Look 3D. Actualmente si queremos que nuestros programas tengan esta apariencia tridimensional podemos escoger dos mtodos diferentes: A.- Comprar un 3D Widgets que es Custom Control que incluye los controles standard de Visual Basic pero con caractersticas mejoradas y apariencia 3D. B. - Aplicar la rutina Hacer3dForm a todos los controles de nuestros desarrollos. El cdigo siguiente corresponde a la rutina Hacer3dForm que provoca una salida como la que aparece en la Fig. 11.8. Tiene 2 argumentos que son la form y el control de dicha form a la que queremos aadir la apariencia tridimensional. Esta rutina calcula las esquina superior izquierda e inferior derecha del control pasado como argumento y dibuja una serie de rectngulos que son los que darn la apariencia tridimensional. Sub Hacer3dForm (UnaForm As Form, unControl As Control) L% = unControl.Left R% = unControl.Left + unControl.Width T% = unControl.Top

B% = unControl.Top + unControl.Height UnaForm.Line (L% - Bisel%, T% - Bisel%)-(R% + Bisel%, T%), QBColor(15), BF UnaForm.Line (L% - Bisel%, T%)-(L%, B%), QBColor(15), BF UnaForm.Line (L% - Bisel%, B%)-(R% + Bisel%, B% + Bisel%), QBColor(8), BF UnaForm.Line (R%, B%)-(R% + Bisel%, T%), QBColor(8), BF UnaForm.Line (L%-Bisel%, T% -Bisel%)-(R% + Bisel%, B%+ Bisel%), QBColor(0), B End Sub

La rutina Command1_Click tan solo pone el valor de la variable Bisel que es la que marca la cantidad de efecto tridimensional y va pasando a la rutina Hacer3dForm todos los controles contenidos en la Form4. Sub Command1_Click () Bisel% = 32 Hacer3dForm Form4, Command1 Hacer3dForm Form4, Dir1 Hacer3dForm Form4, File1 Hacer3dForm Form4, HScroll1 Hacer3dForm Form4, VScroll1 Hacer3dForm Form4, Text1 Hacer3dForm Form4, List1 Hacer3dForm Form4, Frame1 End Sub

La siguiente figura muestra grficamente la apariencia tridimensional que se puede lograr empleando las rutinas anteriores.

Fig. 11.8. Programa GRAFICO.MAK. Aspecto tridimensional de una ventana.

11.5.- PROPIEDADES AVANZADAS

En este apartado vamos a a discutir el uso e implementacin de dos propiedades que por su especial uso merecen un estudio ms detenido.

11.5.1- AUTOREDRAW

Cada Form o caja de dibujo incluyen la propiedad AutoRedraw que puede ser habilitada/deshabilitada tanto en tiempo de diseo como en tiempo de ejecucin. Esta propiedad tiene tan solo dos valores, verdadero o falso. Como ya sabes Windows ofrece al usuario la filosofa Desktop, con lo que puede tener tantas ventanas abiertas como la memoria lo permita. La ventana en uso esta situada encima de otras, y la podemos mover y redimensionar a voluntad. Cuando el rea de una ventana se ve solapada por otra, Windows enva un mensaje a dicha ventana para indicarle que rea ha sido ocultada por la otra ventana. Es responsabilidad del cdigo del programa propietario de esa ventana regenerar su contenido cuando la ventana que se superpuso desaparezca. Si habilitamos la propiedad AutoRedraw de un determinada Form, cuando una parte de dicha ventana sea cubierta por otra, el contenido de la primera es guardado en memoria, para que posteriormente sea mostrado de nuevo. Visual Basic maneja automticamente la regeneracin de controles no grficos, pero la regeneracin de controles grficos corre a cuenta del estado habilitado/ deshabilitado de la propiedad AutoRedraw. Si una caja de dibujo habilita la propiedad Autoredraw est generando un grfico persistente, es decir, un grfico que se guardar en memoria. Como Windows enva un mensaje Paint a la aplicacin cuando se superpone otra ventana encima de la de nuestra aplicacin, Visual Basic copiara el contenido de nuestro grfico en memoria. Por lo tanto no podemos utilizar el evento Paint de nuestra caja de dibujo pues nunca se producir. La habilitacin de la propiedad AutoRedraw deshabilita la generacin de eventos Paint. Como el alumno podr adivinar, se produce un gasto de memoria al guardar dicho grfico. Hay que decir que el tamao asignado para guardar el grfico de una caja de dibujo es igual al necesario para guardar la imagen correspondiente al tamao fsico de esa caja de dibujo, por tanto si asignamos una imagen ms grande del tamao fsico de la caja de dibujo al guardarlo en memoria los datos sobrantes se perdern y no podrn ser representados de nuevo. Cuando un Form habilita la propiedad AutoRedraw se esta produciendo un gasto de memoria igual al de la imagen fsica de la ventana.

Como la memoria sigue siendo un recurso no muy numeroso conviene siempre deshabilitar esta propiedad en los forms o utilizarla solo en muy contados casos. Si deshabilitamos esta propiedad en una form, debemos incluir el cdigo necesario para regenerar la apariencia grfica de nuestra form en el evento Paint. Pero esta opcin solo es aplicable cuando el cdigo necesario para regenerar la apariencia de la ventana no sea muy complicado, pues sino incurramos en una penalizacin de tiempo que podra obligarnos a emplear la tcnica de los grficos persistentes aunque signifique un gasto de memoria. Por regla general, deshabilitaremos la propiedad AutoRedraw solo cuando el cdigo necesario para regenerar la imagen es relativamente sencillo y no imponga importantes penalizaciones de velocidad.

11.5.2.- CLIPCONTROLS

Esta propiedad se aplica a las forms, cajas de dibujo y al control Frame. Como habrs podido observar los controles anteriores pueden actuar todos como contenedores de otros controles. Vamos a definir el trmino Clipping Region como un rea calculada automticamente por Windows que indica las zonas que deben ser pintadas cuando un contenedor es representado. Esta tcnica libera a Windows de gran trabajo de repintado. Suponiendo que tenemos una ventana superpuesta en parte, sobre otra ventana, cuando desaparece la primera Windows tiene dos alternativas. Por un lado repintar todo el rea de nuestra ventana y por otro repintar tan solo el rea cubierta anteriormente. Como vers la tcnica del Clipping puede ahorrar tiempo a nuestro sistema, aunque puede darse el caso que el tiempo necesario para recalcular la Clipping Region sea mayor que el necesario para repintar toda la ventana. Cuando habilitamos la propiedad ClipControls estamos indicando al contenedor que defina un rea de Clipping alrededor de todos los controles, excepto del control Shape, Line, Image, Label y cualquier Custom Control de carcter grfico. De esta forma evitamos que se repinte el rea ocupada por los controles no grficos lo que indudablemente ahorra tiempo. Como ya dijimos antes, desabilitando la propiedad CipControls en forms o contenedores donde no haya muchos controles , puede suponer un ahorro de tiempo.

11.6.- CDIGO DE LA APLICACIN GRAFICO.MAK

A continuacin se incluye el cdigo completo de la aplicacin GRAFICO.MAK, la cual ha servido de explicacin de los conceptos descritos a lo largo del presente captulo.
VISUAL BASIC VERSION 3.00

Begin Form Form5 Caption = "COLOR" Height = 2535 Left = 1635 LinkTopic = "Form2" MDIChild = -1 'True ScaleHeight = 2130 ScaleWidth = 5130 Top = 1650 Width = 5250 Begin CommandButton Command2 Caption = "OK" Height = 375 Left = 1200 TabIndex = 6 Top = 1560 Width = 2535 End Begin HScrollBar HScroll3 Height = 252 LargeChange = 5 Left = 1440 Max = 255 TabIndex = 2 Top = 1080 Width = 2772 End Begin HScrollBar HScroll2 Height = 252 LargeChange = 5 Left = 1440 Max = 255 TabIndex = 1 Top = 720 Width = 2772 End Begin HScrollBar HScroll1 Height = 252 LargeChange = 5 Left = 1440 Max = 255 TabIndex = 0 Top = 360 Width = 2772 End Begin Label Label3 Caption = "Verde" Height = 252 Left = 4320 TabIndex = 5 Top = 720 Width = 612 End Begin Label Label2 Caption = "Azul" Height = 252 Left = 4320 TabIndex = 4 Top = 1080 Width = 612 End

Begin Label Label1 Caption = "Rojo" Height = 252 Left = 4320 TabIndex = 3 Top = 360 Width = 732 End Begin Shape Shape1 FillStyle = 0 'Solid Height = 972 Left = 240 Shape = 3 'Circle Top = 360 Width = 972 End End Sub Command1_Click () Form5.Hide End Sub Sub Command2_Click () Unload Me End Sub Sub Form_Load () Left = 0 Top = 0 Form5.Height = 2535 Form5.Width = 5250 Shape1.FillColor = RGB(0, 0, 0) Form5.Caption = " COLOR: RGB(0,0,0) " End Sub Sub HScroll1_Change () Shape1.FillColor = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value) Form5.Caption = "COLOR:RGB( " + Str$(HScroll1.Value) + " , " + Str$(HScroll2.Value) + " , " + Str$ (HScroll3.Value) + " )" End Sub Sub HScroll1_Scroll () HScroll1_Change End Sub Sub HScroll2_Change () Shape1.FillColor = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value) Form5.Caption = "COLOR:RGB( " + Str$(HScroll1.Value) + " , " + Str$(HScroll2.Value) + " , " + Str$ (HScroll3.Value) + " )"

End Sub Sub HScroll2_Scroll () HScroll2_Change End Sub

Sub HScroll3_Change () Shape1.FillColor = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value) Form5.Caption = "COLOR:RGB( " + Str$(HScroll1.Value) + " , " + Str$(HScroll2.Value) + " , " + Str$ (HScroll3.Value) + " )" End Sub Sub HScroll3_Scroll () HScroll3_Change End Sub Begin Form Form1 Caption = "CAMBIO PROPIEDADES" Height = 4875 Left = 2625 LinkTopic = "Form1" MDIChild = -1 'True ScaleHeight = 4470 ScaleWidth = 3450 Top = 2115 Width = 3570 Begin CommandButton Command1 Caption = "SALIR" Height = 375 Left = 480 TabIndex = 3 Top = 3960 Width = 2535 End Begin HScrollBar HScroll3 Height = 255 LargeChange = 100 Left = 480 Max = 8192 Min = 1 TabIndex = 2 Top = 3480 Value = 1 Width = 2535 End Begin HScrollBar HScroll2 Height = 255 LargeChange = 2 Left = 480 Max = 15 TabIndex = 1 Top = 2880 Width = 2535 End Begin HScrollBar HScroll1 Height = 255 LargeChange = 2 Left = 480 Max = 5 TabIndex = 0 Top = 2280 Width = 2535 End Begin Label Label3 Alignment = 2 'Center

Caption = "GROSOR DE LNEA" Height = 255 Left = 480 TabIndex = 6 Top = 3240 Width = 2535 End Begin Label Label2 Alignment = 2 'Center Caption = "COLOR DE FONDO" Height = 255 Left = 480 TabIndex = 5 Top = 2640 Width = 2535 End Begin Label Label1 Alignment = 2 'Center Caption = "TIPO DE SHAPE " Height = 255 Left = 480 TabIndex = 4 Top = 2040 Width = 2535 End Begin Shape Shape1 BackColor = &H000000FF& BackStyle = 1 'Opaque Height = 1500 Left = 600 Shape = 3 'Circle Top = 225 Width = 2310 End End Sub Command1_Click () Unload Me End Sub Sub Form_DblClick () Left = 0 Top = 0 Form1.Height = 4875 Form1.Width = 3315 End Sub Sub HScroll1_Change () Shape1.Shape = HScroll1.Value End Sub Sub HScroll2_Change () Shape1.BackColor = QBColor(HScroll2.Value) End Sub Sub HScroll3_Change () Shape1.BorderWidth = HScroll3.Value End Sub

Begin Form Form2 Caption = "MOVIMIENTO" Height = 4500 Left = 1695 LinkTopic = "Form2" MDIChild = -1 'True ScaleHeight = 4095 ScaleWidth = 2880 Top = 1935 Width = 3000 Begin Timer Timer1 Enabled = 0 'False Interval = 50 Left = 2040 Top = 3720 End Begin CommandButton Command1 Caption = "Command1" Height = 375 Left = 480 TabIndex = 0 Top = 2640 Width = 1995 End Begin Shape Shape1 BackColor = &H000000FF& BackStyle = 1 'Opaque Height = 255 Left = 255 Shape = 3 'Circle Top = 360 Width = 255 End End Dim l% Dim r% Dim T% Dim B% Dim direccion As Integer Dim interruptor As Integer Sub Command1_Click () If interruptor = 1 Then interruptor = 0 Command1.Caption = "Terminar" timer1.Enabled = -1 Else timer1.Enabled = 0 Unload Me End If End Sub Sub Form_Load () Left = 0 Top = 0 Form2.Height = 4500 Form2.Width = 3000

interruptor = 1

Command1.Caption = "Comenzar" l% = Command1.Left r% = Command1.Left + Command1.Width T% = Command1.Top B% = Command1.Top + Command1.Height

End Sub Sub Movimiento () Select Case direccion Case 1 Shape1.Move Shape1.Left + 80, Shape1.Top - 80 If Form2.Width - Shape1.Left - 120 <= Shape1.Width Then direccion = 3 If Shape1.Top <= 0 Then direccion = 2 If Shape1.Top <= B% And Shape1.Top >= T% And Shape1.Left > l% And Shape1.Left < r% Then direccion = 2

Case 2 Shape1.Move Shape1.Left + 80, Shape1.Top + 80 If Form2.Width - Shape1.Left - 120 <= Shape1.Width Then direccion = 4 If Shape1.Top + Shape1.Height + 400 >= Form2.Height Then direccion = 1 If Shape1.Top + Shape1.Height >= T% And Shape1.Top + Shape1.Height <= B% And Shape1.Left >= l% And Shape1.Left <= r% Then direccion = 1

Case 3 Shape1.Move Shape1.Left - 80, Shape1.Top - 80 If Shape1.Left <= 0 Then direccion = 1 If Shape1.Top <= 0 Then direccion = 4 If Shape1.Top <= B% And Shape1.Top >= T% And Shape1.Left > l% And Shape1.Left < r% Then direccion = 4 Case 4 Shape1.Move Shape1.Left - 80, Shape1.Top + 80 If Shape1.Left <= 0 Then direccion = 2 If Shape1.Top + Shape1.Height + 400 >= Form2.Height Then direccion = 3 If Shape1.Top + Shape1.Height >= T% And Shape1.Top + Shape1.Height <= B% And Shape1.Left > l% And Shape1.Left < r% Then direccion = 3 Case Else direccion = 1

End Select

End Sub Sub Timer1_Timer () Movimiento End Sub

Begin Form Form3 Caption = "ANIMACION"

Height = 3285 Left = 3105 LinkTopic = "Form3" MDIChild = -1 'True ScaleHeight = 2880 ScaleWidth = 2895 Top = 2235 Width = 3015 Begin CommandButton Command5 Caption = "SALIR" Height = 375 Left = 120 TabIndex = 4 Top = 2400 Width = 2655 End Begin CommandButton Command4 Caption = "Stop" Height = 495 Left = 1920 TabIndex = 3 Top = 1800 Width = 855 End Begin Timer Timer1 Enabled = 0 'False Interval = 500 Left = 240 Top = 3360 End Begin CommandButton Command3 Caption = ">>" Height = 495 Left = 720 TabIndex = 2 Top = 1800 Width = 495 End Begin CommandButton Command2 Caption = "<" Height = 495 Left = 1320 TabIndex = 1 Top = 1800 Width = 495 End Begin CommandButton Command1 Caption = ">" Height = 495 Left = 120 TabIndex = 0 Top = 1800 Width = 495 End Begin Image Image2 BorderStyle = 1 'Fixed Single Height = 1455 Left = 600 Top = 120 Width = 1695 End

Begin Image Image1 Height = 1500 Index = 6 Left = 3000 Picture = GRAF3.FRX:0000 Top = 3960 Visible = 0 'False Width = 1500 End Begin Image Image1 Height = 1500 Index = 5 Left = 2520 Picture = GRAF3.FRX:14CA Top = 3960 Visible = 0 'False Width = 1500 End Begin Image Image1 Height = 1500 Index = 4 Left = 2040 Picture = GRAF3.FRX:2994 Top = 3960 Visible = 0 'False Width = 1500 End Begin Image Image1 Height = 1500 Index = 3 Left = 1680 Picture = GRAF3.FRX:3E5E Top = 3960 Visible = 0 'False Width = 1500 End Begin Image Image1 Height = 1500 Index = 2 Left = 1200 Picture = GRAF3.FRX:5328 Top = 3960 Visible = 0 'False Width = 1500 End Begin Image Image1 Height = 1500 Index = 1 Left = 720 Picture = GRAF3.FRX:67F2 Top = 3960 Visible = 0 'False Width = 1500 End Begin Image Image1 Height = 1500 Index = 0 Left = 240 Picture = GRAF3.FRX:7CBC Top = 3960 Visible = 0 'False

Width End End Dim x%

= 1500

Sub Command1_Click () If x% = -1 Then x% = 6 x% = x% + 1 If x% > 6 Then x% = 0 Image2.Picture = Image1(x%).Picture End Sub Sub Command2_Click () x% = x% - 1 If x% = -1 Then x% = 6 Image2.Picture = Image1(x%).Picture

End Sub Sub Command3_Click () Timer1.Enabled = -1 Command1.Enabled = 0 Command2.Enabled = 0 Command3.Enabled = 0 End Sub Sub Command4_Click () Timer1.Enabled = 0 Image2.Picture = Image1(6).Picture Command1.Enabled = -1 Command2.Enabled = -1 Command3.Enabled = -1 End Sub Sub Command5_Click () Unload Me End Sub Sub Form_Load () Left = 0 Top = 0 Form3.Height = 3285 Form3.Width = 3015 End Sub Sub Timer1_Timer () Static y% Image2.Picture = Image1(y%).Picture If y% = 6 Then y% = 0 y% = y% + 1 End Sub

Begin Form Form4 BackColor = &H00C0C0C0& Caption = "3D LOOK" ForeColor = &H00000000& Height = 4545 Left = 1245 LinkTopic = "Form4" MDIChild = -1 'True ScaleHeight = 4140 ScaleWidth = 7365 Top = 2460 Width = 7485 Begin Frame Frame1 BackColor = &H00C0C0C0& Caption = "Frame1" Height = 1215 Left = 120 TabIndex = 8 Top = 1680 Width = 3375 End Begin VScrollBar VScroll1 Height = 2535 Left = 3720 TabIndex = 7 Top = 240 Width = 255 End Begin HScrollBar HScroll1 Height = 255 Left = 120 TabIndex = 6 Top = 1200 Width = 3375 End Begin FileListBox File1 Height = 1005 Left = 2880 TabIndex = 5 Top = 3000 Width = 2175 End Begin DirListBox Dir1 Height = 930 Left = 240 TabIndex = 4 Top = 3000 Width = 2415 End Begin ListBox List1 Height = 1980 Left = 4200 TabIndex = 3 Top = 720 Width = 3015 End Begin TextBox Text1 Height = 285 Left = 4200 TabIndex = 2

Text = "Text1" Top = 240 Width = 3015 End Begin CommandButton Command2 Caption = "SALIR" Height = 975 Left = 5280 TabIndex = 1 Top = 3000 Width = 1935 End Begin CommandButton Command1 Caption = "3D LOOK" Height = 735 Left = 120 TabIndex = 0 Top = 240 Width = 3375 End End Dim Bisel% Sub Command1_Click () Bisel% = 32 Hacer3dForm Form4, Command1 Hacer3dForm Form4, Dir1 Hacer3dForm Form4, File1 Hacer3dForm Form4, HScroll1 Hacer3dForm Form4, VScroll1 Hacer3dForm Form4, Text1 Hacer3dForm Form4, List1 Hacer3dForm Form4, Frame1 End Sub Sub Command2_Click () Unload Me End Sub Sub Form_Load () Left = 0 Top = 0 Form4.Height = 4545 Form4.Width = 7485 End Sub Sub Hacer3dForm (UnaForm As Form, unControl As Control) L% = unControl.Left R% = unControl.Left + unControl.Width T% = unControl.Top B% = unControl.Top + unControl.Height UnaForm.Line (L% - Bisel%, T% - Bisel%)-(R% + Bisel%, T%), QBColor(15), BF UnaForm.Line (L% - Bisel%, T%)-(L%, B%), QBColor(15), BF UnaForm.Line (L% - Bisel%, B%)-(R% + Bisel%, B% + Bisel%), QBColor(8), BF

UnaForm.Line (R%, B%)-(R% + Bisel%, T%), QBColor(8), BF UnaForm.Line (L% - Bisel%, T% - Bisel%)-(R% + Bisel%, B% + Bisel%), QBColor(0), B End Sub

CAPTULO 12 FICHEROS 12.1.- INTRODUCCIN

Hasta ahora todos los datos que han manejado nuestros programas han sido temporales, lo que quiere decir que se perdan cuando desconectamos el ordenador. Huelga decir, que esta situacin no es la ms deseable y que en la mayora de los casos interesa guardar como oro en pao, los datos que estamos manipulando. La forma habitual de almacenar datos en un ordenador es hacerlo mediante ficheros. Un fichero es un rea de almacenamiento de datos situado en un soporte permanente, ya sea magntico u ptico, y que es identificado por un nombre. El sistema de ficheros de Visual Basic es muy parecido al que tena su antepasado el QuickBasic aunque, existen diferencias sustanciales entre ambos lenguajes, especialmente en lo que se refiere a aquellas operaciones con ficheros que implican interaccin con el usuario. Es este sentido, el presente captulo no solo tratar de los conceptos ms tericos de los ficheros, sino que tambin lo har sobre aquellas operaciones de manipulacin de ficheros por el usuario. Para ello Visual Basic incorpora potentes utilidades implementadas en forma de controles. Pero vayamos poco a poco y suframos primero el rigor de la teora antes de pasar a jugar con ficheros.

12.2.- TIPOS DE FICHEROS EN VISUAL BASIC

Visual Basic, atendiendo a la forma en que se accede a ellos, diferencia tres clases de ficheros: - secuenciales: son, en general, una sucesin de caracteres de texto almacenados consecutivamente. El acceso a un elemento del fichero implica el paso previo por los elementos que le anteceden. - aleatorios: se accede a los datos de forma directa mediante su posicin, es decir, el lugar relativo que ocupan. Los datos se organizan en registros de longitud fija, identificados por un nmero de registro. - binarios: permiten el almacenamiento de datos sin que estos tengan que estar sometidos a algn tipo de requerimiento. No importa el tipo de dato que almacenen ni su longitud de registro ya que el fichero es tratado como una secuencia de bytes individuales.

12.2.1.- FICHEROS SECUENCIALES

Como hemos dicho antes, los ficheros secuenciales son especialmente apropiados para el almacenamiento de texto. Por ejemplo, el fichero sobre el que se est escribiendo este captulo. Para que podamos empezar a trabajar con un fichero, lo primero que tiene que ocurrir es que el fichero exista, porque sino debemos crearlo. Cuando ya tengamos el fichero procederemos a abrirle para poder operar sobre l. Una vez abierto, se pueden escribir caracteres, leerlos o aadir nuevos caracteres a los ya existentes. Esas operaciones se pueden identificar mediante las palabras Input, Output y Append. Al finalizar el trabajo se debe cerrar el fichero. La sintaxis de Visual Basic para la apertura de ficheros secuenciales es: Open NombreDeFichero For [Input | Output | Append] As NmeroDeFichero Len = tamao del buffer NombreDeFichero es el nombre, incluido el path con el que vamos a identificar a un fichero mientras que NmeroDeFichero ser el nmero con el que nos referiremos al fichero cada vez que queramos hacer algo con l. Se puede especificar un tamao en bytes para el buffer. Cuando intentamos abrir un fichero inexistente, el sistema acta de dos formas. Si el fichero se intenta abrir para la operacin Input, se genera un mensaje de error, indicando que el fichero debe existir. Si se intenta abrir para las operaciones de Output y Append, el sistema crea el fichero y luego lo abre. Para trabajar con un fichero secuencial, se utilizarn generalmente, variables como elementos de intercambio de informacin.

12.2.1.1.- Lectura de datos en un fichero secuencial Supongamos que queremos extraer informacin de un fichero secuencial. Lo primero que hay que hacer es abrir el fichero para Input. Luego echaremos mano de una serie de sentencias que copiarn el contenido del fichero en variables. Las sentencias que ofrece Visual Basic para tal fin son: Line Input #, Input$ Input #. Line Input # Lee una lnea de un fichero secuencial y la almacena en una variable. El proceso de lectura finaliza cuando se encuentra un carcter de retorno de carro. La sintaxis de esta sentencia es: Line Input # NmeroDeFichero, NombreDeVariable donde, NmerodeFichero es aquel que hemos utilizado en la sentencia Open para abrir el fichero y NombreDeVariable es el nombre de la variable en la que almacenaremos la lnea de texto leda.

Input$ Es una funcin encargada de devolver un String que contiene los caracteres ledos en un fichero secuencial. La sintaxis es: Input$ (n, [#]NmeroDeFichero) donde, n es el nmero de caracteres que leer (ese nmero no puede ser mayor de 65535) y NmeroDeFichero es el nmero del fichero asignado en la sentencia Open.

Input # Lee datos procedentes de un fichero secuencial y asigna esos datos a una serie de variables. Su sintaxis es: Input # NmeroDeFichero, ListaDeVariables Se debe tener mucho cuidado en la asignacin de datos ledos a variables, procurando que los tipos de datos ledos se correspondan con los tipos de datos de las variables. Cuando la sentencia intenta leer un dato numrico, comienza por el primer carcter distinto de un espacio y finaliza cuando encuentra una coma, un espacio o un carcter de fin de lnea. Cuando queremos leer un String se asume que el comienzo de ste es el primer carcter distinto de un espacio y finaliza cuando encuentra una coma, un espacio o un carcter de fin de lnea. Si el primer carcter son unas comillas ("), la sentencia las ignora y almacena como String todos los caracteres que estn encerrados entre stas y las siguientes comillas. Es habitual que cuando queramos trabajar con datos numricos stos se encuentren separados por comas, mientras que si pretendemos trabajar con cadenas de caracteres, se simplifican mucho las cosas si estn encerradas entre comillas.

12.2.1.2.- Escritura de datos en un fichero secuencial Para escribir en un fichero secuencial se deben usar tambin variables. El primer paso consiste en abrir el fichero para Output o Append. Visual Basic tiene dos sentencias que permiten la introduccin de datos en un fichero: Print # y Write #. Print # Escribe datos en un fichero secuencial. La sintaxis de esta sentencia es: Print # NmeroDeFichero, [ [ {Spc(n) | Tab(n)} ] [ListaDeExpresiones] [{; | ,}]] A parte del ya conocido NmeroDeFichero, esta sentencia puede llevar opcionalmente, la funcin Spc(n) que permite insertar espacios entre los datos escritos y la funcin Tab(n) que coloca los datos en la columna especificada en su interior. La ListaDeExpresiones es el conjunto de datos

que queremos escribir en el fichero. Los caracteres de ";" y "," que aparecen al final de la expresin sirven para indicar el lugar donde se ubicarn los datos que escribamos. As el carcter ";" indica que el siguiente dato se escriba inmediatamente despus del ltimo carcter, mientras que la "," indica que el dato que aparece a continuacin se escriba en la siguiente zona de impresin. Las zonas de impresin comienzan cada 14 columnas. Ejemplo Print #3, "Dato 1", "Dato 2" Las cadenas Dato 1 y Dato 2 se escriben en distintas reas de impresin. Print #3, "Dato 1"; "Dato 2" En este caso la escritura se efecta de forma contigua.

Write # Escribe datos en un fichero secuencial. Su sintaxis es: Write # NmeroDeFichero [, ListaDeExpresiones] La principal diferencia con la sentencia Print # es que Write # separa automticamente con comas las distintas expresiones y coloca entre comillas aquellas expresiones que sean de tipo String. Ejemplo. Dim Nombre As String Dim Edad As Integer Nombre = "Pepito" Edad = 45 ... Write #1 Nombre, Edad La salida de esta sentencia ser: "Pepito",45

12.2.2.- FICHEROS ALEATORIOS Como hemos comentado antes, este tipo de ficheros estn formados por registros de igual longitud. Cada registro puede estar compuesto, a su vez, por campos. Un campo es la unidad mnima de informacin de un registro. Est caracterizado por su tamao o longitud y por su tipo de datos. En la mayora de los lenguajes de programacin los campos son de longitud fija.

Un registro es una coleccin de informacin normalmente relativa a una entidad particular. Es una coleccin de campos lgicamente relacionados. Cada registro puede contener uno o ms campos. Un registro de un solo campo corresponde a cualquier tipo de dato estndar. Si el registro tiene varios campos, significa que tenemos algn tipo de dato definido por el usuario, por ejemplo, una estructura de datos.

12.2.2.1.- Definicin de tipo de registros. Antes de abrir un fichero para acceso aleatorio, debemos tener definido el tipo de dato de los registros del fichero. Supongamos que definimos un tipo de dato llamado TopModel en el que queremos introducir los datos ms personales de las ms espectaculares modelos. Type TopModel Nombre As String*10 Apellidos As String*30 Edad As Integer Altura As Single Peso As Single Pecho As Single Cintura As Single Caderas As Single Ojos As String*10 Pelo As String*10 End Type Junto a esta declaracin se pueden definir variables que la aplicacin necesitar para procesar un fichero abierto para uso aleatorio. Global Espaolas As TopModel

12.2.2.2.- Apertura del fichero La sintaxis para abrir un fichero de acceso aleatorio es: Open Fichero For Random As NmeroDeFichero Len=LongitudDeRegistro donde Len determina el tamao de cada registro del fichero. El resto de expresiones siguen las mismas reglas que hemos expuesto en los ficheros secuenciales. Ejemplo Open "MODELOS.DAT" For Random As #1 Len=82 Si no queremos calcular la longitud del registro que hemos definido, podemos usar la funcin Len() que nos devuelve la longitud en bytes de la variable que introduzcamos entre los parntesis.

Los ficheros de acceso aleatorio son los que Visual Basic acepta por defecto, lo que significa que si en la sentencia Open ... omitimos las palabras For Random As, el sistema realiza la misma operacin que si las dejamos.

12.2.2.3.- Edicin del fichero La forma de leer o escribir datos en un fichero de este tipo, pasa por copiar los registros en variables y trabajar con ellas. Para efectuar esto, Visual Basic ofrece la sentencia Get, la cual copia un registro desde un fichero a una variable. Ejemplo Get #1, NmeroDeRegistro, Espaolas La sentencia Get tiene la siguiente sintaxis: Get #NmeroDeFichero, NmeroDeRegistro, NombreDeVariable donde como siempre NmeroDeFichero es aquel que usamos en la sentencia Open para abrir el fichero, NmeroDeRegistro es el nmero del registro que vamos a copiar y NombreDeVariable es el nombre de la variable en la que vamos a copiar el registro. La variable en la que hemos copiado el registro, debe ser del mismo tipo que el registro y podemos visualizar su contenido en cualquier momento.

12.2.2.4.- Escritura de variables en registros. El proceso de escritura de registros en ficheros de acceso aleatorio utiliza fundamentalmente la sentencia Put. Esta sentencia escribe el contenido de una variable en un fichero. Su sintaxis es muy similar a la de la sentencia Get descrita anteriormente. Put NmeroDeFichero, NmeroDeRegistro, NombreDeVariable Si NmeroDeRegistro coincide con la posicin de un registro ya existente, entonces ese registro es reemplazado por el nuevo. Si por el contrario no existe, se aade al final del fichero. Es posible que queramos borrar un registro. para hacer esta operacin el camino ms sencillo sera reemplazarlo por un registro en blanco. Sin embargo, esto no es demasiado conveniente puesto que tendra un registro en algn lugar del fichero que ocupa espacio y no contiene nada. Visual Basic carece de la posibilidad de borrar un determinado registro y hacer que el resto de registros del sistema se renumere de acuerdo al cambio efectuado. Es relativamente sencillo crear una funcin que haga esa tarea. Dicha funcin debera seguir el siguiente algoritmo: 1.- Determinar el registro que queremos borrar. 2.- Copiar el contenido de los registros que le siguen en un registro precedente. Es decir, si queremos borrar el registro nmero 7 de un total de 10 podemos copiar el nmero 8 sobre el 7, el 9 sobre el 8 y el 10 sobre el 9, con lo cual desaparece el registro 7.

3.- Como ahora tenemos dos registro idnticos, el 9 y el 10 tenemos que eliminar el ltimo. 4.- Abrir un nuevo fichero. 5.- Copiar en el fichero nuevo los 9 primeros registros del fichero anterior. 6.- Eliminar el fichero primitivo (sentencia Kill). 7.- Renombrar el nuevo fichero con el nombre del anterior. 8.- Fin.

12.2.3.- FICHEROS DE ACCESO BINARIO

En un fichero binario los bytes pueden representar cualquier cosa. Se aconseja su uso cuando sea importante cuidar el tamao del fichero. La sintaxis para la apertura de ficheros binarios es: Open NombreDeFichero For Binary As NmeroDeFichero La primera razn para economizar espacio de almacenamiento es que los ficheros binarios, al contrario que los de acceso aleatorio, no necesitan tener registros con campos de longitud fija. Si utilizamos un campo definido como un String de 500 caracteres y solo utilizamos 25, estamos malgastando 475 bytes. Por eso, cuando definamos una variable, no haremos mencin de su tamao, permitiendo que ocupe lo que necesite. Pero no todas iban a ser ventajas. Cuando intentamos escribir un campo de longitud variable debemos conocer cual es su longitud, para lo cual podemos usar la funcin Len(). Las operaciones tpicas con los ficheros, son las de escritura y lectura. Para ello se usar la sentencia Put para la primera y Get e Input$ para la segunda. La sintaxis de estas dos funciones ya ha sido descrita anteriormente. Sealar que para ficheros binarios se puede especificar como NmeroDeRegistro la posicin del byte en el que comienza la escritura. No obstante, es frecuente evitar esta especificacin dejando un espacio en blanco en su lugar. Ejemplo Put #5, , NombreDeVariable Si en un programa especificamos una vez la posicin de inicio de escritura, el resto de operaciones de escritura se hacen a continuacin de la primera, sin tener que volver a especificar la posicin. La lectura se hace por medio de Get, la cual coloca en una variable de longitud conocida el nmero de bytes que sta admite. Cuando esa variable sea de longitud variable, el nmero de bytes ledos coincide con la longitud de la variable en el momento de la lectura. Ejemplo

Como ejemplo de las operaciones con ficheros, vamos a disear una aplicacin, denominada RANDOM.MAK, y cuyo cdigo se incluye a continuacin. La aplicacin consiste en la utilizacin de ficheros de acceso aleatorio para crear una pequea base de datos personales. Una vez que se introduce el nombre y los apellidos, se guarda esa informacin en un fichero. Se puede visualizar ese fichero y mover por los diferentes registros tanto para adelante como hacia el final. El programa nos avisa tambin de cuando hemos alcanzado el primer y ltimo registro. En el caso que ocupa a este captulo, se debe prestar especial atencin al cdigo para la apertura, escritura y lectura de datos en un fichero aleatorio. Open "D:\ANT" For Random As NumeroFichero Len = Len(Personal) ... Put NumeroFichero, PosicionFinal, Personal ... Get NumeroFichero, posicion, Personal

Fig. 12.1. Interface de la aplicacin RANDOM.MAK.

' Mdulo para la definicin de variables Type Ficha Nombre As String * 15 Apellidos As String * 30 End Type Global Personal As Ficha Global Posicion As Long Global PosicionFinal As Long Global NumeroFichero As Integer

VERSION 3.00 Begin Form Form1 BackColor = &H00C0C0C0& Caption = "FICHEROS RANDOM" ForeColor = &H00000000&

Height = 3135 Left = 1695 LinkTopic = "Form1" ScaleHeight = 2730 ScaleWidth = 7440 Top = 2235 Width = 7560 Begin CommandButton Command6 Caption = "INTRODUCIR" Height = 495 Left = 2640 TabIndex = 9 Top = 1920 Width = 2295 End Begin CommandButton Command5 Caption = ">>" Height = 495 Left = 4920 TabIndex = 8 Top = 1920 Width = 2055 End Begin CommandButton Command4 Caption = "<<" Height = 495 Left = 480 TabIndex = 7 Top = 1920 Width = 2175 End Begin CommandButton Command3 Caption = "CERRAR" Height = 495 Left = 4920 TabIndex = 6 Top = 1440 Width = 2055 End Begin CommandButton Command2 Caption = "INSERTAR" Height = 495 Left = 2640 TabIndex = 5 Top = 1440 Width = 2295 End Begin CommandButton Command1 Caption = "ABRIR" Height = 495 Left = 480 TabIndex = 4 Top = 1440 Width = 2175 End Begin TextBox Text2 Height = 285 Left = 1320 TabIndex = 1 Top = 720 Width = 5895

End Begin TextBox Text1 Height = 285 Left = 2400 TabIndex = 0 Top = 240 Width = 3495 End Begin Line Line1 BorderColor = &H000000FF& BorderWidth = 3 X1 = 240 X2 = 7200 Y1 = 1200 Y2 = 1200 End Begin Label Label2 BackColor = &H00C0C0C0& Caption = "APELLIDOS:" Height = 255 Left = 195 TabIndex = 3 Top = 765 Width = 1095 End Begin Label Label1 BackColor = &H00C0C0C0& Caption = "NOMBRE:" Height = 255 Left = 1485 TabIndex = 2 Top = 300 Width = 855 End End Sub Command1_Click () NumeroFichero = FreeFile Open "D:\ANT" For Random As NumeroFichero Len = Len(Personal) PosicionFinal = LOF(NumeroFichero) \ Len(Personal) posicion = 1 Command1.Enabled = 0 Command2.Enabled = -1 Command3.Enabled = -1 Command4.Enabled = -1 Command5.Enabled = -1 Command6.Enabled = 0 Get NumeroFichero, posicion, Personal posicion = posicion + 1 Text1.Text = Personal.Nombre Text2.Text = Personal.Apellidos End Sub Sub Command2_Click () Text1.Text = "" Text2.Text = "" Command1.Enabled = 0 Command2.Enabled = 0 Command3.Enabled = 0 Command4.Enabled = 0

Command5.Enabled = 0 Command6.Enabled = -1

End Sub Sub Command3_Click () Close NumeroFichero End End Sub Sub Command4_Click () posicion = posicion - 1 If posicion <= 1 Then MsgBox "es el primer elemento del fichero", 1, "ATENCION" posicin = 1 End If Get NumeroFichero, posicion, Personal Text1.Text = Personal.Nombre Text2.Text = Personal.Apellidos End Sub Sub Command5_Click () posicion = posicion + 1 If posicion >= PosicionFinal Then MsgBox "es el ultimo elemento del fichero", 1, "ATENCION" posicin = PosicionFinal End If Get NumeroFichero, posicion, Personal Text1.Text = Personal.Nombre Text2.Text = Personal.Apellidos

End Sub Sub Command6_Click () Personal.Nombre = Text1.Text Personal.Apellidos = Text2.Text PosicionFinal = PosicionFinal + 1 Put NumeroFichero, PosicionFinal, Personal Text1.Text = "" Text2.Text = "" Command1.Enabled = 0 Command2.Enabled = -1 Command3.Enabled = -1 Command4.Enabled = -1 Command5.Enabled = -1 Command6.Enabled = 0 End Sub Sub Form_Load () Command1.Enabled = -1 Command2.Enabled = 0 Command3.Enabled = 0 Command4.Enabled = 0 Command5.Enabled = 0

Command6.Enabled = 0

End Sub

12.3.- CONTROLES PARA EL MANEJO DE FICHEROS

Una vez que sabemos como crear ficheros y como leer y escribir datos en ellos, vamos a ocuparnos de estudiar la gestin que Visual Basic hace del sistema de ficheros. par ello disponemos de tres controles: - cuadro de lista de discos, - cuadro de lista de directorios, - cuadro de lista de ficheros. En esencia, la idea de todo esto es poder presentar al usuario informacin de discos, directorios y ficheros de su sistema y permitir la eleccin de determinados ficheros para lo que sea conveniente. Los controles del sistema de ficheros son una forma intuitiva, ordenada y sencilla de presentar informacin sobre la situacin de los ficheros. Todo aquel que haya usado Windows, se habr encontrado en numerosas ocasiones con un cuadro de dilogo como el que aparece en la siguiente figura (Fig. 12.2):

Fig. 12.2. Cuadro de dilogo para la apertura de un proyecto en Visual Basic.

En concreto, esta figura corresponde al cuadro de dilogo que se despliega al abrir la opcin Open Project... del men File del Visual Basic. Como se puede ver, tiene fundamentalmente tres cajas. En una de ellas se visualizan los discos de que dispone el sistema, en otra los directorios del disco actual y en la otra los ficheros del directorio actual. Cada una de estas cajas se crea mediante los tres controles ya sealados. Veamos como se trabaja con cada uno de estos controles.

12.3.1.- CUADRO DE LISTA DE DISCOS

En l se presenta informacin sobre el disco actual de trabajo. A su derecha, aparece una flecha que al ser pulsada despliega informacin sobre todas las unidades de disco de que disponemos.

Este control tiene una propiedad importante, llamada Drive la cual determina el disco actual de trabajo. No es posible cambiar el disco actual con solo elegir un disco de la lista, pero se puede usar la propiedad Drive como argumento de la sentencia ChDrive para hacer el cambio. La sentencia ChDrive cambia el disco actual. Su sintaxis es: ChDrive NombreDelDisco Se puede usar la propiedad Drive en una expresin como ChDrive Drive1.Drive Cuando el usuario elige uno de los discos que aparecen en la lista, se produce un evento (tipo Change). Como el nombre por defecto para ese control es Drive1, el procedimiento de evento ser Drive1_Change()

12.3.2.- CUADRO DE LISTA DE DIRECTORIOS

Mediante este control podemos visualizar en pantalla una lista de los directorios disponibles en un determinado disco. El cuadro de directorios es un cuadro de lista simple. El directorio actual aparece situado en la parte superior y los subdirectorios que tuviera estn situados debajo de l un poco identados a la derecha. Si la lista de directorios no cabe en la caja, podemos desplazarnos mediante las barras de desplazamiento vertical que estn situadas a la derecha. Cada directorio tiene colocado a su izquierda un icono que representa una carpeta. En el directorio actual esa carpeta est abierta mientras que en los otros est cerrada. Una propiedad muy utilizada de este control es Path, la cual fija o devuelve el directorio actual del cuadro de lista. Cada directorio est identificado por un nmero entero. Este nmero es el valor de la propiedad ListIndex. El directorio de trabajo tiene asociado el valor ListIndex = -1. aquellos directorios que estn por encima de l tendrn valores de -2,-3, etc., mientras que los que estn por debajo valdrn 0,1,2, etc. Cuando el usuario cambia el directorio mediante el ratn, se produce un evento de tipo Change. Si el nombre por defecto de ese control es Dir1, el procedimiento de evento que se produce ser Dir1_Change(). cuando esto ocurre el nuevo path se coloca en la propiedad Path. Con solo un click de ratn, se ilumina el directorio o subdirectorio sobre el que hemos pulsado. Cuando se produce un doble click ese directorio se asigna a la propiedad Path, con lo que pasa a ser el directorio actual. En ese momento la propiedad ListIndex pasa a valer -1 y se muestran los subdirectorios que cuelgan del nuevo directorio de trabajo.

12.3.3.- CUADRO DE LISTA DE FICHEROS

Para completar la terna relacionada con el sistema de ficheros, Visual Basic ofrece un tercer control llamado cuadro de lista de ficheros. Su misin es visualizar los ficheros existentes en el directorio actual. Este control maneja , entre otras, dos propiedades importantes. La primera, ya conocida, es la propiedad Path que almacena el camino del directorio cuyos ficheros quiero visualizar. La segunda es Pattern y permite visualizar un subconjunto de ficheros elegido mediante su extensin. Ejemplo File1.Pattern = "*.EXE; *.BAS" Como se ve en el ejemplo, esta propiedad puede tomar varios grupos de ficheros identificados por su extensin. Tambin se puede usar el comodn "?". Visual Basic permite adems determinar los ficheros que se visualizan en virtud a sus atributos. As las propiedades ReadOnly, Archive, Normal, Sytem, Hidden se pueden activar o desactivar (True o False) para que aparezcan, por ejemplo, solo ficheros de lectura o solo ficheros ocultos. La versin 3.0 de Visual Basic permite la eleccin mltiple de ficheros, de la misma forma que lo hace Windows 3.1. La propiedad que se encarga de esto es Multiselect. Puede tener tres valores: 0.- no permite la seleccin mltiple, 1.- la seleccin mltiple se hace pulsando sobre cada fichero y de uno en uno, 2.- la combinacin de teclas Shift+click permite seleccionar un grupo de ficheros a la vez. Aunque cada uno de los tres controles que acabamos de ver tiene entidad por si mismo, a nadie se le escapa que la forma ms adecuada de utilizar el sistema de ficheros de Visual Basic es mediante la utilizacin conjunta de los tres controles. Cuando seleccionamos un determinado disco, se genera un procedimiento de tipo Drive1_Change. Si escribimos en ese procedimiento la lnea Dir1.Path = Drive1.Drive estamos pasando el disco actual a la variable Path de la lista de directorios. Esto a su vez genera otro evento Dir1_Change. Una sentencia similar a la anterior escrita en el procedimiento de evento Dir1_Change() permite pasar el camino del directorio actual a la variable Path del cuadro de ficheros File1.Path = Dir1.Path

El resultado final es que tenemos en pantalla los ficheros del directorio elegido para el disco de trabajo. Aunque los que estamos acostumbrados a utilizar aplicaciones Windows, vemos con normalidad estas facilidades, la verdad es que son de una potencia y una utilidad fuera de toda duda.

Ejemplo Desarrollar una aplicacin que incorpore en una sola ventana los tres controles para el manejo de ficheros. Dicha aplicacin debe constar a su vez de una caja de listas donde se visualizen los ficheros elegidos mediante un click de ratn. Un botn de comando permitir elegir el criterio de seleccin para los ficheros que aparezcan en la caja del control de ficheros. Inicialmente y por defecto debern aparecer todos los ficheros.

El interface para el desarrollo de esta aplicacin se muestra en la Fig. 12.3. En ella se muestran todos los elementos que nos pide el programa.

Fig. 12.3. Interface de la aplicacin ejemplo.

El cdigo que lleva consigo la aplicacin es muy sencillo. Tan solo destacar, a parte de la utilizacin de los tres controles que acabamos de comentar en el captulo, que al pulsar el botn de comando cambio de seleccin, se despliega una caja de dilogo pidiendonos la introduccin de un criterio de seleccin. Si ese criterio es *.*, entonces se visualizan todos los ficheros en el cuadro de dilogo de ficheros. Cuando se utilice otro criterio, por ejemplo, *.doc, solo aparecen los ficheros que tengan esa extensin.

Haciendo uso de la propiedad AddItem de las cajas de lista, se van aadiendo a sta, ficheros elegidos con el ratn.

MICROSOFT VISUAL BASIC VERSION 3.00 Begin Form Form1 BackColor = &H00C0C0C0& Caption = "FICHEROS" Height = 5565 Left = 1770 LinkTopic = "Form1" ScaleHeight = 5160 ScaleWidth = 5310 Top = 1260 Width = 5430 Begin CommandButton Command2 Caption = "SALIR" Height = 735 Left = 2640 TabIndex = 5 Top = 4080 Width = 2415 End Begin CommandButton Command1 Caption = "CAMBIO DE SELECCION" Height = 735 Left = 2640 TabIndex = 4 Top = 3240 Width = 2415 End Begin ListBox List1 Height = 1590 Left = 120 TabIndex = 3 Top = 3240 Width = 2175 End Begin FileListBox File1 Height = 2565 Left = 2640 TabIndex = 2 Top = 240 Width = 2535 End Begin DirListBox Dir1 Height = 2055 Left = 120 TabIndex = 1 Top = 720 Width = 2175 End Begin DriveListBox Drive1 Height = 315 Left = 120 TabIndex = 0 Top = 240 Width = 2175 End Begin Line Line6

BorderColor = &H00FF0000& BorderWidth = 3 X1 = 5160 X2 = 5160 Y1 = 3120 Y2 = 4920 End Begin Line Line5 BorderColor = &H00FF0000& BorderWidth = 3 X1 = 2520 X2 = 2520 Y1 = 3120 Y2 = 4920 End Begin Line Line4 BorderColor = &H00FF0000& BorderWidth = 3 X1 = 2520 X2 = 5160 Y1 = 4920 Y2 = 4920 End Begin Line Line2 BorderColor = &H00FF0000& BorderWidth = 3 X1 = 2520 X2 = 5160 Y1 = 3120 Y2 = 3120 End Begin Line Line3 BorderColor = &H000000FF& BorderWidth = 2 X1 = 120 X2 = 5160 Y1 = 5040 Y2 = 5040 End Begin Line Line1 BorderColor = &H000000FF& BorderWidth = 2 X1 = 120 X2 = 5160 Y1 = 3000 Y2 = 3000 End End Sub Command1_Click () Criterio$ = InputBox$("Introduzca el nuevo criterio de seleccin de ficheros:", "CAMBIO DE SELECCION", "*.*") File1.Pattern = Criterio$ End Sub Sub Command2_Click () End End Sub Sub Dir1_Change ()

File1.Path = Dir1.Path End Sub Sub Drive1_Change () Dir1.Path = Drive1.Drive

End Sub Sub File1_Click () List1.AddItem File1.List(File1.ListIndex) End Sub Sub Form_Load () Criterio$ = "*.*" End Sub

CAPTULO 13 CONTROL Y MANEJO DEL RATN 13.1.- INTRODUCCIN

La espectacular implantacin de los interfaces grficos en el mundo de la informtica ha modificado los hbitos y costumbres del usuario. Si hace tan solo unos pocos aos, los usuarios vean al ratn como un artilugio curioso y con un nombre simptico pero con escasa utilidad, en estos momentos se ha convertido en una herramienta no solo fundamental sino casi imprescindible. Pobres de muchos de nosotros si tuviramos que usar Windows mediante el teclado!. Actualmente, el ratn no es un accesorio adicional en un ordenador sino que es parte del ordenador en la misma medida que lo puede ser el teclado y presumiblemente, con el apogeo de los interfaces grficos y la programacin visual el ratn se convertir en el elemento ms usado del ordenador. Visual Basic como aplicacin Windows y como lenguaje de programacin visual que es, ofrece enormes posibilidades para el manejo de ratn. En este captulo vamos a ver qu sucesos estn asociados con el ratn, qu pasa cuando pulso un botn, qu es el cursor del ratn, dnde est localizado en cada instante y ver que el ratn puede realizar otras tareas importantes como el trazado de grficos. As que coloque sobre su alfombrilla ese pequeo artefacto con rabo y botones y preprese para ver las maravillas que Visual Basic puede hacer con l.

13.2.- SUCESOS ASOCIADOS AL RATN

Cualquier actividad que se realice con el ratn, produce inmediatamente un suceso. Existen varios sucesos asociados con el ratn: presionar una tecla, liberar una tecla previamente pulsada, mover el ratn y arrastre. El ltimo suceso se encuadra dentro del nombre ingls drag-and-drop y dada su especial importancia ser tratado en un apartado posterior. Los sucesos asociados al ratn son reconocidos por la mayor parte de los controles: forms, cuadros de imgenes, etiquetas, cuadros de listas, cuadros combinados y los controles para el manejo de ficheros. Los sucesos antes descritos se agrupan bajo los nombres MouseDown, MouseUp y MouseMove. Cuando el ratn est sobre alguna parte de un form que no contiene controles, sta reconoce un suceso. De la misma forma lo hace un control cuando el cursor del ratn est sobre l. Los sucesos de ratn tienen tres argumentos,

- Button: campo de bits cuyos tres bits ms significativos determinan el estado de los botones del ratn. - Shift: campo de bits cuyos tres bits ms significativos muestran el estado de las teclas SHIFT, CTRL y ALT. - X, Y: posicin del cursor del ratn respecto al sistema de coordenadas del objeto que recibe el suceso.

13.3.- POSICIONAMIENTO DE UN CONTROL MEDIANTE EL RATN

Supongamos que tenemos un control del tipo botn de comando situado en cualquier parte de un form. Puede ser interesante mover en tiempo de ejecucin dicho control a algn lugar de la pantalla. Para ello generamos un suceso tipo MouseDown y le pasamos los argumentos descritos anteriormente. El suceso MouseDown se produce cuando pulsamos alguno de los botones del ratn. Sub Form_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single) CmdButton.Move X,Y End Sub El mtodo Move mueve el control a la posicin especificada por X, Y.

Ejemplo Una vez ms, vamos a incluir un programa, MOUSE.MAK, que ir explicando desde un punto de vista prctico los conceptos tericos ms interesantes del captulo. Una de las rutinas que incorpora esta aplicacin (Fig. 13.1), permite posicionar en un lugar de la pantalla determinado por la pulsacin del ratn, un botn de comando. Dicho botn se ir desplazando por la ventana cada vez que pulsamos el ratn en diferentes puntos. As mismo, el programa visualiza las coordenadas de la posicin del ratn.

Fig. 13.1. Programa MOUSE.MAK. Posicionamiento de un control.

MICROSFT VISUAL BASIC VERSION 3.00

Begin Form Form2 Caption = "Mouse Move, Up , Down" Height = 4785 Left = 1650 LinkTopic = "Form2" ScaleHeight = 219 ScaleMode = 0 'User ScaleWidth = 294 Top = 1245 Width = 6000 Begin CommandButton Command1 Caption = "SALIR" Height = 615 Left = 840 TabIndex = 0 Top = 360 Width = 2655 End Begin Label Label2 Alignment = 2 'Center Height = 255 Left = 120 TabIndex = 2 Top = 3960 Width = 5535 End Begin Label Label1 Alignment = 2 'Center Height = 255 Left = 120 TabIndex = 1 Top = 3600 Width = 5535 End End Sub Command1_Click () End End Sub Sub Form_MouseDown (Button As Integer, Shift As Integer, X As Single, Y As Single) Select Case Shift Case 1 Tecla = " Shift " Case 2 Tecla = " Ctrl " Case 3 Tecla = " Shift + Ctrl " Case 4 Tecla = " Alt " Case 5 Tecla = " Shift + Alt " Case 6 Tecla = " Ctrl + Alt " Case 7

Tecla = " Shift + Ctrl + Alt " Case Else Tecla = " Ninguna " End Select

Select Case Button Case 0 Boton = "Ningun Boton" Case 1 Boton = "Boton Izquierdo" Case 2 Boton = "Boton Derecho" Case 3 Boton = "Botones Izquierdo y Derecho" Case 4 Boton = "Boton Central" Case 7 Boton = "Boton Izquierdo, Derecho y Central " End Select Label1.Caption = "Teclas Pulsadas: " + Tecla Label2.Caption = "Botones Pulsados: " + Boton Form2.Caption = "Mouse Down, " + "X=" + Str$(X) + ", Y=" + Str$(Y)

End Sub Sub Form_MouseMove (Button As Integer, Shift As Integer, X As Single, Y As Single) Select Case Shift Case 1 Tecla = " Shift " Case 2 Tecla = " Ctrl " Case 3 Tecla = " Shift + Ctrl " Case 4 Tecla = " Alt " Case 5 Tecla = " Shift + Alt " Case 6 Tecla = " Ctrl + Alt " Case 7 Tecla = " Shift + Ctrl + Alt " Case Else Tecla = " Ninguna " End Select

Select Case Button Case 0 Boton = "Ningun Boton" Case 1 Boton = "Boton Izquierdo" Case 2 Boton = "Boton Derecho" Case 3 Boton = "Botones Izquierdo y Derecho" Case 4 Boton = "Boton Central" Case 7

Boton = "Boton Izquierdo, Derecho y Central " End Select Label1.Caption = "Teclas Pulsadas: " + Tecla Label2.Caption = "Botones Pulsados: " + Boton Form2.Caption = "Mouse Move, " + "X=" + Str$(X) + ", Y=" + Str$(Y)

End Sub Sub Form_MouseUp (Button As Integer, Shift As Integer, X As Single, Y As Single) Select Case Shift Case 1 Tecla = " Shift " Case 2 Tecla = " Ctrl " Case 3 Tecla = " Shift + Ctrl " Case 4 Tecla = " Alt " Case 5 Tecla = " Shift + Alt " Case 6 Tecla = " Ctrl + Alt " Case 7 Tecla = " Shift + Ctrl + Alt " Case Else Tecla = " Ninguna " End Select

Select Case Button Case 0 Boton = "Ningun Boton" Case 1 Boton = "Boton Izquierdo" Case 2 Boton = "Boton Derecho" Case 3 Boton = "Botones Izquierdo y Derecho" Case 4 Boton = "Boton Central" Case 7 Boton = "Boton Izquierdo, Derecho y Central " End Select Label1.Caption = "Teclas Pulsadas: " + Tecla Label2.Caption = "Botones Pulsados: " + Boton Form2.Caption = "Mouse Up, " + "X=" + Str$(X) + ", Y=" + Str$(Y) Command1.Move X - (Command1.Width / 2), Y - (Command1.Height / 2) End Sub

13.4.- APLICACIONES GRFICAS DEL RATN

13.4.1.- GENERACIN DE LNEAS RECTAS

Como ya hemos visto en el captulo de grficos, Visual Basic dispone de un mtodo que permite el trazado de lneas y rectngulos sobre un objeto. Este mtodo es Line. Su sintaxis es [Objeto.]Line[[Step](x1, y1) - [Step](x2, y2)[,[color][, B[F]]] Objeto es el nombre del objeto sobre el que trazaremos la lnea, Step especifica el origen de coordenadas, x1,y1 coordenadas del punto de origen, Step ndica que las coordenadas del punto final de la lnea son relativas al punto de origen de esa lnea x2, y2 coordenadas del punto final, color es el color usado para trazar la lnea, B dibuja un rectngulo usando las coordenadas dadas como sus esquinas opuestas, F si se traza un rectngulo este parmetro permite determinar si su interior est relleno. Si por ejemplo escribimos la expresin [Line - (x2, y2)] lo que hace el programa es trazar una recta desde el ltimo punto trazado al punto de coordenadas (x2, y2). Cuando integramos esa expresin dentro de un procedimiento de suceso de ratn, cada vez que pulsamos una tecla de ratn se dibuja en pantalla una recta que conecta los puntos en que vamos haciendo click. Sub Form_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single) Line - (X, Y) End Sub Si en vez de usar un suceso como MouseDown utilizamos MouseMove, el mismo cdigo de programa me permite garabatear la pantalla con tan solo mover el ratn. Sabemos que MouseMove se genera cuando movemos el ratn, por tanto cada desplazamiento de ratn es procesado y se conecta mediante una lnea con la posicin previa del puntero de ratn.

Ejemplo Hacer una aplicacin que garabatee la ventana de dicha aplicacin. Esta rutina tambin pertenece al programa MOUSE.MAK. Es muy sencilla y hace uso de los trozos de cdigo que acabamos de comentar, concretamente del cdigo asociado al suceso MouseMove y el empleo del mtodo Line. Como pequeo truco, incorpora una variable denominada semforo que dependiendo de su valor activa o desactiva el trazado de lneas en pantalla. La salida de la aplicacin se muestra en la Fig. 13.2.

Fig. 13.2. Programa MOUSE.MAK. Trazado de lneas en la ventana.

El cdigo de esta aplicacin es muy sencillo y aparece a continuacin.

MICROSOFT VISUAL BASIC VERSION 3.00 Begin Form Form1 AutoRedraw = -1 'True Caption = "RATON.EXE" ForeColor = &H000000FF& Height = 3225 Left = 2010 LinkTopic = "Form1" ScaleHeight = 2820 ScaleWidth = 5610 Top = 1590 Width = 5730 End Dim Semaforo As Integer Sub Form_Click () If Semaforo = 1 Then Semaforo = 0 Me.Caption = "RATON.EXE: Dibujo OFF " Else Semaforo = 1 Me.Caption = "RATON.EXE: Dibujo ON " End If End Sub Sub Form_Load () Semaforo = 0 AnchoLinea = 1 End Sub Sub Form_MouseMove (Button As Integer, Shift As Integer, X As Single, Y As Single) If Semaforo = 1 Then Line -(X, Y) Else CurrentX = X CurrentY = Y End If End Sub

13.5.- ARGUMENTOS DE LOS SUCESOS DE RATN

Como hemos visto antes, los sucesos asociados al ratn disponan de tres argumentos. Uno era el X, Y que pasaba la posicin del ratn respecto al sistema de coordenadas del objeto que reciba el suceso, y por su sencillez no precisa mayores comentarios. Los parmetros que resultan ms interesantes de cara a tener una aplicacin ms eficiente son Button y Shift.

13.5.1.- ARGUMENTO BUTTON

Como ya hemos dicho antes, el argumento Button es un entero que representa el estado del ratn. Pertenece a los llamados campos de bits, esto es, un valor binario en el que cada bit representa un estado diferente. En el argumento Button los bits que tienen inters son los tres menos significativos, es decir, los tres que estn ms a la derecha.

Fig. 13.3. Mapa de bits representando el estado del ratn.

Como se puede ver en el grfico, cada bit representa un botn de ratn. Las pertinentes acciones que se realicen, dependern del evento al que nos estemos refiriendo. Por ejemplo, cuando utilicemos el evento MouseDown, el argumento Button nos indica el botn que hemos pulsado, mientras que si le incluimos en el evento MouseUp lo que nos indica es el botn que hemos liberado. En estos dos casos, se produce un cambio en un solo bit por evento. Supongamos que tenemos asignado a Button el valor decimal 1. Su correspondiente expresin binaria es 001 lo que indica que es el botn izquierdo el que ha provocado el evento. De la misma manera se pueden interpretar los valores 2 y 4 (010 y 100 en binario). Como todo el mundo sabe, existen en el mercado variedad de ratones y cada uno puede tener diferente nmero de pulsadores. Si tenemos un ratn con un solo pulsador, ste hace las veces del botn izquierdo. Si tiene dos pulsadores se correspondern a los botones izquierdo y derecho.

El evento MouseMove, indica el estado completo de los botones del ratn. La diferencia con los dos eventos anteriores estriba en que tanto con MouseDown como con MouseUp se indicaba el botn concreto que causaba el evento. En este caso, se indica el estado de todos. Segn se deduce de esto, se pueden activar a la vez ms de un bit del correspondiente argumento. Por ejemplo, si asignamos a Button el valor decimal 7 (111 en binario) estamos indicando que los tres botones del ratn han sido presionados a la vez. Lgicamente, para que el evento MouseMove tenga lugar, no basta con tener pulsados los botones, sino que se debe producir el movimiento del ratn. Es frecuente que necesitemos saber si un determinado botn est siendo presionado. Un pequeo truco para saber esto consiste en la utilizacin del operador lgico And.

Ejemplo: If Button And 1 Then Print "Usted ha pulsado el botn izquierdo" If (Button And 3)=3 Then Print "Usted ha pulsado los botones izquierdo y derecho a la vez" En estos ejemplos se han utilizado las constantes Button para comparar dos expresiones. En el primer caso se compara Button con 1 y si ambos son verdaderos desde un punto de vista lgico (ambos valen lo mismo) la expresin es verdadera. En el segundo caso el valor de Button se compara con 3. Este valor se obtiene de la suma de 1+2, lo que indica que se han pulsado a la vez los botones izquierdo y derecho.

13.5.2.- EL ARGUMENTO SHIFT

La forma de trabajar de este argumento es parecida a la de Button. Cuando se presiona la tecla SHIFT, el argumento Shift vale 1. Cuando se presiona CTRL Shift=2 y si se presiona ALT Shift=4. Esto hace suponer que Shift tambin se corresponde con un campo de bits, cuyos tres bits menos significativos corresponden al estado de las teclas SHIFT, CTRL y ALT.

Fig. 13.4. Mapa de bits mostrando el estado de las teclas CTRL, ALT y SHIFT.

Se pueden presentar combinaciones de estas teclas con lo que el valor de Shift adopta la suma de los valores correspondientes a cada tecla individual. As, si presionamos CTRL+ALT el valor de Shift ser 2+4=6 (110 en binario).

13.6.- DRAG AND DROP

El trmino ingls de "drag and drop", empieza a ser muy familiar entre los usuarios de los interfaces grficos. En concreto, la programacin en Windows y en los lenguajes de programacin visual hacen continuo uso de esta caracterstica. Visual Basic, por supuesto, tambin incorpora esta propiedad. Hasta ahora, la hemos utilizado especialmente en tiempo de diseo cuando queramos mover un control sobre un determinado form. Cuando pulsamos una tecla de ratn sobre un control y movemos el ratn mantenindola pulsada estamos haciendo el proceso de "dragging". El "dropping" consiste en la accin de soltar o liberar esa tecla de ratn que tenamos pulsada. Vamos a empezar a utilizar el "drag and drop" no solo en tiempo de diseo sino tambin en tiempo de ejecucin, incorporndolo a nuestra aplicacin escrita en Visual Basic.

13.6.1.- PROPIEDADES Y EVENTOS ASOCIADOS AL DRAG AND DROP

Visual Basic dispone de varias propiedades, eventos y mtodos para controlar estas acciones. En primer lugar estn las propiedades DragMode y DragIcon. La primera propiedad habilita un arrastre manual o automtico de un determinado control. La segunda, es ms espectacular y permite determinar el dibujito que aparece en pantalla cuando efectuamos una operacin de arrastre. Por otro lado, tenemos otros dos eventos que se asocian a estos procesos. El primero de ellos se llama DragDrop y se produce cuando liberamos un control sobre un determinado objeto. Por ejemplo, se produce cuando soltamos la tecla de ratn que arrastraba un control para colocarlo sobre una determinada form. El otro evento, llamado DragOver se produce cuando arrastramos un control sobre un objeto. Por ltimo, disponemos tambin de un mtodo llamado Drag, que comienza o acaba un arrastre manual. Todos los controles, a excepcin de los mens y los timers pueden utilizar las anteriores propiedades y pueden incorporalas en tiempo de ejecucin. Las forms, reconocen los eventos descritos pero no las propiedades.

13.6.2.- ARRASTRE AUTOMTICO DE UN CONTROL

Es insultantemente sencillo el asignar a un control las caractersticas de drag and drop, hasta el punto que casi desmerecen la enorme potencia de esta utilidad. La forma de asignar a un control el drag and drop consiste en poner la propiedad DragMode = 1 para ese control. Cuando un control est siendo arrastrado, mediante un arrastre automtico, no reconoce ningn otro evento de ratn.

13.6.3.- HAGMOSLO BONITO. PROPIEDAD DRAGICON

Windows, y tambin Visual Basic, presentan por defecto un borde gris al arrastrar un determinado objeto o control. Supongamos que estamos moviendo un determinado icono o control. Cuando se produce la operacin de arrastre, el objeto en cuestin pierde su esttica y se trasforma en una imagen gris y menos vistosa. Como no poda ser de otra manera, Visual Basic permite elegir el dibujo que aparece en pantalla mientras estamos realizando una operacin de arrastre. El elemento que permite tal desfachatez es la propiedad DragIcon. Como suele ocurrir con el resto de propiedades, es posible especificar su valor tanto en tiempo de diseo como en tiempo de ejecucin. En tiempo de diseo debemos recurrir a la ventana de propiedades, seleccionar esta propiedad y especificar el nombre del fichero que contiene el grfico que queremos visualizar cuando arrastremos el icono. Ya sabemos que Visual Basic dispone de una extensa librera de iconos, contenidos en el directorio \icons, y que pueden incorporarse como imagen. La especificacin de esta propiedad en tiempo de ejecucin, puede hacerse de varias maneras, aunque la ms intuitiva consiste en asignar una imagen cargada con la funcin LoadPicture: Ejemplo: Image1.DragIcon=LoadPicture("C:\VB\ICONS\FICHERO.ICO")

Ejemplo Otra de las rutinas que incorpora el programa MOUSE.MAK hace referencia precisamente al punto que estamos comentando. La aplicacin presenta dos cajas de listas con ficheros. Inicialmente la caja de la izquierda contiene los ficheros del directorio actual, mientras que la de la derecha est vaca.

Se trata de construir un programa que arrastre mediante ratn los ficheros de la caja de la izquierda y copie su nombre en la caja de la derecha. La dificultad aadida consiste en hacer que durante el proceso de arrastre aparezca un determinado icono. El diseo del interface es muy sencillo. Se trata de una ventana etiquetada con las palabras Drag & Drop, una caja de listas de ficheros y una caja de listas, separadas por una lnea recta (control Line). Un botn de comando nos permite abandonar la aplicacin. El cdigo que lleva aparejado es muy sencillo y tan solo se trata de aadir al procedimiento del evento DragDrop la propiedad AddItem de las cajas de lista para que vaya aadiendo los ficheros que arrastramos. En la propiedad DragIcon incluimos el nombre del fichero de icono que vamos a visualizar en el arrastre, en nuestro caso una calculadora. La Fig. 13.5 nos muestra el interface de esta aplicacin.

Fig. 13.5. Programa MOUSE:MAK. Interface de usuario.

MICROSOFT VISUAL BASIC VERSION 3.00 Begin Form Form3 BackColor = &H00C0C0C0& Caption = "Drag &Drop" Height = 4470 Left = 1710 LinkTopic = "Form3" ScaleHeight = 4065 ScaleWidth = 5700 Top = 1140 Width = 5820 Begin CommandButton Command1 Caption = "SALIR" Height = 495 Left = 1440 TabIndex = 2

Top = 3360 Width = 2655 End Begin ListBox List1 Height = 2565 Left = 3000 TabIndex = 1 Top = 480 Width = 2295 End Begin FileListBox File1 DragIcon = RATON3.FRX:0000 Height = 2565 Left = 480 TabIndex = 0 Top = 480 Width = 2055 End Begin Line Line1 BorderColor = &H000000FF& BorderWidth = 2 X1 = 2760 X2 = 2760 Y1 = 240 Y2 = 3240 End End Sub Command1_Click () END End Sub Sub File1_MouseDown (Button As Integer, Shift As Integer, X As Single, Y As Single) File1.Drag 1 End Sub Sub File1_MouseUp (Button As Integer, Shift As Integer, X As Single, Y As Single) File1.Drag 2 End Sub Sub List1_DragDrop (Source As Control, X As Single, Y As Single) List1.AddItem File1.List(File1.ListIndex) End Sub

13.6.4.- EVENTO DRAGDROP

Este evento se produce cuando se libera una tecla de ratn despus de que la hemos tenido pulsada durante la operacin de arrastre. Supongamos que quiero pasar un determinado control de una form a otra. Para ello, coloco el puntero de ratn sobre l, pulso el botn izquierdo y arrastro el control hasta la posicin deseada, pero sin soltar el botn. Cuando hayamos alcanzado la posicin destino podemos soltar el botn para que el control quede definitivamente situado.

En este proceso, se invoca al evento DragDrop, dentro del cual intervienen tres argumentos: Source, X, Y. Los dos ltimos notifican las coordenadas del lugar en que soltamos el ratn, mientras que Source hace referencia al control que hemos liberado sobre una determinada regin de la pantalla. La expresin para este evento es: Sub Form_DragDrop(Source As Control, X As Single, Y As Single) End Sub

13.6.5.- CONTROL MANUAL DEL ARRASTRE

Como hemos visto hace un momento, la propiedad DragMode permita elegir entre un control manual o automtico del proceso de arrastre. Cuando esta propiedad se pone en modo manual, podemos ejercer un control ms exhaustivo sobre los procesos de Drag & Drop. Con DragMode=Manual, podemos especificar cuando quiero que un determinado control pueda ser arrastrado y cuando no, cosa que en modo automtico no poda elegir, puesto que siempre estaba activada esa posibilidad. La forma de trabajar con esta propiedad consiste en fijar su valor a 0-Manual, y utilizar en el cdigo de la aplicacin el mtodo Drag. Este mtodo sigue la siguiente sintaxis: [nombre_del_control.]Dragaccin El valor que permite controlar el proceso viene puesto en accin. Cuando accin vale 0, se cancela el arrastre, se habilita si vale 1 y si vale 2 el control se libera produciendo un evento del tipo DragDrop. Ejemplo: CtlName.Drag 1 CtlName.Drag 2 (habilita el arrastre para el control CtlName) (libera el control al igual que ocurrira al soltar el botn del ratn)

13.6.6.- POSICIONAMIENTO DE UN CONTROL MEDIANTE RATN

Es frecuente a la hora de trabajar con el Drag & Drop, que arrastremos un determinado control para colocarlo en otra posicin de la pantalla. Lo que queremos es moverlo manteniendo pulsado el botn izquierdo del ratn, situarlo sobre la nueva posicin y que al soltar el botn ese control quede colocado sobre esa nueva posicin. El mtodo Move ser el encargado de hacer esa misin. Este mtodo adopta las coordenadas X,Y del evento DragDrop y sita la esquina superior izquierda del control en la posicin del ratn.

Sub Form_DragDrop(Source As Control, X As Single, Y As Single) Souce.Move X,Y End Sub

CAPTULO 14 EL DEBUGGER 14.1.- INTRODUCCIN

Definiremos en primer lugar el trmino "bug" como cualquier error en nuestro cdigo de programa, que impida su correcto funcionamiento y que por su naturaleza tenga grandes posibilidades de pasar inadvertido para el programador. Por lo tanto, la tcnica del Debugging es simplemente aquella que nos facilita el encontrar dichos bugs lo antes posible. Visual Basic como entorno completo de programacin, provee una serie de utilidades que nos facilitarn la ardua tarea de fijar y corregir los errores que se encuentran dispersos en nuestro cdigo. Adems la potencia de dichas herramientas puede ser aprovechada para experimentar con cambios en los valores de variables y propiedades as como para analizar el flujo de ejecucin de nuestras aplicaciones.

14.2.- LA TCNICA DEL DEBUGGING

Imaginemos un pequeo programa que calcule el factorial de N, pero que nos de resultados increibles o que simplemente deje colgado nuestro ordenador al introducir valores de N que sobrepasen un valor determinado o cuando dichos valores fueran negativos. Incluso se podra complicar cuando nuestro programa trabajara perfectamente excepto para dos valores tan concretos como por ejemplo N=7 y N=39. Este problema pudiera estar localizado en la rutinas de tratamiento de los valores introducidos por el usuario o bien pudiera encontrarse en la definicin del algoritmo de factorizacin o en la limitada capacidad del tipo de variables escogidas o en el peor de los casos por que nos hemos topado con un bug del propio compilador, lo que a buen seguro habra acabado con la paciencia del ms sufrido programador. Si a este pequeo ejemplo le aumentamos la complejidad hasta llegar a los desarrollos profesionales podemos ver la necesidad de las tcnicas de Debugging . Cuando un programa crece en complejidad, aumenta lnealmente la posibilidad de error y geomtricamente la dificultad de deteccin de dicho error. Hay que mencionar que en el mercado de la informtica profesional, existen DEBUGGERS, que son un producto separado o acompaando a un compilador determinado (CODE VIEW; TURBO DEBUGGER; PERISCOPE DEBUGGER) pero que como tales no ofrecen inters, pues no pueden ser usados desde Visual Basic, tan slo son utilizados para lenguajes compilados (C, C+ +, PASCAL, ASSEMBLER).

Cualquier plataforma de desarrollo, incluye una serie de facilidades para la deteccin de errores, digamos que llevan un pequeo debugger en su interior (versin limitada de los debuggers profesionales). Visual Basic cuenta con una serie de herramientas que iremos comentando en este captulo y que se encuentran agrupadas bajo el men Debug. Hay que mencionar que se encuentran cas al mismo nivel de las herramientas que podemos encontrar en otras plataformas de desarrollo, como puede ser Microsoft C++ 7.0. En los lenguajes interpretados la tcnica del Debugging tiene una sencilla implementacin, pues baste recordar que cada lnea es interpretada y ejecutada inmediatamente, siendo ms sencillo la deteccin de los errores. Podemos equiparar las facilidades del Debugging de Visual Basic a facilidades de anlisis. Esta ambivalencia viene dada al aplicar estas facilidades al cdigo que est exento de errores y que nos permitir la observacin de su ejecucin lneal haciendo ms comprensible y facilitando la depuracin final de zonas crticas de nuestras aplicaciones. Entre el soporte que ofrece Visual Basic a las facilidades de Debugging podemos destacar: breakpoints, break expressions, watch expressions, single stepping, procedure stepping as como la visualizacin y/o edicin de los valores de las variables y propiedades.

14.3.- LOS ERRORES Y SUS CLASES

Vamos a definir las tres clases de errores que podemos tipificar dentro del proceso de desarrollo de programas: Errores de Compilacin: estos errores estn ntimamente relacionados con los defectos de construccin de cdigo. Por ejemplo, podemos escribir Wihle Do en lugar de While Do, omitir algn signo de puntuacin necesario u omitir palabras claves dentro de una determinada construccin de flujo, por ejemplo, al usar una sentencia Next sin su correspondiente For. Dentro de los errores de compilacin podemos incluir tambin los errores sintcticos. Por ejemplo, si escribimos Form1.Icon, Visual Basic nos informar que falta un signo igual y un valor con una ruta determinada para definir la localizacin del icono del Form1. Visual Basic detecta automticamente los errores sintcticos, cuando los escribimos en la ventana de cdigo, si previamente hemos validado la opcin Syntax Checking bajo el men principal Options dentro del submen Environment .. . Errores en Tiempo de Ejecucin: los errores en tiempo de ejecucin ocurren y son detectados por Visual Basic cuando una sentencia ejecuta una operacin imposible. Por ejemplo, una divisin por cero (tcnicamente hablando, se produce una excepcin en el microprocesador y Visual Basic es informado que se ha intentado dividir cualquier valor por cero). Como podrs adivinar, podemos tener una sentencia sintcticamente correcta que slo en tiempo de ejecucin y gracias a una errnea entrada del usuario, puede acarrear un error: Sub Ejemplo ()

TamaoHabitacin = Val ( Text1.Text ) NumeroPersonas = Val ( Text2.Text ) Habitaciones = TamaoHabitacin / NumeroPersonas End Sub El usuario, inadvertidamente puede insertar en la caja de texto Text1, el valor cero, lo que causara una divisin por cero, y por tanto un error en tiempo de ejecucin. Para evitar este error, debemos incluir en nuestro cdigo una rutina que atrape y maneje estos errores. Errores Lgicos o "Bugs": son los que ocurren cuando una aplicacin no realiza correctamente la tarea para la que ha sido diseada, es decir, no tiene errores sintcticos, ni realiza operaciones invlidas que puedan producir errores en tiempo de ejecucin, sin embargo todava produce resultados incorrectos. A veces, los errores lgicos se producen por la incomprensin de cmo se ejecutan las sentencias propias de Visual Basic. As por ejemplo, inadvertidamente es posible codificar la siguiente sentencia "SELECT CASE" que contiene un rango de argumentos invlido: SELECT CASE X CASE -1 TO -5 CalcularAlgo ( X ) ..... ..... Esta sentencia sintcticamente es correcta, pero el cdigo que le sigue nunca ser ejecutado, pues el rango debe ser expresado desde su lmite inferior a su lmite superior. Para que dicho cdigo sea vlido el rango debera ser " -5 to -1 ". Otro error lgico lo podemos encontrar en el siguiente ejemplo: FOR X X= -1 to -5 ..... .... NEXT XX El cdigo interior nunca ser ejecutado ya que al no haber especificado la palabra clave "STEP", seguida de un entero, el valor del paso ser por defecto igual a 1, pero el valor del paso necesario sera -1. El cdigo correcto sera : FOR XX=-1 to -5 STEP -1 .... .... NEXT XX

14.4.- TIEMPO DE DISEO, TIEMPO DE EJECUCIN, MODO DE RUPTURA (BREAK MODE)

Dentro del desarrollo de un programa bajo Visual Basic podemos diferenciar 3 etapas a saber: Tiempo de Diseo: durante esta etapa se produce el diseo en si de nuestra aplicacin. Podemos disear Forms, dibujar controles, escribir cdigo y ajustar las propiedades de cada objeto que participa en nuestro diseo. Hay que decir que aunque muchas veces se solape con esta etapa, existe otra que por lo general permanece olvidada, el anlisis del diseo. Durante el tiempo de diseo, no es posible el uso de las herramientas del debugger ni la ejecucin de nuestro cdigo, tan slo es posible la validacin de puntos de ruptura Break Points y la creacin de expresiones espa Watch Expresions. Tiempo de Ejecucin: se produce cuando nuestra aplicacin toma el control y nos permite interactuar con ella como si se tratara del usuario final. El cdigo puede ser visto pero no cambiado o alterado. Break Mode: estamos en modo de ruptura cuando se produce la suspensin de la ejecucin de nuestra aplicacin y podemos ver y/o editar el cdigo, as como examinar y editar los datos. Tambin es posible rearrancar la aplicacin, terminar o continuar la ejecucin desde el mismo punto. Podemos identificar el modo en el que nos encontramos, tan slo con echar un vistazo a la barra de ttulode la ventana principal de Visual Basic, donde podemos encontrar encerrado entre corchetes el modo en el que se encuentra nuestro sistema .

14.4.1.- UTILIZANDO EL MODO DE RUPTURA

Como ya hemos visto, en tiempo de diseo slo es posible cambiar el cdigo, pero no podemos observar la manera en que dichos cambios modificarn el comportamiento de nuestra aplicacin cuando esta se ejecute. Por el contrario, en tiempo de ejecucin tan slo podremos comprobar el comportamiento exacto de nuestra aplicacin, sin poder realizar ningn cambio. El modo de ruptura (Break Mode) suspende la ejecucin de nuestro programa en cualquier momento y nos ofrece una instantnea de nuestra aplicacin permitindonos explorar el estado y valor de variables, propiedades, estructuras de control, etc. Cuando nuestra aplicacin se encuentra en Break Mode es posible: - Determinar qu procedimientos han sido llamados y se estn ejecutando. - Ver el contenido de variables propiedades y sentencias.

- Cambiar el valor de propiedades y variables. - Ejecutar sentencias Visual Basic inmediatamente. - Modificar cdigo en nuestra aplicacin. - Controlar manualmente la ejecucin de nuestra aplicacin.

Como puedes observar las posibilidades que nos ofrece el modo de ruptura son aprovechadas en la tcnica del Debugging. De hecho el modo de ruptura viene impuesto por la creacin de dicha tcnica. En este modo podemos entrar de dos formas diferentes: Manualmente: Cuando presionamos CRTL+BREAK, cuando seleccionamos Break del men Run o cuando escogemos el botn Break de la barra de herramientas del Visual Basic. Automticamente : Cuando la ejecucin de nuestro programa genera un error en tiempo de ejecucin, cuando la ejecucin alcanza un punto de ruptura previamente habilitado por el desarrollador, o simplemente cuando la ejecucin alcanza una sentencia Stop. Cuando se produce un error en tiempo de ejecucin y entramos en modo de ruptura podemos corregirlo y continuar la ejecucin simplemente seleccionando Continue del men Run o seleccionando el icono Run de la barra de herramientas. Si se producen cambios en la declaracin de variables o si aadimos variables, Visual Basic nos indicar que se debe rearrancar la aplicacin desde el comienzo para que los cambios tengan efecto.

14.5.- PUNTOS DE RUPTURA (BREAK POINTS)

Un punto de ruptura, es una lnea del cdigo que el programador ha validado o marcado para interrunpir la ejecucin normal del programa. Debemos usar los puntos de ruptura en partes de nuestro cdigo, en las que sospechamos que puede ocurrir una ejecucin anormal del cdigo. Cuando la ejecucin de nuestro programa alcanza un punto de ruptura, esta se detiene y entra en modo de ruptura, permitindonos utilizar todas las herramientas del debugger. Para poder marcar o borrar un punto de ruptura, primero deberemos buscar en la ventana de cdigo la lnea en la que queramos situar/borrar el punto de ruptura y desde el men Debug escoger la opcin Toggle Breakpoint o simplemente podemos presionar F9 o escoger el icono BreakPoint de la barra de herramientas del Visual Basic. Cuando marcamos un punto de ruptura, dicha lnea aparece sobreiluminada para destacar su existencia.

Cuando nuestra aplicacin ha alcanzado un punto de ruptura la ejecucin es suspendida y esto posibilita que podamos observar el estado ntegro de nuestra aplicacin. Hay que mencionar que cuando se alcanza un punto de ruptura, la ejecucin se suspende en la lnea inmediatamente anterior a la lnea donde se ha definido el punto de ruptura. Si queremos observar la ejecucin de la lnea que lo contiene, debemos ejecutar la siguiente lnea con la facilidad de ejecucin paso a paso que se provee bajo el men de Debug y que posteriormente comentaremos. Como ya vimos anteriormente podemos utilizar la sentencia Stop como alternativa a los puntos de ruptura, pues sus consecuencias son iguales. La diferencia radica en que la sentencia Stop forma parte del cdigo fuente de nuestra aplicacin y como tal es susceptible de ser grabado, mientras que cuando grabamos nuestra aplicacin con puntos de ruptura ya definidos estos se perdern. Podemos definir a la sentencia Stop como puntos de ruptura permanentes, susceptibles de ser conservados en el cdigo fuente.

14.6.- EJECUCIN ARBITRARIA DE CDIGO

Es posible identificar la sentencia causante de un error con la ayuda de un punto de ruptura, pero generalmente slo nos indicar el rea de cdigo que tenemos que aislar, culpable de dicho error. Cuando conocemos el rea, en la que presumiblemente puede estar localizado el error, podemos utilizar una facilidad adicional que nos permitir ejecutar paso a paso cada lnea o cada procedimiento permitindonos fijar rpidamente el error. Ejecucin paso a paso de sentencias "Single Stepping": esta facilidad nos permite ejecutar las sentencias lnealmente y de una en una, permitindonos ver los efectos laterales de dicha ejecucin en los Forms de nuestra aplicacin o en la ventana de Debug. Para utilizar esta tcnica, tan slo basta con seleccionar la opcin Single Step del men Debugg, seleccionar el icono Single Stepping de la barra de herramientas de Visual Basic o presionar F8. Durante la ejecucin de esta facilidad, Visual Basic cambia continuamente a tiempo de ejecucin para que se ejecute la sentencia indicada y vuelve a Break Mode. Visual Basic nos indica en todo momento cual es la sentencia que se est ejecutando, pues la encierra en un recuadro en la ventana de cdigo. Ejecucin paso a paso de procedimientos "Procedure Stepping": idntico al anterior, pero se diferencia en que cuando la sentencia en curso, hace una llamada a un procedimiento, este se ejecuta en su totalidad y no paso a paso. Esto es muy til cuando tenemos una serie de procedimientos libres de error y testeados perfectamente.

Imaginemos que nuestra sentencia actual hace una llamada a una funcin encargada de presentar una caja de dilogo determinada, y que dicha funcin ha sido perfectamente testeada. Sera muy tedioso el tener que ejecutarla paso a paso, si tenemos la absoluta certeza que esta libre de errores. Para utilizar esta tcnica tan slo basta con seleccionar la opcin Procedure Step del men Debugg, seleccionar el icono Procedure Stepping de la barra de herramientas de Visual Basic o presionar SHIFT + F8. Dentro de las facilidades que Visual Basic ofrece para el Debugging o depuracin del cdigo, podemos destacar, la que nos permite escoger cual ser la siguiente lnea a ejecutar dentro de un mismo procedimiento. Esta facilidad es similar al Single Step (que slo permite ejecutar la sentencia inmediatamente siguiente) con la diferencia que nos es posible especificar cual va a ser la siguiente sentencia ejecutada (podemos escoger la siguiente sentencia delante o detrs de la que ha sido ejecutada actualmente). Para utilizar esta facilidad tan slo tenemos que mover nuestro punto de insercin a la sentencia que nosotros queramos ejecutar y seleccionar del men Debug la opcin Set Next Statement y reanudar la ejecucin de nuestro programa con seleccin del la opcin Continue del men Run.

14.7.- VENTANA "CALLS"

En la ventana Calls aparece informacin relativa a todas aquellas llamadas a procedimientos activos, es decir, procedimientos que en el momento en el que la aplicacin se encuentra en Break Mode, han comenzado pero que an no han concluido. En dicha ventana se muestra el mdulo propietario de dicho procedimiento, y el nombre del procedimiento en cuestin. Esta facilidad es muy til para observar el comportamiento en la ejecucin de procedimientos anidados. Para llamar a esta ventana tan slo tenemos que poner a nuestra aplicacin en Break Mode y seleccionar Calls.. del men Debug o seleccionar el icono Calls.. de la barra de herramientas de Visual Basic o presionar CRTL+L. Podemos realizar un seguimiento de los procedimientos anidados que nos muestra la ventana Calls. En dicha ventana figura una lista de todos los procedimientos activos. Hay que mencionar que no figura informacin sobre variables asgnadas a alguna instancia de la Form en curso, por lo tanto no nos es posible distingir, mediante la informacin que nos ofrece dicha ventana , entre mtiples instancias. Podemos utilizar el botn Show correspondiente a esta ventana para que nos muestre el cdigo del procedimiento que nosotros previamente hubiramos desarrollado.

Ejemplo

Al final del captulo se adjunta el cdigo del programa TEXT.EXE, para que puedas verificar el uso de la ventana Call y el tratamiento de procedimientos anidados. Tan slo tienes que ejecutar el programa y apretar el botn etiquetado como TEST. Cuando lo hayas hecho estars en Break Mode. Presiona CRTL+L y vers la ventana con la informacin sobre los 3 procedimientos anidados. Puedes seleccionar cualquiera de ellos con el ratn y posteriormente presionar el botn Show para poder observar el cdigo asociado al procedimiento seleccionado.

14.8.- EXPRESIONES "WATCH"

Definimos las expresiones Watch o expresiones espa como todas las expresiones que definimos explcitamente como tal en nuestro cdigo y que cuando nos encontremos en Break Mode nos mostrarn el valor de sus contenidos en la ventana Debug. As podremos observar fcilmente sus valores y si son los correctos. Hay que decir que podemos indicar a Visual Basic que cuando determinada expresin Watch alcance o sobrepase un valor determinado ponga nuestra aplicacin en Break Mode. Por ejemplo, es posible que automticamente nuestra aplicacin entre en Break Mode cuando el contenido del contador de una sentencia For - Next alcance un determinado valor.

14.8.1.- AADIENDO EXPRESIONES WATCH

Existe la posibilidad de aadir expresiones Watch durante el tiempo de diseo o durante el Break Mode. Para crear las expresiones Watch empleamos la caja de dilogo Add Watch a la que se llama desde la opcin Add Watch del men Debug. En la Fig. 14.1 podemos ver el detalle de dicha caja de dilogo.

Fig. 14.1. Caja de dilogo Add Watch.

Colocaremos en el cuadro de texto correspondiente, el nombre de la expresin que queramos aadir. Esta expresin puede ser una variable, una propiedad o cualquier funcin de nuestro cdigo. Dentro del grupo de opcines etiquetado Context fijaremos el mbito de la expresin, que como podemos observar puede estar limitado a un determinado procedimiento, a un Form, a un Mdulo determinado o ser global a toda la aplicacin.

Dentro del grupo de opcines etiquetado Watch Type fijaremos la forma de tratamiento que Visual Basic dara a la expresin Watch recien creada. Cuando seleccionemos Watch Expression, Visual Basic mostrar el valor de dicha expresin en la ventana Debug cuando nuestro pograma se encuentre en Break Mode. Cuando seleccionemos Break when Expression is True, Visual Basic automticamente generar un Break Mode si la expresin en cuestin alcanza un valor verdadero (valor distinto de cero). Similarmente si seleccionamos Break when Expression has Changed, Visual Basic pasar a Break Mode cada vez que el valor de la expresin Watch cambie. Como podemos ver el uso y la utilidad de las expresiones Watch en muy grande, y con un empleo inteligente de dicha facilidad es relativamente sencillo la eliminacin de los bugs en nuestros programas.

14.8.2.- EDICIN Y ELIMINACIN DE EXPRESIONES WATCH

Visual Basic nos ofrece las facilidades de edicin y borrado de expresiones Watch. Para acceder a estas facilidades tan slo debemos escoger la opcin Edit Watch del men Debug. Aparecer el cuadro de dilogo Watch que nos permitira la edicin e insercin de cualquier expresin Watch, as como la posibilidad de eliminacin de cualquier expresin o la eliminacin del conjunto de todas las expresiones Watch. La figura siguiente (Fig. 14.2), nos ofrece una aclaracin visual de dicha caja de dilogo. Como apreciars el uso de todas las opcines mencionadas anteriormente es muy intuitivo y se hace innecesaria cualquier explicacin adicional.

Fig. 14.2. Ventana de edicin de expresiones Watch.

14.8.3.- EXPRESIONES WATCH INSTANTANEAS

Tambin es posible aadir expresiones Watch instantaneas, lo que nos permitir chequear el valor de cualquier variable, propiedad o funcin en un determinado momento. Para esto, tan slo es necesario encontrarnos en Break Mode, seleccionar la expresin que se quiere visionar y seleccionar la opcin Instant Watch del men Debug o en su defecto usar la combinacin rpida Shift + F9.

14.9. LA VENTANA DEBUG

Esta ventana aparece slo cuando nuestra aplicacin se encuentra en Break Mode y nos permite ver el contenido de expresiones mientras se va ejecutando paso a paso nuestro programa. Es posible cambiar el contenido de cualquier variable o propiedad desde dicha ventana, lo que nos permitir una mejor comprensin de la forma en que el cdigo de nuestro programa se comporta, bajo determinadas circustancias. En esta ventana: podemos diferenciar claramente dos partes. Zona inmediata o Immediate Pane: muestra la informacin relativa al proceso de Debug. Es posible tambin el requerir informacin del sistema al teclear comandos en esta zona. Tenemos que decir que esta zona intermedia es la sucesora del la ventana Inmediate Window de Visual Basic 1.0. Zona Watch o Watch Pane: tan slo nos muestra las expresiones Watch en uso. Si realizamos un doble click sobre cualquiera de las expresiones Watch, se nos mostrar la caja de dilogo Edit Watch ya comentada anteriormente. En el ttulo de esta ventana figura el Form o mdulo activo as como el procedimiento activo al entrar en Break Mode.

14.9.1.- MOSTRANDO INFORMACIN EN LA ZONA INMEDIATA "INMEDIATE PANE" Podemos mostrar informacin relativa al contenido de variables, propiedades y funciones en la zona inmediata de dos formas diferentes: Forma indirecta: incluyendo el mtodo Print en el cdigo de nuestra aplicacin. El uso de mtodos nos ofrece como gran ventaja sobre el uso de expresiones Watch que no necesita entrar en Break Mode para poder mostrar el valor de las expresiones especificadas. Para utilizar este mtodo tan slo debemos incluir: Debug.Print expresin, expresion. El siguiente ejemplo nos mostrara el ancho y largo de Form1 en la zona intermedia sin necesidad de entrar en Break Mode: Debug.Print Form1.Height , Form1.Width Forma Directa: es posible forzar la impresin de los valores de las expresiones cuando estamos en Break Mode desde la zona inmediata Immediate Pane de la ventana Debug. Para lograr esto, slo es necesario introducir la sentencia Print seguida de la expresin a evaluar y presionar Enter. Inmediatamente Visual Basic mostrar en la siguiente lnea el valor de la expresin solicitada. Hay que mencionar que podemos utilizar el signo de interrogacin como sustituto de la sentencia Print.

14.9.2.- ASIGNACIN DE VALORES A VARIABLES Y PROPIEDADES

Desde la zona inmediata de la ventana Debug podemos asignar nuevos valores a variables y propiedades cuando nuestra aplicacin se encuentre en Break Mode. Tan slo debemos introducir la variable o propiedad deseada seguida de su nuevo valor y presionar Enter para que el cambio tenga efecto cuando entremos de nuevo en tiempo de ejecucin. No hay que olvidar que tenemos que referenciar totalmente las variables y propiedades. As pues referenciaremos a las propiedades con el objeto y con la Form a que pertenecen, para que dichos cambios tengan lugar. El siguiente ejemplo cambia los valores de una serie de propiedades: Form1.Height = 500 Form1.Width = 500 Form2.MaxButton = -1 Form2.MinButton = -1

14.9.3.- TESTEO DE FUNCIONES

Al igual que ocurra en la versin 1.0 de Visual Basic, la zona inmediata puede evaluar cualquier sentencia de Visual Basic pero sin aceptar la definicin o redefinicin de datos. Por tanto es posible llamar a funciones o procedimientos para evaluarlos. Si queremos evaluar cualquier procedimiento, tan slo tenemos que introducirlo en la zona inmediata de la ventana Debug y pulsar Enter. El siguiente ejemplo comprueba el perfecto funcionamiento del evento DragOver con unos determinados parmetros. Picture1_DragOver ( Button1 , 100, 100, 0 ) Si Option Explicit (obliga a la declaracin explcita de todas la variables) est habilitada, todas las variables que introduzcas en la zona inmediata de la ventana Debug deben estar declaradas dentro del mbito en el que se ha suspendido la ejecucin del programa. Siempre puedes llamar a cualquier procedimiento de un mdulo a menos que dicho procedimiento haya sido declarado como Private, en cuyo caso, slo puedes llamar a ese procedimiento si la ejecucin se encuentra en dicho mdulo.

14.10.- MANEJO DE ERRORES

Ya vimos anteriormente todas las clases de errores y la tcnica del debug, pero vamos a intentar codificar rutinas que nos permitan evitar errores en tiempo de ejecucin.

Imagnate la rutina de una aplicacin encargada de instalar una serie de ficheros desde la unidad A y cuya nica funcin es pedir el nombre de una unidad y de un directorio al usuario. Si ese directorio no existe, lo crea y despus copia una serie de ficheros a ese directorio. Cuando el usuario inserte el nombre de la unidad y del directorio pueden ocurrir varias cosas: A. - que la unidad especificada no exista. B. - que tal directorio no exista y haya que crearlo. C. - que ese directorio exista y haya que informar al usuario. Posteriormente el programa copiar toda una serie de ficheros a ese directorio. Pero imaginemos por un momento que el usuario se ha olvidado cerrar la disquetera. Como te podrs imaginar si intentamos acceder a una unidad que no existe, se producir un error, al igual que si intentamos acceder a un directorio inexistente o a una unidad de disquete que no est correctamente cerrada. Si nuestro programa de instalacin no contiene una serie de rutinas de manejo de errores, posiblemente tendra asegurado un completo fracaso en el mundo del usuario despistado. Inmediatamente vamos a crear esta pequea aplicacin INSTALA.EXE donde veremos el diseo de rutinas de manejo de errores.

14.10.1.- SENTENCIA ON ERROR GOTO

Esta sentencia activa la rutina de manejo de errores, especifica la localizacin de dicha rutina en el procedimiento y puede ser usada para desactivar una rutina de manejo de errores. Su sintaxis es la siguiente: On Error { Go To line | Resume Next | Goto 0 } Como vemos On Error tiene varias opcines : GoTo Line: nos indica el nmero de lnea o etiqueta de lnea (cualquier cadena de caracteres que termina con :, por ejemplo RutinaError:) donde comenzar la rutina de manejo de errores. El control se bifurcar a la citada lnea o etiqueta de lnea. La rutina de manejo de errores debe residir en el mismo procedimiento en el que se ha definido la sentencia On Eror. Resume Next: especifica que cuando ocurre un error en tiempo de ejecucin, el control es devuelto a la sentencia imediatamente siguiente a la que produjo el error. Go To 0: desconecta cualquier rutina de manejo de errores en el procedimiento en curso. Cuando el manejador de errores est habilitado (On Errror ..) cualquier error causar que el flujo de control del programa sea redirigido a la rutina de manejo de errores. Este manejador de

errores permanece activo hasta que se ejecuta cualquiera de las siguientes sentencias: Resume, Exit Sub, Exit Function. Si ocurre un error mientras un manejador de error est activo, es decir, se est tratando otro error previo, el manejador de errores no puede hacerse cargo de este error. Si una rutina tiene activo su manejador de errores, el control es devuelto a la rutina llamadora y su manejador de errores es activado para manejar el nuevo error. En el caso de que esta ltima rutina tenga tambin activado su manejador de errores el control es devuelto hasta que encontremos un manejador de errores no activo que pueda tratar el error. Si no existe ningn manejador de errores inactivo, el sistema apunta que se ha producido un error fatal . Hay que recordar en este punto que un manejador de errores no es una rutina o una funcin , tan slo es un bloque de cdigo dentro de un procedimiento. En el siguiente ejemplo, vamos a ver el cdigo correspondiente a manejo de errores del programa INSTALA.EXE. Sub Command1_Click () Unidad$ = Text1.Text Directorio$ = Text2.Text On Error GoTo ManejadorErrores: If Len(Unidad$) = 1 Then Unidad$ = Unidad$ + ":\" Else Unidad$ = Left$(Unidad$, 1) + ":\" End If Ruta$ = Unidad$ + Directorio$ If Dir$(Ruta$, 16) <> "" Then Respuesta1% = MsgBox(" El directorio indicado ya existe, quiere continuar la instalacin", 36, "ATENCION") If Respuesta1% = 7 Then Text1.Text = "" Text2.Text = "" Exit Sub End If Else MsgBox " Creando : " + Ruta$, 16, " ATENCION" MkDir Ruta$ End If MsgBox "Ahora, tericamente, comenzara el proceso de instalacin de una serie de ficheros en el directorio especificado", 16, " ATENCION" End ManejadorErrores: NumeroError% = Err

Select Case NumeroError% Case 68 Respuesta% = MsgBox("Unidad inexistente", 16, "ATENCION ERROR") Text1.Text = "" Text2.Text = "" Exit Sub Case 71 Respuesta% = MsgBox("Por Favor chequee su unidad de disco", 17, "ATENCION ERROR") If Respuesta% = 1 Then Resume Else Text1.Text = "" Text2.Text = "" Exit Sub End If Case 75 Respuesta% = MsgBox("Error de acceso en unidad y/o directorio especificado ", 16, "ATENCION ERROR") Text1.Text = "" Text2.Text = "" Exit Sub Case 76 Respuesta% = MsgBox("Especificacin de unidad o directorio errnea", 16, "ATENCION ERROR") Text1.Text = "" Text2.Text = "" Exit Sub Case Else Resume End Select End Sub Como vemos en el cdigo anterior este pequeo programa tan slo se limita a recoger del usuario la especificacin de unidad y directorio/s, comprobar su existenci y en caso contrario crearlos. Existe una manejador de errores que comienza a partir de la etiqueta ManejadorErrores: y que fue previamente habilitado con la sentencia On Error GoTo ManejadorErrores:. En este manejador de errores tan slo hacemos un tratamiento de 4 errores, dejando abierta la posibilidad de tratar cuantos queramos.

14.10.2.- SENTENCIAS: RESUME, RESUME NEXT, RESUME LINE#

Tras la deteccin de un error, la sentencia Resume reanuda la ejecucin del programa en la sentencia que caus dicho error o en la llamada ms reciente siempre que sta est fuera del procedimiento que contiene el manejador de errores. En el cdigo anterior vemos que slo permitiremos que se ejecute de nuevo la sentencia que causa el error, en el caso de que dicho error sea producido por que el usuario no ha introducido bien el diskette. La sentencia Resume Next reanuda la ejecucin en la sentencia inmediatamente siguiente a la que produjo el error, as evitamos que se vuelva a producir dicho error. Resume Line obliga a que la ejecucin continue en la lnea especificada, bien sea por su nmero de lnea o por su etiqueta correspondiente. Imaginemos un programa en el que un evento determinado llama a una serie de procedimientos encadenados. Si ocurre un error en el procedimiento "C" y este procedimiento no cuenta con un manejador de errores habilitado, Visual Basic automticamente busca si entre los procedimientos "B" y "A" , tienen algn manejador de errores habilitado, y si no es as lo busca incluso en el evento inicial que propici las llamadas en cascada. Si no encuentra ningn manejador habilitado detiene la ejecucin del programa e informa al usuario que se ha producido un error. Para la siguiente disquisicin supondremos que slo el procedimiento "A" tiene activado el manejador de errores. Si Visual Basic encuentra la sentencia Resume en este manejador, la ejecucin continuar ejecutando de nuevo la llamada al procedimiento "B" , que a su vez llam a la sentencia del procedimiento "C" que produjo el error. Si Visual Basic encuentra la sentencia Resume Next en este manejador, la ejecucin continuar ejecutando de nuevo la siguiente sentencia del "B", que a su vez llam a la sentencia del procedimiento "C" que produjo el error.

14.10.3.- FUNCIONES : ERR, ERL y ERROR$

Despus de que un error ocurra, la funcin Err devolver un entero correspondiente al cdigo de error producidido. La funcin Erl nos devolver un entero largo que es el nmero de lnea de la sentencia que ha producido el error. Como habrs observado las funciones anteriores tan slo devuelven valores coherentes cuando se produce un error, por tanto slo suelen ser utilizadas dentro de las rutinas de manejo de errores. Despus que Visual Basic encuentra una sentencia Resume, Exit Sub o Exit Function, automticamente pone a cero los valores que sern devueltos por estas funciones.

La funcin Error$ acepta como argumento el cdigo de cualquier error y devuelve una cadena de caracteres correspondiente a la descripcin de dicho error. Si el argumento representa un cdigo de error que no est definido en Visual Basic, es decir, corresponde a un cdigo de error definido por el programador, esta funcin devuelve la siguiente cadena de caracteres: User-defined error. Si esta funcin es llamada sin argumento, nos devolver el error cometido ms recientemente y si no se ha producido ningn tipo de error nos devolver una cadena de catacteres vaca. El siguiente ejemplo muestra en una Caja de Dilogo el nmero correspondiente al error producido y su descripcin : MsgBox "Error n:" + Str$(Err) + Error(Err), 16, "ATENCION ERROR"

14.10.4.- SENTENCIAS: ERR y ERROR

La sentencia Err especifica y/o cambia el valor correspondiente al cdigo de error que posteriormente ser devuelto por la funcion Err. El uso de esta sentencia es para asignar cdigos de error no utilizados por Visual Basic a nuestra aplicacin. As podemos crear facilmente cdigos de error especficos de nuestra aplicacin. La sentencia Error simula la ocurrencia de un error. El argumento de esta sentencia indicar a Visual Basic el tipo de error que tiene que simular. Este cdigo puede corresponder a errores propios de Visual Basic o a cdigos de error definidos por el programador dentro de su aplicacin. Gracias a esta sentencia podemos generar cualquier tipo de error en el sistema.

14.11.- LISTADO DEL PROGRAMA ERROR MICROSOFT VISUAL BASIC VERSIN 3.00 Begin Form Form1 BackColor = &H00C0C0C0& Caption = "Form1" Height = 2925 Left = 1980 LinkTopic = "Form1" ScaleHeight = 2520 ScaleWidth = 3645 Top = 2235 Width = 3765 Begin CommandButton Command2 Caption = "SALIR" Height = 1095 Left = 1920

TabIndex = 2 Top = 1080 Width = 1335 End Begin CommandButton Command1 Caption = "TEST" Height = 1095 Left = 360 TabIndex = 1 Top = 1080 Width = 1335 End Begin TextBox Text1 Height = 375 Left = 360 TabIndex = 0 Top = 360 Width = 2895 End End Sub Command1_Click () For X% = 1 To 10 Prueba1 Next X% End Sub Sub Command2_Click () End End Sub Sub Prueba1 () For Y% = 1 To 10 Prueba2 Next Y% End Sub Sub Prueba2 () For XY% = 1 To 10 Prueba3 Next XY% End Sub Sub Prueba3 () For pp% = 1 To 10 Text1.Text = Str$(pp%) Stop Next pp% End Sub

14.12.- LISTADO DEL PROGRAMA INSTALA MICROSOFT VISUAL BASIC VERSION 3.00 Begin Form Form2 Caption = "INSTALA.EXE" Height = 3285 Left = 3030 LinkTopic = "Form2" ScaleHeight = 2880 ScaleWidth = 3465 Top = 1290 Width = 3585 Begin CommandButton Command1 Caption = "OK" Height = 615 Left = 360 TabIndex = 4 Top = 2040 Width = 2895 End Begin TextBox Text2 Height = 375 Left = 240 TabIndex = 3 Top = 1440 Width = 3015 End Begin TextBox Text1 Height = 375 Left = 2880 TabIndex = 1 Top = 240 Width = 375 End Begin Label Label2 Alignment = 2 'Center Caption = "Introduzca el directorio donde residirn los ficheros instalados:" Height = 495 Left = 240 TabIndex = 2 Top = 840 Width = 2895 End Begin Label Label1 Alignment = 2 'Center Caption = "Introduzca la unidad donde quiera instalar los ficheros :" Height = 495

Left = 120 TabIndex = 0 Top = 240 Width = 2775 End End Sub Command1_Click () Unidad$ = Text1.Text Directorio$ = Text2.Text On Error GoTo ManejadorErrores: If Len(Unidad$) = 1 Then Unidad$ = Unidad$ + ":\" Else Unidad$ = Left$(Unidad$, 1) + ":\" End If Ruta$ = Unidad$ + Directorio$ If Dir$(Ruta$, 16) <> "" Then Respuesta1% = MsgBox(" El directorio indicado ya existe, quiere continuar la instalacin", 36, "ATENCION") If Respuesta1% = 7 Then Text1.Text = "" Text2.Text = "" Exit Sub End If Else MsgBox " Creando : " + Ruta$, 16, " ATENCION" MkDir Ruta$ End If MsgBox "Ahora, teoricamente, comenzaria el proceso de instalacin de una serie de ficheros en el directorio especificado", 16, " ATENCION" End Exit Sub ManejadorErrores: MsgBox "error " + Str$(Err) + Error(Err), 16, "ATENCION ERROR" NumeroError% = Err Select Case NumeroError% Case 68 Respuesta% = MsgBox("Unidad inexistente", 16, "ATENCION ERROR") Text1.Text = "" Text2.Text = "" Exit Sub Case 71 Respuesta% = MsgBox("Por Favor chequee su unidad de disco", 17, "ATENCION ERROR") If Respuesta% = 1 Then Resume Else

Text1.Text = "" Text2.Text = "" Exit Sub End If Case 75 Respuesta% = MsgBox("Error de acceso en unidad y/o directorio especificado ", 16, "ATENCION ERROR") Text1.Text = "" Text2.Text = "" Exit Sub Case 76 Respuesta% = MsgBox("Especificacin de unidad o directorio erronea", 16, "ATENCION ERROR") Text1.Text = "" Text2.Text = "" Exit Sub End Select End Sub

CAPTULO 15 INTERFACE DE DOCUMENTO MLTIPLE (VENTANAS MDI) 15.1.- INTRODUCCIN

Aunque el concepto de Interface de Documento Mltiple pueda parecer ms o menos nuevo, su implementacin es de todos conocida, no en vano es lo primero que tenemos en pantalla cuando entramos en el administrador de programas de Windows. El MDI permite crear una aplicacin que contenga mltiples ventanas dentro de una ventana llamada ventana madre. La ventana principal del administrador de programas contiene en su interior una serie de ventanas hijas que corresponden a los diferentes grupos de programas que tengamos en Windows. Hablando en la terminologa de Visual Basic el MDI consiste en una form que contiene en su interior mltiples forms. Una aplicacin desarrollada en Visual Basic tan solo puede contener una form MDI, en el interior de la cual se situarn todas las dems ventanas form. Las form que estn en el interior del contenedor principal se conocen como form hijas y no son ms que forms normales pero que tienen su propiedad MDIChild = True. Cuando ejecutamos la aplicacin las ventanas hijas estarn ocupando el rea interior de la ventana madre, no pudiendo salir del espacio ocupado por sta. Adems, cuando minimizamos una ventana hija, su icono aparece dentro de la ventana madre, nunca en el exterior de sta.

Fig. 15.1. Ventanas MDI e iconos de las ventanas hijas.

El diseo de un interface MDI se convierte en uno de los aspectos ms bonitos de la programacin en Visual Basic, tanto por su sencillez en el diseo, como por su potencia y

espectacularidad. Es pues uno de esos asuntos que pasan desapercibidos cuando se usan, pero que cuando se disean se da uno cuenta de su verdadera vala.

15.2.- CARACTERSTICAS DE LAS VENTANAS HIJAS

El diseo de las ventanas MDI no difiere del diseo de cualquier otro tipo de form. Tanto la ventana madre como las posibles ventanas hijas pueden contener cdigo, controles, propiedades de la misma manera que las otras forms. Tan solo hay que indicar que van a ser ventanas MDI. Para crear una aplicacin MDI, el proceso es tan sencillo como elegir la opcin New MDI Form del men File. Automticamente se crea una ventana que lleva, por defecto, el ttulo de MDI Form1. Esta ventana ser la ventana madre de la aplicacin MDI. El proceso de creacin de las ventanas hijas, es igualmente sencillo. En primer lugar se crea una nueva form, o se abre alguna ya existente, y se pone su propiedad MDIChild = True. Desde ese momento el nuevo form pasa a ser una ventana hija de la ventana MDI inicial. Y si bien en tiempo de diseo estas ventanas son iguales a las dems, es en tiempo de ejecucin cuando muestran su verdadera talla. En primer lugar, hay que decir que las ventanas hijas se visualizarn dentro del rea ocupada por la ventana madre. El usuario es muy libre de modificar el tamao y posicin de las ventanas hijas, pero con la restriccin de que stas no pueden salirse de la ventana madre. Tambin hemos indicado antes, que si minimizamos una ventana hija, aparece su icono colocado en la parte inferior de la ventana madre, y siempre dentro de sta. Si la que minimizamos es la ventana madre, tanto ella como todas las ventanas que pudiera tener en su interior quedan reducidas a un solo icono. Cuando se quiera volver a poner la ventana a su posicin y tamao original, se hace un doble click sobre el icono de la ventana minimizada y todo el conjunto de ventanas recupera las caractersticas que tena antes de ser minimizada. De la misma forma que podemos minimizar una ventana MDI, tambin podemos maximizarla. Cuando se maximiza la ventana madre, pasa a ocupar toda la pantalla y en su interior se siguen situando las ventanas hijas. Si lo que se maximiza es una ventana hija, esta pasa a ocupar la totalidad del rea de la ventana madre. Adems, en la barra de ttulo de la ventana madre aparece su propio ttulo y el de la ventana hija que hemos maximizado. Si alguna de las ventanas hijas tiene una barra de mens, dicha barra no aparece sobre ella sino que aparece sobre la ventana madre siempre y cuando que la ventana hija sea la ventana activa. Si se cambia de ventana activa, tambin cambia la barra de mens.

15.3.- VISUALIZACIN DE VENTANAS MDI

Visual Basic permite determinar que ventanas se visualizan en primer lugar cuando se ejecuta la aplicacin.

Una forma sencilla de hacer esto es indicando el nombre de la ventana que aparece al ejecutar la aplicacin. Para ello podemos seleccionar la opcin Project del men Options. Aparece una ventana titulada Project Options, la cual tiene una casilla etiquetada con Start Up Form. Es en esa casilla donde debemos colocar el nombre de la ventana a visualizar en primer lugar. Llevando esta idea al tema de las ventanas MDI, podemos especificar una ventana hija como ventana de arranque. Esto supone que al ejecutar la aplicacin se cargen a la vez la ventana madre y la hija. Por el contrario, si lo que cargamos es la ventana madre, lo que se produce es tan solo la carga de dicha ventana, es decir, ninguna de las ventanas hijas aparecer en pantalla a no ser que se indique otra cosa. El tamao de las ventanas hijas puede ser calculado automticamente por el propio programa. Para ello, dichas ventanas deben tener la propiedad BorderStyle = 2. El tamao y la posicin son calculados en virtud del tamao de la ventana madre y del nmero de ventanas hijas. Esto quiere decir, que en este caso, no importa para nada el tamao que nosotros hayamos puesto en el momento del diseo de las ventanas. Si el valor de la propiedad BorderStyle es distinto de 2, los valores de tamao y posicin son los especificados en el diseo de la aplicacin. La carga de una ventana MDI se efecta de igual manera que el resto de las forms, es decir, mediante la sentencia Load. Tambin sabemos que con la sentencia Show no solo se puede cargar en memoria una ventana sino que adems se visualiza. Usaremos esta sentencia tambin para las ventanas MDI. El proceso contrario es quitar la ventana. Esto se hace con Unload. La sentencia activa un evento llamado QueryUnload. Como el suceso QueryUnload se activa antes de quitar la ventana de memoria, se puede presentar al usuario alguna opcin, ofreciendo, por ejemplo, la posibilidad de guardar esa form antes de que desaparezca.

15.4.- MENS EN VENTANAS MDI

Ya hemos dicho en anteriores prrafos, que las ventanas MDI tanto hijas como madres, pueden llevar asociados una lnea de mens. Sabemos tambin que esos mens se disean mediante la ventana de diseo de mens, de la misma forma que se hace con el resto de las forms, y hemos comentado la relacin entre la ventana madre y los mens de las ventanas hijas. Lo que vamos a describir ahora es el diseo del llamado Men Ventana. Este es un men especial que permite, entre otras cosas, visualizar el ttulo de todas las ventanas hijas que tenemos abiertas. Adems, se pueden incorporar en ese men las bien conocidas sentencias para la organizacion de ventanas e iconos dentro de una ventana madre. Estas posibilidades, se resumen en el ordenamiento en forma de cascada o la colocacin de las ventanas como si fueran baldosas y tambin en el reordenamiento de los iconos en la ventana madre.

El proceso a seguir para tal fin, consiste en disear un men que le vamos a llamar Ventana. Si mientras estamos diseando ese men dentro de la ventana de diseo de mens, activamos la casilla Window List, se provoca que cuando ejecutemos la aplicacin y seleccionemos el men Ventana aparezca una lista de las ventanas hijas disponibles. Adems, el ordenamiento de ventanas e iconos es posible gracias al mtodo Arrange. Si utilizamos junto a este mtodo las constantes CASCADE, TILE_HORIZONTAL y ARRANGE_ICONS, podemos ordenar dentro de la ventana madre, todas las ventanas hijas o los iconos de stas.

Ejemplo Todo esto, junto a algunas cosas ms lo vamos a incorporar al diseo de una aplicacin llamada MDI.MAK. Esta aplicacin se muestra al final del captulo.

15.5 .- DISEO DE UNA BARRA DE HERRAMIENTAS

Sabemos que una barra de herramientas nos permite de una forma abreviada seleccionar determinadas opciones con tan solo pulsar el correspondiente icono. No solo Visual Basic contiene barras de herramientas, sino que en estosmomentos es rara la aplicacin Windows que no ofrece en algn modo esta posibilidad. Los pasos necesarios para crear una barra de herramientas son: 1.- poner un cuadro de imagen dentro de un form MDI. 2.- Colocar dentro de ese cuadro de imagen aquellos controles que queramos que aparezcan en la barra de herramientas. 3.- Determinar las propiedades que sean necesarias. 4.- Escribir el cdigo para cada botn de la barra de herramientas.

Ejemplo Ver aplicacin MDI.MAK al final de ste captulo.

15.6.- APLICACIN EJEMPLO: MDI.MAK

15.6.1.- CARACTERSTICAS MDI DE LA APLICACIN

La aplicacin constar de una ventana madre, sobre la que podemos ir creando en tiempo de ejecucin ventanas hijas. La ventana madre, deber contener un men. El men estar formado por tres elementos llamados Fichero, Opciones y Ventana. El men Fichero, incorporar las opciones de men Nuevo, Cerrar y Salir, las cuales permitirn crear una ventana hija, cerrar una ventana existente y salir de la aplicacin. El men Opciones est indicado para elegir el color y el grosor de trazo de las lneas que dibujemos. El men Ventana incorpora las opciones de ordenacin de ventanas, y la lista de ventanas abiertas. La aplicacin presenta justo debajo de la barra de mens una barra de herramientas con dos iconos. Estos iconos al ser pulsados permiten crear o eliminar una ventana hija.

15.6.2.- RUTINAS INCORPORADAS A LA APLICACIN

1.- Rutina para el control del color (ver Fig. 15.2). Esta rutina es la misma que la que comentamos en el captulo "Grficos".

Fig. 15.2. Rutina para el tratamiento de color.

2.- Rutina para el control del grosor de lnea (ver Fig. 15.3). Se trata de una simple barra de desplazamiento que aumenta o disminuye el grosor de las lneas que tracemos.

Fig. 15.3. Rutina para el grosor de lnea.

3.- Rutina para dibujar lneas en la ventana (ver Fig. 15.4). Es la misma rutina que la que se dise en el captulo "Control y manejo del ratn".

Fig. 15.4. Rutina para el control del grosor de lnea.

15.6.3.- APLICACIN COMPLETA

Todas las caractersticas explicadas se reunen en la aplicacin MDI.MAK cuyo interface grfico aparece en la Fig. 15.5.

Fig. 15.5 .Aplicacin MDI.MAK. Interface de usuario. Ordenacin en mosaico.

15.6.4.- CDIGO DE LA APLICACIN

El cdigo, a pesar de hacerse largsimo por incorporar los valores de las propiedades, es muy sencillo y lo que son los procedimientos son una aplicacin directa de los conceptos comentados a lo largo del captulo.
MICROSOFT VISUAL BASIC VERSION 3.00 ' DISEO DE LA VENTANA CON LAS OPCIONES DE MEN Begin Form Form1 AutoRedraw = -1 'True Caption = "Form1" ForeColor = &H000000FF& Height = 3510 Left = 2190 LinkTopic = "Form1" MDIChild = -1 'True ScaleHeight = 2820 ScaleWidth = 4245 Top = 1770 Width = 4365 Begin Menu Fichero Caption = "&Fichero" Begin Menu Opcion Caption = "&Nuevo" Index = 0 End Begin Menu Opcion Caption = "&Cerrar" Index = 1 End Begin Menu Opcion Caption = "-" Index = 2 End Begin Menu Opcion Caption = "&Salir" Index = 3 End End Begin Menu opciones Caption = "&Opciones" Begin Menu barras Caption = "&Barra de Herramientas" Checked = -1 'True End Begin Menu color Caption = "&Color" End Begin Menu lineas

Caption = "&Lineas" End End Begin Menu ventana Caption = "&Ventana" Begin Menu cascada Caption = "&Cascada" End Begin Menu mosaico1 Caption = "&Mosaico Horizontal" End Begin Menu mosaico2 Caption = "Mo&saico Vertical" End Begin Menu organizar Caption = "&Organizar Iconos" End End End Dim Semaforo As Integer Sub barras_Click () If barra = -1 Then barras.Checked = 0 barra = 0 MDIForm1!Picture1.Visible = 0 Else barras.Checked = -1 barra = -1 MDIForm1!Picture1.Visible = -1 End If End Sub Sub cascada_Click () MDIForm1.Arrange 0 End Sub Sub color_Click () Form2.Show End Sub Sub Form_Click () If Semaforo = 1 Then Semaforo = 0 ForeColor = ColorLinea DrawWidth = AnchoLinea Me.Caption = "VentanaMDI n" + Me.Tag + ", Dibujo OFF " Else Semaforo = 1 ForeColor = ColorLinea DrawWidth = AnchoLinea Me.Caption = "VentanaMDI n" + Me.Tag + ", Dibujo ON " End If End Sub Sub Form_Load () Semaforo = 0 AnchoLinea = 1 End Sub Sub Form_MouseMove (Button As Integer, Shift As Integer, X As Single, Y As Single)

If Semaforo = 1 Then Line -(X, Y) Else CurrentX = X CurrentY = Y End If End Sub Sub lineas_Click () Form3.Show End Sub Sub mosaico1_Click () MDIForm1.Arrange 1 End Sub Sub mosaico2_Click () MDIForm1.Arrange 2 End Sub Sub Opcion_Click (Index As Integer) Select Case Index Case 0 HacerVentana Case 1 QuitarVentana Me Case 3 End End Select End Sub Sub organizar_Click () MDIForm1.Arrange 3 End Sub

' CDIGO ASOCIADO A LA RUTINA DE COLOR Begin Form Form2 Caption = "COLOR" Height = 2535 Left = 2325 LinkTopic = "Form2" ScaleHeight = 2130 ScaleWidth = 5130 Top = 1755 Width = 5250 Begin CommandButton Command2 Caption = "OK"

Height = 375 Left = 1080 TabIndex = 6 Top = 1560 Width = 2895 End Begin HScrollBar HScroll3 Height = 252 LargeChange = 5 Left = 1440 Max = 255 TabIndex = 2 Top = 1080 Width = 2772 End Begin HScrollBar HScroll2 Height = 252 LargeChange = 5 Left = 1440 Max = 255 TabIndex = 1 Top = 720 Width = 2772 End Begin HScrollBar HScroll1 Height = 252 LargeChange = 5 Left = 1440 Max = 255 TabIndex = 0 Top = 360 Width = 2772 End Begin Label Label3 Caption = "Verde" Height = 252 Left = 4320 TabIndex = 5 Top = 720 Width = 612 End Begin Label Label2 Caption = "Azul" Height = 252 Left = 4320 TabIndex = 4 Top = 1080 Width = 612 End Begin Label Label1 Caption = "Rojo" Height = 252 Left = 4320 TabIndex = 3 Top = 360 Width = 732 End Begin Shape Shape1 FillStyle = 0 'Solid Height = 972 Left = 240

Shape Top Width End End

= 3 'Circle = 360 = 972

Sub Command1_Click () End Sub Sub Command2_Click () ColorLinea = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value) Form2.Hide End Sub Sub Form_Load () Shape1.FillColor = RGB(0, 0, 0) Form2.Caption = " COLOR: RGB(0,0,0) " End Sub Sub HScroll1_Change () Shape1.FillColor = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value) Form2.Caption = "COLOR:RGB( " + Str$(HScroll1.Value) + " , " + Str$(HScroll2.Value) + " , (HScroll3.Value) + " )" End Sub Sub HScroll1_Scroll () HScroll1_Change End Sub Sub HScroll2_Change () Shape1.FillColor = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value) Form2.Caption = "COLOR:RGB( " + Str$(HScroll1.Value) + " , " + Str$(HScroll2.Value) + " , (HScroll3.Value) + " )" End Sub Sub HScroll2_Scroll () HScroll2_Change End Sub Sub HScroll3_Change () Shape1.FillColor = RGB(HScroll1.Value, HScroll2.Value, HScroll3.Value) Form2.Caption = "COLOR:RGB( " + Str$(HScroll1.Value) + " , " + Str$(HScroll2.Value) + " , (HScroll3.Value) + " )" End Sub Sub HScroll3_Scroll () HScroll3_Change End Sub

" + Str$

" + Str$

" + Str$

' CODIGO ASOCIADO A LA RUTINA DEL GROSOR DE LNEA Begin Form Form3 BackColor = &H00C0C0C0& Caption = "Grosor de Linea" Height = 1500 Left = 2685 LinkTopic = "Form3" ScaleHeight = 1095 ScaleWidth = 4260

Top = 2115 Width = 4380 Begin CommandButton Command1 Caption = "OK" Height = 855 Left = 2760 TabIndex = 3 Top = 120 Width = 1335 End Begin HScrollBar HScroll1 Height = 255 LargeChange = 2 Left = 120 Max = 20 TabIndex = 0 Top = 720 Width = 2415 End Begin Label Label2 Alignment = 2 'Center BorderStyle = 1 'Fixed Single Height = 195 Left = 1320 TabIndex = 2 Top = 360 Width = 495 End Begin Label Label1 BackColor = &H00C0C0C0& Caption = "Grosor:" Height = 255 Left = 600 TabIndex = 1 Top = 360 Width = 615 End End Sub Command1_Click () AnchoLinea = HScroll1.Value Form3.Hide End Sub Sub HScroll1_Change () Label2.Caption = Str$(HScroll1.Value) Form3.Caption = "Grosor de Linea =" + Str$(HScroll1.Value) End Sub

' VENTANA MDI CON BARRA DE HERRAMIENTAS Begin MDIForm MDIForm1 Caption = "DOCUMENTO MDI" Height = 5730 Left = 990 LinkTopic = "MDIForm1" Top = 5385 Width = 8085 Begin PictureBox Picture1 Align = 1 'Align Top

BackColor = &H00C0C0C0& FillColor = &H00C0C0C0& ForeColor = &H00C0C0C0& Height = 495 Left = 0 ScaleHeight = 465 ScaleWidth = 7935 TabIndex = 0 Top = 0 Width = 7965 Begin Image Image6 Height = 480 Left = 4680 Picture = MDIMDI1.FRX:0000 Top = 0 Visible = 0 'False Width = 480 End Begin Image Image5 Height = 480 Left = 3840 Picture = MDIMDI1.FRX:0302 Top = 0 Visible = 0 'False Width = 480 End Begin Image Image4 Height = 480 Left = 2880 Picture = MDIMDI1.FRX:0604 Stretch = -1 'True Top = 0 Visible = 0 'False Width = 480 End Begin Image Image3 Height = 480 Left = 2160 Picture = MDIMDI1.FRX:0906 Top = 0 Visible = 0 'False Width = 480 End Begin Image Image2 Height = 480 Left = 600 Picture = MDIMDI1.FRX:0C08 Top = 0 Width = 480 End Begin Image Image1 Height = 480 Left = 0 Picture = MDIMDI1.FRX:0F0A Top = 0 Width = 480 End End Begin Menu Fichero Caption = "&Fichero" Begin Menu opcion

Caption = "&Nuevo" Index = 0 End Begin Menu opcion Caption = "&Cerrar" Index = 1 End Begin Menu opcion Caption = "-" Index = 2 End Begin Menu opcion Caption = "&Salir" Index = 3 End End Begin Menu opciones Caption = "&Opciones" Begin Menu barras Caption = "&Barra de Herramientas" Checked = -1 'True End End End Sub barras_Click () If barras = -1 Then barras.Checked = 0 barra = 0 Picture1.Visible = 0 Else barras.Checked = -1 barra = -1 Picture1.Visible = -1 End If End Sub Sub Image1_MouseDown (Button As Integer, Shift As Integer, X As Single, Y As Single) Image1.Picture = Image4.Picture End Sub Sub Image1_MouseUp (Button As Integer, Shift As Integer, X As Single, Y As Single) Image1.Picture = Image3.Picture Opcion_Click (0) End Sub Sub Image2_MouseDown (Button As Integer, Shift As Integer, X As Single, Y As Single) Image2.Picture = Image6.Picture Opcion_Click (1) End Sub Sub Image2_MouseUp (Button As Integer, Shift As Integer, X As Single, Y As Single) Image2.Picture = Image5.Picture End Sub Sub MDIForm_Load () barra = -1 ReDim NuevaVentana(0) NuevaVentana(0).Tag = 0 NuevaVentana(0).Caption = "VentanaMDI n 0 " + ", Dibujo OFF " NuevaVentana(0).Show

End Sub Sub Opcion_Click (Index As Integer) Select Case Index Case 0 HacerVentana Case 1 QuitarVentana Screen.ActiveForm Case 3 End End Select End Sub

CAPTULO 16 INTERCAMBIO DINMICO DE DATOS 16.1.- INTRODUCCIN

Como es de todos conocido, Windows es un entorno operativo que permite realizar multitarea. Esto significa, que se pueden ejecutar a la vez, varias operaciones. Es precisamente esta virtud la que abre las posibilidades de comunicacin entre las diferentes aplicaciones que se estn ejecutando. Muchas veces estamos interesados en que nuestras aplicaciones compartan datos. Por ejemplo, si tengo una serie de datos almacenados en una hoja de clculo nos puede interesar que algunos de ellos se aadan a los campos de una base de datos, o bien, queremos que aparezcan en un documento que estamos creando con un procesador de textos. Este tipo de acciones las vamos realizando con ms o menos xito mediante la copia en el portapapeles y el posterior pegado de esos datos en una determinada aplicacin. Sin embargo, si queremos automatizar todo este proceso debemos recurrir al llamado Intercambio Dinmico de Datos (DDE-Dynamic Data Exchange). El DDE es un mecanismo soportado por Windows y que permite la comunicacin entre aplicaciones mediante un intercambio automtico de datos.

16.2.- CONCEPTOS BSICOS DE UNA CONVERSACIN DDE

Dentro de las conversaciones que se establecen entre aplicaciones Windows para el intercambio de datos, podemos destacar dos elementos indispensables. El primero de ellos es la aplicacin que inicia la conversacin, tambien llamada aplicacin destino (destination application), mientras que el otro es la aplicacin que responde a la anterior, llamada aplicacin fuente (source application). No es extrao que una aplicacin mantenga una conversacin con varias aplicaciones a la vez. Dicha aplicacin podra actuar perfectamente como la aplicacin destino en unos casos y en otros como la aplicacin fuente. Los trminos de "destination application" y "source application" son, respectivamente, los nuevos nombres que Microsoft da a "client application" y a "server application". Estos ltimos se incluan en la versin 1.0 de Visual Basic y fueron cambiados en la 2.0 por los nuevos trminos segn el estndar de Windows. Cuando una aplicacin destino se prepara para iniciar una conversacin, debe conocer dos cosas. La primera de ellas es el nombre de la aplicacin fuente y la segunda es la materia de la conversacin, tambin llamada tpico. Estas dos caractersticas se mantienen constantes a lo largo de toda la conversacin.

El nombre de la aplicacin fuente, es nico, y generalmente se corresponde con el nombre de un fichero ejecutable. Por ejemplo, cuando la aplicacin fuente es Microsoft Excel, su nombre de aplicacin DDE es Excel. Para el procesador de textos Word, su nombre es WinWord, para el Access es MSAccess, para el Project es Project y para FoxPro es FoxPro. El tpico, como decamos, indica en cierto modo las caractersticas de la conversacin. As, Excel reconoce como tpico el nombre de un fichero terminado en .XLS .XLC, mientras que Word hace lo propio con .DOC y .DOT. Si la aplicacin fuente es un form creado en Visual Basic, se debe especificar el tpico mediante la propiedad LinkTopic. Un tipo de tpico muy interesante es el llamado System, el cual suministra informacin sobre la aplicacin, tal como qu otros tpicos soporta o los formatos de los datos de que dispone. Y como ltima definicin podemos hablar de los item, los cuales hacen referencia a la clase de datos que se transfiere en la comunicacin. Excel utiliza com items, la referencia a las celdillas de la hoja de clculo. Cuando interviene algn control creado en Visual Basic como destino de la conversacin DDE, se puede especificar el item mediante la propiedad LinkItem. Si el form es la fuente de la conversacin, el nombre de cada uno de los controles se puede usar como item de una conversacin DDE.

16.3.- ENLACES EN UN INTERCAMBIO DINMICO DE DATOS

Cuando dos aplicaciones estn enfrascadas en una conversacin de tipo DDE, se dice que mantienen un enlace (link). Segn sea la forma en que la aplicacin fuente actualiza la aplicacin destino cuando cambian los datos en la primera, distinguimos tres tipos de enlaces: - enlace automtico - enlace manual - enlace notificado En el enlace automtico, la aplicacin fuente suministra datos a la aplicacin destino cada vez que los datos definidos mediante la propiedad LinkItem cambian. El enlace manual, se caracteriza porque esa actualizacin se produce solamente cuando la aplicacin destino lo pide, mientras que el enlace notificado se identifica porque la aplicacin fuente notifica a la aplicacin destino que los datos han cambiado, pero solo le pasa los datos cuando sta se lo pide.

16.4.- ENLACES DDE EN TIEMPO DE DISEO

El establecimiento de vnculos entre aplicaciones Windows, se puede efectuar mientras diseamos la aplicacin. Visual Basic contiene determinadas propiedades que permiten establecer los enlaces entre aplicaciones. Todas esas propiedades se engloban mediante el nombre genrico de

"Link Properties". De aqu se deduce que no hace falta escribir cdigo para efectuar una aplicacin DDE, sino que tan solo se necesita precisar el valor adecuado para las propiedades. Esas propiedades se pueden modificar mientras diseamos la aplicacin y sus valores quedarn grabados en la propia aplicacin. Cuando se ejecute la aplicacin esos valores se reestablecen y se intenta iniciar la conexin entre aplicaciones. Antes de meternos con las "Link Properties" vamos a describir la forma ms sencilla de establecer una conversacin DDE. Como sabemos, existen dos formas de comunicar nuestra aplicacin con otras. Una de ellas es hacer que nuestra aplicacin sea la que reciba dsatos de otras aplicaciones y la otra es hacer que sea nuestra propia aplicacin la que suministre los datos a las dems aplicaciones. Los pasos necesarios para establecer una conversacin en la que la aplicacin que estamos diseando sea la aplicacin destino son: 1.- entrar en el entorno de Visual Basic y empezar el diseo de nuestra aplicacin. 2.- abrir la aplicacin fuente, 3.- seleccionar en la aplicacin fuente el item que quiero recibir, 4.- seleccionar el comando Copy del men Edit de la aplicacin fuente, 5.- seleccionar el control de la aplicacin destino que va a recibir los datos, 6.- elegir Paste Link del men Edit del entorno de Visual Basic.

Cuando se ha efectuado el enlace, los datos del control destino se actualizan. Esto es debido a que estamos haciendo un enlace automtico y los datos de la aplicacin destino cambiarn siempre que lo hagan los de la aplicacin fuente. Si la aplicacin destino est en ejecucin, esto originar un evento de tipo Change. Es posible que algunas veces el comando Paste Link est inactivo. Esto significa o que la aplicacin fuente no puede establecer una aplicacin tipo DDE o que el formato de los datos no es reconocido por Visual Basic. Si queremos que la aplicacin fuente, es decir, la que suministre los datos, sea la aplicacin que estamos diseando, el procedimiento a seguir es el siguiente: 1.- entrar en el entorno de Visual Basic y abrir nuestra aplicacin, 2.- seleccionar el form que va a suministrar los datos y poner la propiedad Link Mode a 1- Source, 3.- elegir el comando Copy del men Edit de Visual Basic, 4.- abrir la aplicacin destino, 5.- elegir el destino de los datos en la aplicacin destino,

6.- escoger el comando Paste Link del men Edit de la aplicacin destino.

Si la aplicacin destino no contiene el comando Paste Link, entonces esa aplicacin no soporta DDE. Si dicho comando existe pero est inactivo, entonces quiere decir que no se reconoce el tipo de datos a transmitir. Cada vez que los datos de nuestra aplicacin, que hemos elegido para el intercambio, se modifiquen, esta modificacin se traslada automticamente a la aplicacin destino.

16.5.- PROPIEDADES DEL ENLACE (LINK PROPERTIES)

Acabamos de ver algunas de las limitaciones que tena el proceso de comunicacin mediante los comandos Copy y Paste Link. Por ejemplo, el problema que se plantea si la aplicacin no contiene esos comandos. Cuando necesitamos establecer comunicaciones ms sofisticadas, debemos recurrir a las Link Properties. Como en anteriores casos, debemos distinguir si la aplicacin va a ser la destino o la fuente.

16.5.1.- PROPIEDADES PARA LA APLICACIN DESTINO

Las propiedades de enlace son tres: LinkTopic, LinkItem y LinkMode. La propiedad LinkTopic de un determinado control contiene el nombre de la aplicacin fuente y el tpico o fichero fuente. El criterio a seguir es: aplicacin/tpico Ejemplo: EXCEL/C:\EXCEL\FUENTE.XLS

Esta propiedad se puede especificar para cualquier caja de texto, etiqueta o caja de imagen. Es imprescindible para establecer la conversacin, conocer el nombre de la aplicacin fuente y el tpico. La propiedad LinkItem para un control, especifica el item de la conversacin definida por la propiedad LinkTopic para el mismo control. Como ya sabemos el item se corresponde con la unidad mnima de comunicacin de datos. En el caso de una hoja de clculo corresponde a la celdilla en cuestin, por ejemplo, R5C7.

Por ultimo, nos queda especificar el tipo de enlace que queremos tener en esa conversacin. Esto se puede especificar mediante la propiedad LinkMode. Esta puede tener cuatro valores: 0.- None 1.- Automatic 2.- Manual 3.- Notify Por defecto, un determinado control tiene la propiedad LinkMode puesta a 0 lo que significa que no hay conversacin. Para que la conversacin se produzca, la aplicacin fuente debe estar en ejecucin. En caso contrario se genera un mensaje de error. Cuando se eligen los valores 2 3 de la propiedad LinkMode, no se produce la actualizacin de los datos de manera automtica, por lo que es necesario indicar explcitamente este hecho. Existe un mtodo llamado LinkRequest que permite realizar esa tarea.

16.5.2.- PROPIEDADES PARA LA APLICACIN FUENTE

En esencia, el proceso es muy parecido al anterior. La propiedad LinkTopic asignada a una determinada form, sirve para especificar el tpico de una conversacin DDE. Los items vienen especificados por los nombres de todos los controles de esa form que queramos que suministren datos. El nombre de la aplicacin ser o bien el nombre que le demos al ejecutable de esa aplicacin o el nombre del fichero de proyecto si estamos dentro de Visual Basic. De la misma forma que hemos aplicado la propiedad LinkMode para los controles, lo podemos hacer para las forms. Su valor por defecto es 0. None. Cuando se pone a 1. Source los controles de esa form, proveern datos a la aplicacin destino. Es aconsejable poner en tiempo de diseo la propiedad LinkMode a 1. Source ya que se puede desactivar o activar en tiempo de ejecucin. Esto no sera posible si en tiempo de diseo se pone a 0. None.

16.6.- EVENTOS ASOCIADOS AL DDE

Cada tipo de enlace que hemos visto, lleva asociado un evento. Esto implica que se pueden escribir procedimientos para responder a esos eventos. Cuando los controles de un form actan como destinatarios de una conversacin tipo DDE se pueden destacar los siguientes eventos: - LinkOpen - LinkClose - LinkError - LinkNotify

Si las forms actan como fuentes de datos, los eventos que reconocen son: - LinkOpen - LinkClose - LinkError - LinkExecute

16.6.1.- EVENTOS DE LA APLICACIN DESTINO

LinkOpen Se produce cuando un control efecta con xito una conversacin DDE. LinkClose Se genera cuando por alguna razn se interrumpe la conversacin DDE. LinkError Se genera cuando se produce un error en la conversacin pero sin que se ejecute cdigo, puesto que en este caso, los errores se gestionan de otra forma. Por ejemplo, se puede producir un evento de tipo LinkError cuando se intenta pasar un dato en formato no admisible. LinkNotify Se produce cuando una conversacin, previamente conectada mediante un enlace de tipo Notify, tiene datos para enviar a la aplicacin destino.

16.6.2.- EVENTOS DE LA APLICACIN FUENTE

Son aquellos que se producen cuando una determinada form est involucrada en una conversacin DDE y adems acta como fuente de datos. LinkOpen Se produce cuando la aplicacin destino inicia la conversacin. El procedimiemnto de evento asociado a LinkOpen acepta un argumento entero. Este argumento ser falso siempre que se llame al procedimiento. Si el cdigo que lleva asociado el procedimiento hace que el valor del argumento sea verdadero, en ese mismo instante se rompe la conversacin. LinkClose Ocurre cuando la aplicacin destino finaliza su conversacin.

LinkError Se produce cuando se genera un error en la conversacin DDE pero siempre que ese error no venga motivado por un error del cdigo de programa. LinkExecute Se produce cuando una aplicacin enva un comando para que sea ejecutado por la aplicacin fuente. Este evento admite dos argumentos: el propio comando que se enva y que ser de tipo de dato String y un entero que indicar si la aplicacin fuente ha entendido el mensaje. Ejemplo Sub Form_LinkExecute(CmdStr As String, Cancel As Integer) Ejemplo El efectuar una conversacin de tipo DDE es bastante sencillo. Supongamos que hacemos una aplicacin que inicie una conversacin con Excel. La aplicacin consta de una caja de texto y una casilla de verificacin. Cuando se efecta una pulsacin de ratn sobre la casilla de verificacin, se establece un vnculo entre la caja de texto y la hoja de clculo, en el que la segunda enva datos a la primera. El interface de esta aplicacin se muestra en la Fig. 16.1, y a continuacin se especifica el cdigo del programa.

Fig.16.1. Interface de la aplicacin ejemplo.

El cdigo es tan sencillo como lo siguiente: Sub Check1_Click() Text1.LinkMode = NONE Text1.LinkTopic = "Excel | Sheet1" Text1.LinkItem = "R1C1" Text1.LinkMode = HOT End Sub

CAPTULO 17 VINCULACIN E INCRUSTACIN DE OBJETOS (OLE) 17.1.- INTRODUCCIN

La vinculacin e incrustacin de objetos constituye un mtodo para mejorar la interoperatividad entre aplicaciones Windows. Mediante esta tecnologa, podemos crear una aplicacin en Visual Basic que sea capaz de visualizar y manipular datos procedentes de otras aplicaciones Windows. Por eso, es ideal para la creacin de aparentes presentaciones en las que incluimos en una nica ventana form, una serie de datos, grficos, texto, etc. creados en diferentes aplicaciones Windows. Junto a la aparente vistosidad de la aplicacin aparece intrnsecamente asociada, una extraordinaria potencia. Esta potencia hace posible la manipulacin desde una aplicacin diseada por el usuario de numerosas aplicaciones Windows. As no es de extraar poder tener acceso con un click de ratn a una pantalla de datos Excel o a una imagen creada con Paintbrush por citar tan slo unos ejemplos. La Fig. 17.1 muestra un ejemplo de una aplicacin diseada en Visual Basic 3.0 y desde la cual podemos ver datos de Excel, Word, PaintBrush y del editor de ecuaciones. En ella se han incorporado cuatro controles OLE, uno para cada aplicacin.

Fig. 17.1.- Ejemplo de aplicacin OLE diseada en Visual Basic 3.0.

Si efectuamos un doble click en cada uno de los controles, se ejecuta la aplicacin que est asociada al control. Cada uno de los datos que hemos dispuesto se llama objeto OLE. Una misma aplicacin puede aportar diferentes objetos. Por ejemplo, Excel puede proporcionar un rango de celdillas de la hoja de clculo, un grfico de barras, una macro, etc. Cada uno de estos datos o grupos de datos constituyen un objeto OLE. La aplicacin que ha suministrado tales datos se llama clase de objetos. Cuando colocamos un control OLE sobre una ventana form, aparece una ventana en la que estn reflejados los nombres de las clases de que nuestro ordenador dispone. Un ejemplo de esa ventana aparece en la Fig. 17.2.

Fig. 17.2.- Ejemplo de una ventana de clases de objetos OLE.

Cuando hemos dado ttulo al captulo le hemos llamado Vinculacin e Incrustacin de objetos. Esto es una traduccin al espaol del trmino ingls Object Linking and Embedding (OLE). En dicho trmino aparecen dos conceptos que tienen entidad propia.

Por un lado la vinculacin (linking) de objetos establece un enlace o vnculo entre la aplicacin Visual Basic y la aplicacin Windows que hayamos seleccionado. Los datos existentes en los objetos vinculados no estn grabados en el control OLE, sino que hay nicamente se especifica el vnculo y una imagen para representar el la form esos datos. Desde la aplicacin Visual Basic y mediante un doble click podemos acceder a los datos con los que hemos establecido un vnculo. Esos datos, tambin pueden ser llamados desde cualquier otra aplicacin que tenga vinculacin con ellos. Cualquier modificacin en esos datos, aparece reflejada en todas las aplicaciones que estaban vinculadas a ellos. Por otro lado, la incrustacin de objetos hace que todos los datos asociados con el objeto estn contenidos en el control OLE. Ese control contiene el nombre de la aplicacin que ha suministrado los objetos, los propios datos y una imagen del objeto. La diferencia con la vinculacin radica en que en esta ltima el control solo guardaba un vnculo con los datos, no los propios datos. Los datos de los objetos incrustados no estn disponibles para ninguna otra aplicacin.

17.2.- CONTROL OLE2

17.2.1.- CREACIN DE OBJETOS OLE EN TIEMPO DE DISEO O EN TIEMPO DE EJECUCIN La forma de crear objetos OLE dentro de una aplicacin escrita en Visual Basic es mediante el control OLE. Estos objetos, pueden crearse en tiempo de diseo colocando el control sobre la form correspondiente y respondiendo a los cuadros de dilogo que aparecen, o pueden crearse en tiempo de ejecucin mediante la definicin adecuada de las diferentes propiedades asociadas al control. Cada momento de creacin tiene sus ventajas y sus inconvenientes, de manera que es el programador el que debe decidir que momento se adapta mejor a su aplicacin. Cuando se crea un objeto OLE en tiempo de diseo, el fichero ejecutable resultante tiene un mayor tamao que si lo hacemos en tiempo de ejecucin, puesto que en el primer caso todos los datos asociados al objeto OLE se incorporan al fichero .EXE. Cuando se crea un objeto mediante cdigo, es decir, en tiempo de ejecucin, el sistema suspende cualquier otra actividad hasta que ha creado el objeto. Por tanto, si creamos un objeto en un Form_Load, dicha form no se visualiza hasta que el objeto ha sido creado. 17.2.2.- CREACIN DE OBJETOS OLE EN TIEMPO DE DISEO La forma de crear objetos OLE durante el diseo de la aplicacin es muy sencilla. Se deben colocar en la ventana del form correspondiente tantos controles OLE como se necesiten. Cada vez que se coloca un control OLE automticamente se visualiza la caja de dilogo llamada Insert Object (Insercin de Objeto). Esta caja, que aparece en la Fig. 17.3 permite la eleccin del tipo de objeto que vamos a insertar. Despus de esto, es el propio Visual Basic quien coloca automticamente los valores adecuados de las propiedades para ese control OLE.

Fig. 17.3.- Cuadro de dilogo de Insercin de Objeto.

Entre las muchas propiedades que podemos encontrarnos dentro de un control OLE, podemos destacar dos que hacen referencia a la forma en que vamos a visualizar el objeto. Una de ellas es la propiedad DisplayType que dependiendo de que valga 1 o 0 permite visualizar el objeto OLE como un icono o no. Cuando esta propiedad vale 1, la casilla de verificacin que aparece en el cuadro de dilogo Insert Object est activada. En caso contrario, Fig. 17.3 est desactivada. La otra propiedad es SizeMode la cual determina el tamao del objeto visualizado dentro del control OLE. Esta propiedad puede tener tres valores: - 0 - Clip: coloca el objeto ajustado a los bordes del control OLE - 1 - Strech : estira el objeto para adaptarlo al tamao del control - 2 - AutoSize: ajusta el tamao del control al tamao del objeto.

17.2.2.1.- Creacin de objetos vinculados. Como habamos comentado anteriormente, cuando vinculamos un objeto el control OLE mantiene informacin del vnculo establecido tal como el nombre de la aplicacin que proporciona el objeto, el nombre del fichero donde se guardan los datos vinculados y una imagen de dichos datos. En ningn caso se hace cargo el control de guardar los datos. Para crear un objeto vinculado se colocar el control OLE sobre el form correspondiente. Como ya sabemos, automticamente se visualiza la caja de insercin de objetos. En ella se debe seleccionar por un lado, el tipo de objeto que vamos a vincular y despus de esto seleccionar el botn de opcin etiquetado por Create from File. Al hacer esto aparece un nuevo cuadro de dilogo (ver Fig. 17.4) en el que se debe elegir el botn Browse. Tambin de forma automtica se despliega el cuadro Browse en el que se solicita el nombre de un fichero a vincular. Se pulsa OK y se vuelve al cuadro de insercin de objetos, en el cual se debe seleccionar la casilla Link y pulsar finalmente OK.

Fig. 17.4.- Creacin de objetos vinculados.

Tambin conocemos ya como se activa un control OLE en tiempo de ejecucin. Se hace un doble click sobre el propio control e inmediatamente se activa la aplicacin que ha suministrado el objeto. En ese momento se podrn modificar los datos, los cuales se actualizarn en la aplicacin creada en Visual Basic cuando se graben las modificaciones. Puede ocurrir que nuestra aplicacin no est en ejecucin y que los datos vinculados se modifiquen desde otro sitio. Esto hace que al ejecutar nuestra aplicacin los datos no aparezcan inmediatamente actualizados a no ser que se especifique que lo hagan poniendo el valor de la propiedad Action del control OLE a Action=6 (OLE_UPDATE).

Otra posibilidad que puede ocurrir con los objetos vinculados, es que no queramos que el objeto vinculado sea un fichero entero, sino que sea una parte de l, bien sea un prrafo en un documento, un rango de las celdillas de una hoja de clculo u otros. Para que esto ocurra, se debe especificar el rango de datos a vincular, lo cual se hace en la propiedad SourceItem.

17.2.2.2.- Creacin de objetos incrustados. Es posible crear un objeto incrustado de dos formas bien distintas. Por un lado, podemos crear un objeto incrustado procedente de un fichero ya existente y por otro, podemos crear un nuevo objeto. Si elegimos el primer caso, se representar una imagen de dicho fichero en el control OLE. Si optamos por crear un nuevo objeto, se abre la aplicacin correspondiente para que el usuario introduzca los datos. Esta ltima posibilidad es ms utilizada en tiempo de ejecucin, pues as el usuario podr introducir los datos mientras ejecuta la aplicacin. En general, es costumbre crear objetos ya existentes en tiempo de diseo, de manera que se pueda ajustar el tamao del objeto y prepararle para su aspecto final cuando se ejecute el programa. Los pasos a seguir para crear un objeto incrustado son los siguientes: - colocar el control OLE sobre la form correspondiente, - seleccionar el tipo de objeto que vamos a crear, - activar la casilla Create from File, - elegir el botn Browse, - seleccionar el fichero a incrustar desde el cuadro de dilogo de Browse y OK.

Los datos en un objeto incrustado no son datos persistentes, de modo que cuando se hacen modificaciones en ellos, se deben grabar para que la siguiente vez aparezcan tal y como se han dejado despus de la modificacin.

17.2.2.3.- Utilizacin de mens Pop-up con el control OLE. Cuando tenemos el control OLE sobre la ventana del form, es posible desplegar un men pop-up mediante la pulsacin del botn derecho del ratn. La Fig. 17.5 muestra el men pop-up desplegado.

Fig. 17.5.- Men Pop-up para un control OLE.

Desde sta, se puede crear un objeto nuevo (Insert Object), pegar un objeto desde el portapapeles (Paste Special) y borrar el objeto incrustado (Delete ...).

El men Pop-up vara sensiblemente si en el control OLE todava no hemos colocado ningn objeto.

17.2.2.4.- Creacin de objetos mediante el cuadro de dilogo Paste Special. Esta utilidad permite la creacin de un objeto vinculado o incrustado a partir de los datos que han sido copiados en el portapapeles. La forma de utilizar esto es: - copiar en el portapapeles los datos que queremos vincular o incrustar, - colocar el control OLE en la aplicacin Visual Basic, - visualizar el men pop-up mediante la pulsacin del botn derecho del ratn, - elegir la opcin Paste Special, - en el cuadro de dilogo que se visualiza (Fig. 17.6), seleccionar la opcin Paste para incrustar el objeto o Paste Link para vincularle. - elegir OK para crear el objeto.

Fig. 17.6.- Cuadro de dilogo Paste Special.

17.2.3.- CREACIN DE OBJETOS OLE EN TIEMPO DE EJECUCIN Como era de prever, mientras que para la creacin de objetos en tiempo de diseo utilizbamos diferentes cuadros de dilogo, para crear objetos durante la ejecucin de la aplicacin debemos recurrir a las diferentes propiedades del control. La creacin de objetos OLE a travs de propiedades es siempre menos intuitiva que con las cajas de dilogo, pero no nos queda ms remedio que hacerlo as.

17.2.3.1.- Propiedades para la creacin de objetos. Las propiedades que intervienen en la creacin de objetos OLE son cinco. Class Esta propiedad especifica la clase de datos que el objeto contiene as como el nombre de la aplicacin de suministra el objeto. La Fig. 17.2 contiene una serie de nombres de clases disponibles en mi sistema. Por ejemplo, para crear un objeto que contenga datos procedentes de un documento Word, se debe poner en propiedad Class = WordDocument.

OleTypeAllowed

En general, la misin fundamental de esta propiedad es la de indicar el tipo de objeto que vamos a crear. En ese sentido, podemos decir si el objeto estar vinculado, incrustado o cualquiera de los dos. Para hacer esto, debemos poner alguno de los siguientes valores en la propiedad OleTypeAllowed: OLE_LINKED: para crear un objeto vinculado, OLE_EMBEDDED: para un objeto incrustado, OLE_EITHER: para cualquiera de los dos. Es el valor por defecto.

SourceDoc Esta propiedad especifica el nombre completo, incluido el path, del fichero que vamos a utilizar como objeto a vincular o el que vamos a utilizar como plantilla para incrustar un objeto. Ejemplo: Olectrl1.SouceDoc = "F:\excel\indice.xls"

SourceItem Se utiliza solamente para objetos vinculados, y su misin es especificar el rango de datos a vincular dentro del fichero que estemos tratando.

Action Determina la operacin que vamos a realizar sobre un control OLE. As por ejemplo, es posible usar la propiedad Action para crear un objeto o para borrarle.

17.2.3.2.- Creacin de objetos vinculados. Se pueden distinguir tres pasos fundamentales en la creacin de un objeto vinculado. - Especificacin de la aplicacin que suministrar el objeto. Ole1.Class = "WordDocument" - Especificacin del fichero a vincular. Ole1.SourceDoc = "F:\WINWORD\DOCUMENTO.DOC" - Creacin del fichero vinculado. Ole1.Action = OLE_CREATE_LINK

Tambin es posible determinar el rango de datos mediante la propiedad SouceItem. Los datos de un objeto creado, se visualizan sobre el control OLE.

17.2.3.3.- Creacin de objetos incrustados. Dentro de los objetos incrustados, podemos diferenciar dos tipos: - aquellos que provienen de un fichero ya existente - aquellos objetos de nueva creacin que permiten al usuario introducir los datos. Los pasos necesarios para crear un fichero incrustado desde un fichero son: - Determinar el tipo de objeto mediante la propiedad Class - Especificar el tipo de fichero a usar como plantilla mediante SourceDoc. - Poner la propiedad Action = OLE_CREATE_EMBED

Por otro lado, para crear un objeto incrustado vaco se siguen las siguientes etapas: - Especificar el tipo de objeto con la propiedad Class. - Poner la propiedad Action = OLE_CREATE_EMBED - Activar la aplicacin que suministra el objeto para que el usuario pueda introducir los datos que quiera en esa aplicacin. Esto se hace poniendo Action = OLE_ACTIVATE.

17.2.3.4.- Actuando sobre un objeto. Siempre que queramos efectuar alguna accin sobre un objeto, lo primero que debemos hacer es activar el objeto. En tiempo de ejecucin esto se puede hacer con Action = 7. Existen toda una serie de acciones que podemos efectuar sobre los objetos. Estas operaciones se conocen con el trmino ingls de "verbs". Todos estos aparecen en un men pop-up cuando se pone a "True" la propiedad AutoVerbMenu.

17.2.3.5.- Guardar los datos en un fichero. Los datos asociados a un control OLE no son permanentes, sino que desaparecen una vez que el control se cierra. La forma de evitar la prdida de estos datos es grabarlos en un fichero. Esto se hace poniendo la propiedad Action al oportuno valor. Los pasos a seguir son: - abrir un fichero en modo binario, - especificar en la propiedad FileNumber el nmero del fichero abierto, - poner Action = OLE_SAVE_TO_FILE.

Una vez que hemos grabado en un fichero podemos visualizarle cuando queramos,. El proceso de recuperacin de los datos grabados tiene tambin tres pasos: - abrir el fichero en modo binario, - poner en la propiedad FileNumber el nmero del fichero abierto,

- poner Action = OLE_READ_FROM_FILE.

17.2.4.- DISTRIBUCIN DE APLICACIONES OLE

Es importante decir, que todas las aplicaciones que hagamos en Visual Basic y que utilicen el control OLE, deben ejecutarse en un sistema que contenga las correspondiente libreras de enlace dinmico (DLL). En caso de que no existan stas, Microsoft autoriza a distribuir, junto a la aplicacin que contenga el control OLE, los siguientes ficheros: COMPOBJ.DLL MSOLE2.DLL MSOLEVBX.DLL OLE2.REG OLE2.DLL OLE2CONV.DLL OLE2DISP.DLL OLE2NLS.DLL OLE2PROX.DLL STORAGE.DLL VBOA300.DLL

Estos ficheros deben ser instalados en el directorio de Windows \SYSTEM.

17.3.- AUTOMATIZACIN OLE

17.3.1.- INTRODUCCIN

Como bien dice Microsoft, una de las principales bazas del xito de Microsoft Windows ha sido la capacidad que tiene para compartir datos entre diferentes aplicaciones. Como es lgico, la evolucin que ha sufrido el "sistema operativo" Windows, ha ido incluyendo diferentes mejoras en la comparticin de datos. En ese sentido, las primeras versiones utilizaban el portapapeles para hacer eso. Posteriormente, se logr un incremento de manejabilidad y potencia mediante el intercambio dinmico de datos (DDE). Actualmente, Microsoft centra su esfuerzo en el desarrollo de la tecnologa OLE para no slo compartir datos entre aplicaciones, sino para manipular a voluntad esos datos. La automatizacin de estos ltimos procesos es el asunto del que trataremos a continuacin.

17.3.2.- QU ES LA AUTOMATIZACIN OLE?

Se puede decir que es el conjunto de procesos mediante los cuales las aplicaciones prestan sus objetos OLE para que sean manipulados desde otras aplicaciones que soporten esta tcnica. Cuando una aplicacin soporta la automatizacin OLE, se puede acceder a sus objetos desde Visual Basic. Mediante las tcnicas usuales de programacin en Visual Basic, es posible manipular esos objetos. De tal forma que se pueden invocar mtodos, fijar propiedades, etc., todo ello encaminado a manipular los objetos de otras aplicaciones.

17.3.3.- ACCESO A LOS OBJETOS OLE

Es posible manipular objetos OLE procedentes de otras aplicaciones, sin necesidad de crear objetos vinculados o incrustados. Esto se hace mediante la funcin CreateObject. Antes de crear un objeto, debemos definir una variable que pueda usarse como referencia al objeto. Esto se hace dimensionando una variable de tipo Object. Dim Documento As Object La funcin CreateObject necesita una cadena especificando el nombre de la aplicacin y el tipo del objeto que vamos a crear. Una aplicacin puede soportar diferentes objetos. Por ejemplo, la aplicacin llamada Documento puede tener los objetos prrafo y sentencia. Una vez que decidimos el objeto a crear, se asigna a la variable objeto el objeto devuelto por la funcin CreateObject. Set Documento = CreateObject("Documento.Prrafo")

Al ejecutar el cdigo, empieza a funcionar la aplicacin que suministra el objeto y se crea el propio objeto. En ningn caso aparece en la aplicacin Visual Basic una representacin o imagen del objeto, como ocurra con las objetos incrustados o vinculados en un control OLE. Sin embargo, y esto es lo importante, se puede acceder al objeto, desde Visual Basic, a travs de la variable objeto que hemos definido. Ejemplo Documento.Insert = "Ejemplo de automatizacin OLE" Documento.SaveAs = "F:\TC\EJ.DOC"

17.3.4.- UTILIZACIN DE LOS OBJETOS EXISTENTES

Si hemos utilizado el control OLE para crear un objeto vinculado e incrustado y si ese objeto soporta la automatizacin OLE, se puede acceder a las propiedades y mtodos de Visual Basic mediante la propiedad Object. Esta propiedad devuelve el objeto del control OLE. Ejemplo Supongamos que tenemos un control OLE que contiene un objeto que soporta la automatizacin OLE. Este objeto tiene los mtodos Insert y Select as como la propiedad Bold. La forma de usar ese objeto es: Ole1.Object.Insert "Hola, mundo" Ole1.Object.Select Ole1.Object.Bold = True

Si tenemos el objeto grabado en un fichero, la forma de acceder a ese objeto es mediante la funcin GetObject, la cual lleva como argumento el nombre del fichero. Ejemplo Supongamos que tenemos la aplicacin DOCUMENTO.EXE y creamos un objeto que le grabamos en el fichero PAG.DAT. Dim Documento As Object Set Documento = GetObject("F:\TC\PAG.DAT")

CAPTULO 18 LIBRERAS DE ENLACE DINMICO 18.1.- INTRODUCCIN

La gran proliferacin de las aplicaciones Windows en los ltimos aos se debe en gran medida al propio WINDOWS 3 que acerc la filosofa del "desktop computer" a los usuarios finales sin unos requerimientos de hardware excesivos y, en segundo lugar, a la aparicin de toda una serie de lenguajes o plataformas de desarrollo que permitan al programador y/o al usuario final desarrollar sus propias aplicaciones sin tener que recurrir al legendario y sin embargo tan odiado Windows Development Kit y al C. Ejemplos de esta nueva generacin de productos de todos conocidos son: Visual Basic, Visual C++ , Actor, Smalltalk, Realizer, Knowledge Pro, Liana, Turbo Pascal para Windows, etc. La filosofa en el desarrollo de aplicaciones difiere en cada uno de los productos anteriormente mencionados, sin embargo hay una caracterstica comn a todos y siempre destacada por sus fabricantes, "fcil acceso a DLLs". Tan importantes son las DLLs para la implantacin de estos productos en el mundo del desarrollo Windows? . La respuesta es rotunda: SI. Estos programas generalmente han sacrificado velocidad y programacin en bajo y medio nivel en aras de la facilidad y simplicidad. As es raro el desarrollador que trabaje con Visual Basic y no haya adquirido algn Custom Control (estos ficheros con extensin .VBX son en realidad DLLs que siguen unas especificaciones propias de Microsoft Visual Basic y que ofrecen un infinito campo de ampliacin al Visual Basic) o el que no se haya visto en la necesidad de generar una DLL en C, C++ o en ensamblador para evitar las limitaciones de este entorno de desarrollo. Como veremos el uso de DLLs no solo se ve justificado como ampliacin de entornos de desarrollo sino tambin como manera eficaz de compartir rutinas comunes entre programas que se encuentran ejecutndose concurrentemente.

18.2.- DEFINICIN Y USO DE LAS DLLs

Como ya sabrs una de las capacidades innovadoras que Windows tom prestado del mundo de los grandes ordenadores es el enlace dinmico. En el viejo entorno DOS los programadores deban enlazar las funciones contenidas en las libreras en tiempo de compilacin. Windows permite enlazar las funciones de las libreras en tiempo de ejecucin, posibilitando que varios programas ejecutndose concurrentemente, compartan una misma librera de enlace dinmico. Windows es en si mismo un compendio de DLLs, siendo las principales GDI.EXE, USER.EXE, KRNL386.EXE .

El programador en Visual Basic se ve abocado en numerosas ocasiones a utilizar las funciones contenidas tanto en las DLLs de Windows como en las DLLs distribuidas o vendidas por terceros. Gracias a las facilidades que Visual Basic ofrece, podemos llamar en cualquier momento a las diversas funciones del API de Windows, permitiendo gran flexibilidad a nuestros desarrollos. No hay que olvidar, que los Custom Controls son quiz la aportacin ms destacada de Visual Basic a la comunidad informtica, y que dichos controles no son ms que DLLs que siguen una estricta estructura definida por Visual Basic.

18.3.- DECLARACIN DE PROCEDIMIENTOS CONTENIDOS EN DLLs

Como sabemos cualquier librera, ya sea de enlace dinmico o sea esttica, contiene una serie de procedimientos que son llamados, bien en tiempo de compilacin o en tiempo de ejecucin, por un determinado programa que utilice los procedimientos de dicha librera. Visual Basic necesita informacin adicional para poder llamar a los procedimientos de las DLL s. Para facilitrsela debemos declarar cada procedimiento en la seccin de declaraciones de una Form o de un mdulo de cdigo. La sentencia encargada de realizar la tarea descrita anteriormente es: DECLARE, cuya sintaxis mostramos a continuacin : DECLARE Sub NombreProcedimiento Lib "NombreLibreria" [Alias "NombreAlias"] [([Lista de Argumentos])] DECLARE Function NombreProcedimiento Lib "NombreLibreria" [Alias "NombreAlias"] [([Lista de Argumentos])] [As Tipo]

Como te podrs imaginar el uso de Sub o Function queda definido cuando el procedimiento devuelva o no un determinado valor de retorno. Todos los usuarios de la edicin profesional de Visual Basic pueden encontrar en el subdirectorio \WINAPI un fichero de texto "WINAPI.TXT" que contiene las definiciones standard de todas las funciones del API de Windows 3.1 . Te aconsejamos que selecciones las declaraciones necesarias del fichero "WINAPI.TXT" pues si lo cargas como mdulo desde Visual Basic, se producir una penalizacin importante en la carga y compilacin de nuestro proyecto. Tambin puedes encontrar en este subdirectorio dos ficheros de ayuda que contiene informacin adicional sobre funciones, mensajes y estructuras del API de Windows. Es posible, que cuando queramos utilizar un procedimiento de una determinada DLL, el nombre de ste, coincida con una palabra reservada de Visual Basic, lo que invalidara su uso. Supongamos que estamos utilizando una DLL que contiene procedimientos de manejo de bases de datos, la funcin encargada de abrir una determinada base de datos se denomina OPEN, como observars coincide con

una palabra reservada de Visual Basic. Para solucionar este inconveniente utilizaremos la sentencia Alias en la declaracin de la funcin. El siguiente ejemplo muestra el uso de la sentencia Alias: DECLARE Function AbrirFichero Lib "C:\WINDOWS\XBASE.DLL" Alias "Open" (ByVal NombreFichero As String]) As Integer En la anterior declaracin podemos observar que sustituimos el nombre verdadero de la funcin Close por el nombre AbrirFichero que ser el que utilizaremos en posteriores llamadas a esta funcin. Como se puede ver, en la declaracin anterior se especifica la DLL a la que pertenece la funcin y el path correspondiente.

18.4.- LLAMADAS A PROCEDIMIENTOS CONTENIDOS EN DLLs

Tras la declaracin de la funcin anterior podemos llamarla desde cualquier lugar de nuestro cdigo. A continuacin se presenta un ejemplo de llamada a la funcin anterior: Ejemplo Sub Form_Load () ValorRetorno% = AbrirFichero ("C:\DBASE\ALUMNOS.DBF") End Sub

Hay que verificar siempre la correcta declaracin de los argumentos que son pasados a los procedimientos contenidos en las DLLs.

18.5.- DEFINICIN DE LOS TIPOS DE ARGUMENTOS

18.5.1.- ARGUMENTOS POR VALOR O POR REFERENCIA

Visual Basic realiza el paso por defecto de argumentos a los procedimientos por referencia, es decir, Visual Basic pasa una direccin de 32 bits por cada argumento. Esta direccin seala el lugar de la memoria en que se encuentra el valor del argumento referenciado. Al contrario que lo dicho anteriormente, el C pasa los argumentos por valor, es decir, que pasa una copia del valor del argumento. Como ya sabrs la gran mayora de las DLLs han sido escritas en C y por lo general esperan que los argumentos que le sean pasados lo sean por valor y no por referencia. Si esto sucede, se suele producir generalmente la cada del sistema.

Pero Visual Basic nos ofrece la posibilidad de pasar argumentos por valor a las DLLs. Tan solo hemos de indicarlo en la declaracin de argumentos. El modificador ByVal indica al compilador que el argumento que sigue ser pasado por valor. El siguiente ejemplo ilustra el uso del modificador ByVal en la sentencia Declare: Declare Function AddFontResource Lib "GDI" (ByVal lpFilename As Any) As Integer

18.5.2.- ARGUMENTOS FLEXIBLES

Como vemos, en el ejemplo anterior se produce la declaracin del argumento lpFilename para que sea pasado por valor, pero hemos utilizado un nuevo tipo "any". Este nuevo tipo nos ofrece la posibilidad de utilizar argumentos flexibles. Algunas funciones de DLLs pueden admitir diferentes tipos de datos para un mismo argumento. Vamos a declarar una misma funcin, primero con la sintaxis del C y despus con la sintaxis del Visual Basic, para que el alumno pueda entender el uso del tipo any. HBITMAP CreateBitmap(nWidth, nHeight, cbPlanes, cbBits, lpvBits) int nWidth; int nHeight; UINT cbPlanes; UINT cbBits; const void FAR* lpvBits; entero, Ancho del Bitmap entero, Largo del Bitmap Nmero de planos de color Nmero de bits por pixel Direccin de un array de Bits

Declare Function CreateBitmap Lib "GDI" (ByVal nWidth As Integer, ByVal nHeight As Integer, ByVal nPlanes As Integer, ByVal nBitCount As Integer, ByVal lpBits As Any) As Integer En la declaracin anterior podemos observar que el argumento lpBits ha sido declarado como de tipo Any, pues se puede llamar a esa funcin con un puntero (Long) o con un array de enteros en ese mismo argumento.

18.5.3.- STRINGS COMO ARGUMENTOS

Casi todas las funciones contenidas en las DLLs que contiene el API de Windows esperan que los strings que le sean pasados como argumentos, estn definidos como Strings del C standard, es decir, strings que terminan con el carcter nulo (ANSI cero). Hay que recordar que los string de Visual Basic no terminan con el carcter nulo y por tanto son formalmente incompatibles con los string del c standard. No hay que mencionar que es lo que suceder cuando suministremos como argumento a una funcin que espera un string del C standard, un string de Visual Basic.

Para indicar al compilador que transforme un string Visual Basic a string C standard aadiendo el carcter nulo al final de dicho string, tan solo tenemos que emplear el modificador ByVal. Cuando empleamos el modificador ByVal con un string no es pasado por valor, sino que es transformado a string del C standard aadiendo el carcter nulo. Hay que mencionar que es posible disear DLLs que acepten strings de Visual Basic. En este caso no es necesario emplear el modificador ByVal en la declaracin de la funcin. Todos los strings son pasados a las funciones por referencia, por lo tanto las funciones pueden modificar el contenido de los strings, pero las funciones no pueden aumentar la longitud del string en cuestin, por lo tanto si la funcin intenta modificar la longitud del string lo nico que har ser sobrescribir el contenido de las zonas de memoria adyacentes con el consecuente peligro para la integridad del sistema. Debido a todo lo mencionado anteriormente tenemos que declarar los argumentos de string pertenecientes a funciones que puedan modificar su longitud, de modo que tengan suficiente capacidad para que las funciones de las DLLs nunca sobreescriban la memoria adyacente al superar la capacidad de los strings.

18.5.4.- ARRAYS COMO ARGUMENTOS

Si queremos pasar cualquier elemento de un array tan solo hay que indicarlo en la funcin: resultado% = FuncionPasoElementoArray ( GranArry(3459) ) Si queremos pasar el array por completo a un procedimiento contenido en una DLL puede ocurrir dos cosas: A) Que dicha DLL haya sido especialmente diseada para trabajar con cualquier array de Visual Basic. En cuyo caso no existir ningn tipo de problema, y se pasar el argumento con el nombre del array en cuestin seguido de unos parntesis vacos. resultado% = FuncionPasoTodosLosElementosArrayVB ( GranArry( ) ) B) Si la DLL no acepta los arrays de Visual Basic directamente tan solo podemos pasar arrays numricos, y esto se consigue pasando el primer elemento del array. resultado% = FuncionPasoTodosLosElementosArray ( GranArry(0) )

18.5.5.- TIPOS DEFINIDOS POR EL USUARIO COMO ARGUMENTOS

Cuando utilicemos algunas de las mltiples funciones del API de Windows ser necesario pasar argumentos que contengan datos de tipo definido por el usuario. Como los arrays, podemos pasar cualquier elemento de dicha estructura definida por el usuario.

Tambin podemos pasar estructuras completas, pasndolas por referencia, pues as facilitamos al compilador la direccin del primer elemento de dicha estructura. El siguiente ejemplo muestra lo dicho anteriormente : Ejemplo Primero definimos la estructura RECT: Type RECT left As Integer top As Integer right As Integer bottom As Integer End Type Dim EstructuraRect as RECT

Definimos la subrutina DrawFocusRect Declare Sub DrawFocusRect Lib "User" (ByVal hDC As Integer, lpRect As RECT) HnadleDC% = 1345 EstructuraRect .left = 100 EstructuraRect .top = 100 EstructuraRect .right = 500 EstructuraRect.bottom = 500 Para llamar a esta subrutina solo tenemos que llamarla con los siguientes parmetros: DrawFocusRect (HnadleDC% , EstructuraRect) Si la DLLs no ha sido especficamente diseada para ser utilizada desde Visual Basic, no es posible utilizar Strings de longitud variable como miembro de estructuras definidas por el usuario.

18.5.6.- PUNTEROs NULOS COMO ARGUMENTOS

Suele ser usual que una DLL que haya sido diseada en C o en C++ espere como argumento, de algunas de sus funciones, un puntero nulo. Como ya sabemos, en Visual Basic no existe el concepto de puntero, pero es posible simular el paso de punteros nulos a procedimientos. Para simular el paso de punteros nulos, primero debemos declarar el argumento como Any y despus pasar la expresin ByVal 0&.

18.5.7.- HANDLES COMO ARGUMENTOS

Windows como entorno operativo grfico usa extensivamente handles. Podemos definir los handles como enteros de 16 bits que se refieren a un objeto creado o usado por una aplicacin. Los handles en Windows son similares a los handles de ficheros convencionales en el DOS. Windows identifica todos los objetos como instancias de aplicacin, ventanas, mens, controles, zonas de memoria, ficheros, objetos del GDI. con Handles. La mayora de los handles son ndices de tablas que Windows maneja internamente. As nuestros programas solo tienen acceso a los handles pero no a los datos a los que apuntan, pues esto es tarea exclusiva de Windows. Un programa Windows debe casi siempre obtener un handle para llamar a cualquier funcin Windows. El valor de un determinado handle carece de importancia para nuestro programa pero es de vital importancia para Windows, pues identifica biunivocamente el objeto al que se refiere con las propiedades que le otorga Windows. Cuando un argumento de una Funcin perteneciente a alguna DLL espera el valor de un handle debe ser declarado como ByVal Integer. Recuerda que no se pueden realizar operaciones matemticas con handles aunque sean enteros, pues esto podra provocar la cada del sistema.

18.5.8.- PROPIEDADES COMO ARGUMENTOS

Podemos pasar propiedades de los Objetos de Visual Basic como argumentos. Las propiedades deben ser pasadas por valor (ByVal) . El siguiente ejemplo muestra la declaracin de la funcin ReleaseDC que liberara el Contexto de Dispositivo utilizando como argumentos el Handle de la Ventana propietaria del DC y el DC en si. Declare Function ReleaseDC Lib "User" (ByVal hWnd As Integer, ByVal hDC As Integer) As Integer ValorRetorno% = ReleaseDC ( Ventana1.hWnd, Pinter.hDC ) Como vemos en la declaracin del argumento hWnd este ha sido declarado por valor y por tanto podemos utilizar directamente la propiedad Ventana1.hWnd como argumento.

CAPTULO 19 CUSTOM CONTROLS 19.1.- INTRODUCCIN

En este capitulo vamos a comentar el uso y las funciones de los 22 Custom Controls que forman parte de la versin Profesional de Visual Basic 3.0. Como ya sabrs un Custom Control es una extensin al entorno de programacin Visual Basic. Estos controles actan de la misma manera que los controles estndar de Visual Basic y al igual que ellos, se sitan grficamente en la Caja de Herramientas. Quiz sea la aportacin por parte de Visual Basic de estos controles desarrollados por terceros una de sus ms destacables caractersticas. Hay que mencionar que hoy en da ha surgido un floreciente mercado de estos Custom Controls. La mxima de todo programador debe ser: "no reinventes la rueda" y los Custom Controls son la prctica de la mxima anterior. Para que vamos a perder semanas y semanas intentando codificar una pequea hoja de clculo si en el mercado existe un Custom Control que nos ofrece una hoja de clculo de impensable potencia para poderla incorporar a nuestros desarrollos. Gracias a la edicin profesional de Visual Basic 3.0 podemos disponer de ms de 20 Custom Controls que nos permitirn entre otras muchas cosas, aadir un look tridimensional a nuestros desarrollos, utilizar rboles jerrquicos de directorios, incorporar rutinas de comunicacin y de grficos financieros en nuestras aplicaciones as como desarrollar aplicaciones multimedia y aplicaciones orientadas al uso de la tecnologa Pen Windows . En el presente captulo nos vamos a dedicar a enumerar las principales caractersticas de estos Custom Controls. Hay que decir que dado el elevado nmero de ellos y las muchas propiedades que contienen, resulta inviable en este curso el hacer una descripcin pormenorizada de ellos. La versin profesional de Visual Basic incluye un manual en el que se describen en detalle. Adems, y a estas alturas de curso, el alumno debe estar preparado para utilizar cualquier control de Visual Basic. Como estos controles siguen la misma filosofa que los descritos a lo largo del curso, solo es necesario consultar el manual para determinar los valores de las propiedades en virtud del trabajo que queramos hacer.

19.2 TIPOS DE CUSTOM CONTROLS

Podemos definir un fichero Custom Control como una DLL (Dinamic Link Library) que contiene toda una serie de servicios que Visual Basic utilizar para proveer facilidades adicionales a nuestros programas. Estos controles pueden ser desarrollados por terceras compaas o por nosotros mismos con la ayuda del Visual Basic Control Development Kit y cualquier compilador de C o de Pascal. En este captulo vamos a hacer una clara diferenciacin entre los Custom Controls standard que son los que vienen incluidos en la versin profesional de Visual Basic 3.0 y los Custom Controls no Standard que son controles distribuidos por terceras empresas y que abarcan un amplio abanico de posibilidades. Estos ltimos sern cubiertos en el Apndice 1. La Fig. 19.1a muestra los Custom Controls que se distribuyen con la versin Profesional de Visual Basic 2.0, mientras que la Fig. 19.1b lo hace para la 3.0. Fig. 19.1a. Custom Controls en Microsoft Visual Basic 2.0 Professional Edition.

Fig. 19.1b.- Custom Controls en Microsoft Visual Basic 3.0 Professional Edition.

Para cargar un Custom Control tan solo tenemos que seleccionar la opcin Add File del men File y seleccionar el fichero correspondiente al Custom Control escogido. El fichero seleccionado aparecer en la ventana Project y en la caja de herramientas. Desde ese momento podemos utilizar nuestro nuevo Custom Control como si se tratara de cualquier control standard de Visual Basic. Cuando llegue el momento de crear la versin definitiva de nuestro desarrollo creando el fichero .EXE final, debemos incluir los ficheros correspondientes a los Custom Controls usados en l. Lo ficheros correspondientes a los Custom Control deben residir en el mismo directorio donde se encuentra nuestro fichero .EXE o bien en cualquier directorio que se encuentre incluido en el Path. Es recomendable que cuando distribuyamos nuestros desarrollos instalemos los ficheros correspondientes a los Custom Controls en el directorio /Windows/System. A modo de resumen, podemos decir que cuando distribuyas a terceros tus desarrollos debes incluir: - Programa .EXE - Fichero run-time de Visual Basic (VBRUN200.DLL). - Ficheros de libre distribucin correspondientes a los Custom Controls. La versin profesional de Visual Basic 2.0 incluye un fichero: VB.LIC que es el que nos permitir usar los Custom Controls que en l se incluyen. Digamos que este fichero es la

licencia de uso en tiempo de diseo de los Custom Controls, por lo tanto no estamos autorizados a distribuir este fichero con nuestros desarrollos. Sin este fichero, solo podemos hacer uso de los Custom Controls incluidos en modo de ejecucin.

19.2.1. - CUSTOM CONTROLS STANDARD

Dado que Microsoft no ha lanzado versin en castellano de este producto y para evitar posibles confusiones hemos preferido no traducir el nombre de los diferentes controles. Consiguientemente, sern llamados por el correspondiente nombre en ingls que Microsoft pone en los manuales.

19.2.1.1.- 3D Check Box Gracias a este control podemos aadir un aspecto tridimensional a las casillas de verificacin standard de Visual Basic. Como facilidad adicional podemos situar el texto a la derecha o a la izquierda. La Fig 19.2 muestra un ejemplo de este control.

Fig. 19.2. 3D CheckBox. En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.2.- 3D Option Button Gracias a este control podemos aadir un aspecto tridimensional a los Botones de Opcin standard de Visual Basic. Al igual que con el anterior control, podemos situar el texto a la derecha o a la izquierda. La Fig. 19.3 muestra un ejemplo de este control.

Fig. 19.3. 3D Option Button.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.3.- 3D Command Button Este control nos permite aadir un aspecto tridimensional a los botones de comando standard de Visual Basic. Adems podemos incluir un bitmap o icono en el interior del botn, podemos controlar la anchura del bisel, lo que marcar la apariencia tridimensional. Tambin podemos definir distintos tipos de representacin del texto que dar lugar a la apariencia tridimensional. La Fig. 19.4 muestra un ejemplo de este control.

Fig. 19.4. 3D Command Button.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.4.- 3D Frame Este control nos permite aadir un aspecto tridimensional al control Frame standard de Visual Basic, que sirve como contenedor de otros controles. Como hacamos con otros controles podemos utilizar texto con apariencia tridimensional y tambin podemos elegir la localizacin del texto (izquierda, derecha, centro). La Fig. 19.5 muestra un ejemplo de este control.

Fig. 19.5. 3D Frame.

Como puedes observar en la figura anterior podemos escoger la apariencia tridimensional de las lneas que forman los lmites grficos de este control. En la figura se han diseado tres de los posibles tipos de lneas. En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.5.- 3D Group Push Button Este control es un botn de seleccin que cambia su estado cuando es pulsado/soltado. Podemos asignar Bitmaps o Iconos a estos botones. Al incluir este control en nuestros desarrollos podemos emular la apariencia de la barra de herramientas de Microsoft Word o Excel. La Fig. 19.6 muestra un ejemplo de este control.

Fig. 19.6. 3D Group Push Button. En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.6.- 3D Panel Este control tridimensional nos sirve para mostrar texto normal o tridimensional, en un panel tridimensional, para incluir otros controles dentro de este fondo tridimensional. Puede ser utilizado como barra tridimensional de Status o bien como barra dinmica coloreada que indica el porcentaje de determinadas acciones. La Fig. 19.7 muestra un ejemplo de este control.

Fig. 19.7. 3D Panel.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control. Todos los controles tridimensionales nombrados anteriormente han sido diseados por la compaa SHERIDAN SOFTWARE SYSTEMS Inc. y estn incluidos en el fichero THREED.VBX.

19.2.1.7.- Animated Button Este control permite insertar animaciones, mediante la sucesiva aparicin de imgenes en formato Metafile, Icon o BitMap. Dentro de este control podemos diferenciar tres tipos de Botones: Botones Animados: podemos animar cualquier secuencia grfica que aparecer dentro de los lmites del control. Botones multiestado: son botones que cambian su apariencia conforme al estado en que se encuentran (por ejemplo, la imagen de un semforo que cambia el color segn el estado en que se encuentre la lgica del programa). Casillas de Verificacin animadas: son similares a las Casillas de Verificacin standard de Visual Basic pero con la particularidad de mostrar imgenes relacionadas con el estado y significado de dicho control. La Fig. 19.8 muestra grficamente los diferentes tipos de este control.

Fig. 19.8. Animated Buttons.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.8.- Common Dialog Este control nos provee de acceso directo al conjunto de Cajas de Dilogo comunes que forman parte de Windows 3.1. Recordemos que estas Cajas de Dilogo se encuentran codificadas en el archivo COMMDLG.DLL y que su uso facilita y standariza la utilizacin de los Cuadros de Dilogo ms comunes en nuestras aplicaciones. Podemos enumerar los diferentes Cuadros de Dilogo que se encuentran a nuestro alcance con la utilizacin de este control: - Apertura de Ficheros. - Grabado de Ficheros - Eleccin de Color - Eleccin de Fuentes - Accin de Impresin

Las figuras que vienen a continuacin son un ejemplo de cada uno de los cuadros de dilogo que hemos comentado.

Fig. 19.9. Cuadro de Dilogo para la eleccin de un fichero.

La Fig. 19.9 nos permite utilizar esta Caja de Dialogo standard para que el usuario final pueda escoger un determi.nado fichero. Podemos suministrar como parmetros a este dilogo los diferentes tipos de archivos a mostrar as como el path por defecto.

Fig. 19.10. Cuadro de Dilogo para grabar un fichero.

El dialogo de la Fig. 19.10 nos permite utilizarlo como Caja de Dialogo standard para que el usuario final pueda poner el nombre de un determinado fichero y que pueda ser grabado posteriormente. Podemos suministrar como parmetros a este dilogo los diferentes tipos de archivos a salvar, as como el path por defecto.

Fig. 19.11. Cuadro de Dilogo para la eleccin de color.

La Fig. 19.11 nos permite disponer de esta Caja de Dilogo standard para que el usuario final pueda escoger un determinado color. Podemos suministrar como parmetros a este dialogo el color por defecto y los colores definidos por el usuario.

Fig. 19.12. Cuadro de Dilogo para la eleccin de los tipos de letra.

En el cuadro de la Fig. 19.12, podemos suministrar como parmetros a este dilogo la font por defecto as como sus caractersticas(tamao, estilo, color, etc)

Fig. 19.13. Cuadro de Dilogo para las opciones de impresin. El dialogo precendente nos permite utilizarlo como Caja de Dialogo standard para que el usuario final pueda controlar la impresion de sus documentos. Podemos suministrar como parametros a este dialogo el rango de impresin. Es posible iniciar la puesta a punto de la impresora desde este dilogo (Setup). En la gua de Referencia de los Custom Controls puedes

obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.9.- Communications Gracias a este control es posible incorporar rutinas de comunicaciones en nuestros desarrollos. As podemos transmitir y recibir datos a travs de nuestro puerto serie. No hace falta mencionar que las rutinas de comunicacin son complejas y muy especializadas lo que hace poco viable la inclusin de estas capacidades de comunicacin en nuestros aplicaciones. En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.10.- Gauge Este control nos ofrece la posibilidad de construir indicadores o medidores segn nuestras necesidades. El uso de este control se hace indispensable para los desarrolladores de controladores grficos de aparatos de medida. As es posible definir grficamente termmetros, indicadores de tanto por ciento, o cualquier tipo de indicador analgico. Es posible definir la imagen que servir como fondo de dichos indicadores, lo que nos permitir una gran personalizacin de nuestro trabajo. La Fig. 19.14 muestra las innumerables posibilidades de este control.

Fig. 19.14. Varios usos del control Gauge.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.11.- Graph

Nos encontramos ante un Custom Control que nace de la adecuacin de una librera de grficos ya conocida en el mercado de las herramientas de desarrollo para C, como es GRAPICHS SERVER, al mundo de los Custom Controls para Visual Basic. Este control acta como puente entre la potente librera orientada al manejo de grficas ya mencionada anteriormente y Visual Basic. Por lo tanto salva la complejidad de manejo de esta librera en C y se introduce en el "mundo" de la sencillez y rapidez de desarrollo de Visual Basic. Hay que mencionar que este control tiene estructura de Cliente/ Servidor y soporta mltiples clientes simultneamente. Esto quiere decir que podemos ejecutar a la vez varios programas que hagan uso de los servicios de este servidor grfico sin ningn tipo de conflicto entre ellos. Como ventajas adicionales de la inclusin de este control en nuestros desarrollos podemos encontrar: - Salida de las imgenes de los diversos tipos de grficos directamente a pantalla, disco, o portapapeles, permitindonos esta ltima opcin escoger el formato (Bitmap/Windows Metafile). - Salida de los grficos por impresora a la mxima resolucin que sta permita. Las diversas propiedades que tiene cualquier objeto Graph las podemos dividir en 5 grandes grupos: CONTROL: Dentro de esta clasificacin se encuentra todas las propiedades que condicionan el manejo en si de los datos a representar. Podemos definir el nmero de puntos / conjuntos (Topologa Fila/Columna) a representar. ESTILO: Dentro de estas propiedades podemos destacar aquellas que nos permitirn especificar el fondo del grfico, el ttulo del grfico, el estilo (2 o 3 dimensiones, de Barras, de Tarta, Grant, Polar, Lineal, HLC, de Area, Max/Min, etc.), nmero y tipos de las etiquetas, tipos de lneas ( colores y texturas ), etc. ARRAY: Podemos definir las propiedades del conjunto de datos a representar (Color, Textura, Patrones, Tipo de Grfico, Etiquetas, Ttulos, Subttulos). TECNICO: Definiremos el tipo de archivo (Bitmap/Metafile) en el cual se guardar la imagen de nuestro grfico y podremos mandar esta imagen directamente a un control de dibujo standard de Visual Basic para posteriores manipulaciones (estrechar/agrandar). STANDARD: En este grupo se encuentran las propiedades comunes con los controles standard de Visual Basic (CtlName, DragIcon, DragMode, etc.). Con este control especializado, podemos disear grficos interactivamente. As podemos suministrar toda una serie de valores que servirn para generar un determinado grfico, este podr ser dibujado en pantalla, enviado al Clipboard o impreso. La Fig. 19.15 muestra los diferentes tipos de grficos realizados con este control.

Fig. 19.15. Ejemplo de grficos generados con el control Graph.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.12.- Key Status Este control nos permite mostrar y cambiar el estado de las teclas CAPS LOCK, NUM LOCK, INS y SCROLL LOCK. En la Fig. 19.16 se indica una representacin grfica de este control.

Fig. 19.16. Control Key Status.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.13.- MAPI Primero vamos a definir MAPI como interface de programacin de mensajera entre aplicaciones, es decir, toda la serie de servicios y funciones necesarias para ofrecer al desarrollador un interface que le permita incluir en sus desarrollos capacidades de correo electrnico. Existen dos tipos de controles MAPI:

Session Mapi: que es el encargado de comenzar la sesin inicializando automticamente toda una serie de estructuras. Mensaje Mapi: proveer toda una serie de facilidades y funciones para realizar una variedad de funciones de mensajera electrnica. Como te podrs imaginar dada la funcin de estos dos controles, permanecen invisibles en tiempo de ejecucin. Este control esta especialmente orientado a aquellos desarrollos que se quieran ejecutar bajo Windows Trabajo en Grupo En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.14.- Masked Edit

El control Masked Edit nos permite especificar patrones de entrada as como formatear los datos para ser mostrados posteriormente. Hay que mencionar que este control se comporta igual que la Caja de Texto standard de Visual Basic. La nica diferencia entre ambos radica en las capacidades de formatear la entrada y salida de datos que tiene Masked Edit. Si no utilizamos las capacidades de formateo mencionadas anteriormente, este control se comportara igual que la Caja de Texto standard. La Fig. 19.17 muestra grficamente este control.

Fig. 19.17. Control Masked Edit.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.15.- Multimedia MCI Este control maneja la reproduccin y grabado de ficheros Multimedia (ficheros de audio, imagen, video, midi, etc.). Para estas funciones utilizan dispositivos MCI (Media Control Interface). Grficamente este control se muestra como una serie de botones de comando que se asemejan a los encontrados en un reproductor de video standard (ver Fig. 19.18). Para que este control pueda funcionar deben estar presentes los servicios MCI que forman parte de Windows 3.1 as como de las Extensiones Multimedia.

Fig. 19.18. Ejemplo del control multimedia MCI.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.16.- PEN Edit Dentro de este Custom Control podemos diferenciar dos: BEdit: es un control similar a la caja de texto estandar con la particularidad de estar orientado al uso de la tecnologa Pen. HEdit: similar a a las cajas combinadas pero aprovechando la entrada Pen. Los controles anteriores nos permiten desarrollar aplicaciones que se aprovechen de los servicios de la tecnologa Pen Computing y funcionar bajo el entorno Pen Windows. La Fig. 19.19 muestra la apariencia grfica de estos controles.

Fig. 19.19. Representacin grfica de los controles que dispone Pen Edit.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.17.- PEN Ink On BitMap Como los anteriores, este Custom Control est orientado a ser empleado bajo Microsoft Windows for Pen Computing. Es un control de Caja de Dibujo mejorado, que permite dibujar y borrar tinta en un determinado BitMap. Hay que aclarar que el termino Tinta se refiere a todo lo que dibujemos y/o borremos encima del BitMap. Podemos salvar la Tinta de tres maneras diferentes: como BitMap, como Tinta o como BitMap que combine lo escrito y el bitmap de fondo. Como se puede ver en la Fig. 19.20, la salida grfica de estos controles, en combinacin con bitmaps, puede reportar bastante espectacularidad.

Fig. 19.20. Ejemplo del control Ink On Bitmap.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.18.- PEN Ink On Screen Keyboard

Tambin este Custom Control esta orientado a ser empleado bajo Microsoft Windows for Pen Computing. Este control nos permite acceder al teclado en pantalla, que es un servicio que provee Windows for Pen Computing sin utilizar el complejo API de la tecnologa Pen. Hay que recordar que bajo la tecnologa Pen, el teclado tiene una importancia secundaria e incluso se puede prescindir de su utilizacin, y es aqu donde este control se nos hace verdaderamente til. Las siguientes figuras (Fig. 19.21) muestran las diferentes apariencias grficas de este control.

Fig. 19.21. Ejemplo del control Pen Ink On Screen Keyboard.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.19.- Picture Clip Podemos utilizar este control para seleccionar un rea determinada de un BitMap y mostrar el rea definida en una Caja de Dibujo o en una Form. Como vers este control nos ofrece una gran facilidad para almacenar mltiples recursos de dibujos. Imagnate si queremos mostrar 25 iconos diferentes a la vez. La solucin tradicional sera emplear 25 cajas de dibujo con el consecuente gasto de recursos del sistema. Si embargo, podemos definir un BitMap que contenga a los 25 iconos a la vez y cuando queramos escoger un icono determinado utilizaremos el Control Picture Clip para seleccionar la regin correspondiente a ese BitMap La figura 19.22 muestra la apariencia grfica de este control.

Fig. 19.22. Ejemplo de salida grfica del control Picture Clip Control.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.20.- Spin Button Podemos definir a un Boton Spin como una generalizacin de las barras de desplazamiento, que nos permitirn en conjuncin con cualquier otro control, aumentar y disminuir valores. Los Botones Spin son representaciones de cabezas de flechas que intuitivamente y de forma grfica, nos indican que su uso aumentar o disminuir el valor del control al que califican. As podemos utilizar los Botones de Spin para aumentar o disminuir valores numricos que son mostrados en una Caja de Texto. La figura 19.23 muestra una posible representacin este control.

Fig. 19.23. Control Spin Button.

En la gua de Referencia de los Custom Controls puedes obtener informacin detallada sobre las Propiedades, Eventos y Mtodos de este Custom Control.

19.2.1.21.- Outline. Con motivo de seguir mejorando la presentacin de la informacin y de adoptar las mayores cualidades de Windows, la edicin profesional de Visual Basic 3.0 incorpora un nuevo "custom control". Este es el control Outline, el cual permite presentar una lista jerrquica de ficheros y directorios, de semejante trazo a la que incorpora Windows en su administrador de archivos. El nombre genrico del fichero que contiene este control es MSOUTLIN.VBX. Hay que decir, que el Visual Basic no incluye por defecto este control en la caja de herramientas, por lo que habr que aadirlo si es que se quiere utilizar. Ya sabemos que la forma de aadir un control es mediante la opcin Add File del men File. Microsoft define a este control como una caja de listas organizada jerrquicamente y en la que cada uno de los items puede tener varios niveles de items subordinados, los cuales aparecen representados en los diferentes niveles de identacin. Como bien sabrn todos aquellos que hayan utilizado el administrador de archivos de Windows (Fig. 19.24), los diferentes items se pueden expandir o contraer. El ejemplo ms claro es el de un rbol de ficheros y directorios. El primer item ser el nombre del directorio raiz y tendr como items subordinados todos los directorios que cuelguen de l. A su vez, dentro de cada

directorio pueden aparecer diferentes niveles de subdirectorios y dentro de stos otros subdirectorios o incluso ficheros.

Fig. 19.24.- Administrador de archivos de Windows. Estructura jerrquica de directorios.

El rbol completo de un directorio indica que ste est expandido, pero si slo aparece el propio directorio, se dice que est contraido. Tambin es sabido, que asociado a cada item puede aparecer algn elemento grfico como las pequeas carpetas y hojas que aparecen en el administrador de archivos. Cada item puede tener texto o grficos, de modo que pueden visualizarse hasta cinco elementos (Fig. 19.25):

Fig. 19.25.- Elementos del control Outline.

- Lneas de rbol, las cuales son las conocidas lneas horizontales y verticales que unen diferentes items en una organizacin jerrquica. - Indentacin, que a pesar de su extrao nombre no es otra que esos espaciados que sirven para indicar items subordinados. - Dibujos ms/menos. Estos pequeos iconos con su respectivo signo +/-, sirven para indicar si se visualizan o no los items subordinados. As cuando hacemos un doble click sobre el signo +, se depliegan los items subordinados que cuelgan de ese item. Si por el contrario se pulsa sobre el signo -, se esconden los items subordinados y queda nicamente el item principal. - Imgenes de tipo, las cuales nos muestran desde un punto de vista grfico el estado de un item, es decir, si puede ser expandido o contraido. - Texto. Es la cadena de caracteres que describe a cada item. Todos los elementos grficos que hemos comentado se pueden o no visualizar, e incluso se pueden visualizar unos y no otros. La propiedad Style es la que nos permite determinar qu elementos grficos van a aparecer con cada item. El control Outline, como el resto de los controles, presenta muchas propiedades, mtodos y eventos. La descripcin completa de esos elementos se pueden encontrar en el apndice A del libro 1 de la edicin profesional y en el manual de referencia.

CAPTULO 20

CONTROL DE ACCESO A BASES DE DATOS

20.1.- INTRODUCCIN
El Control de acceso a bases de datos recin incorporado a la nueva versin de Visual Basic (y que se presenta como el control estrella de esta nueva versin) permite a cualquier usuario la posibilidad de realizar la creacin e interrogacin de cualquier base de datos con relativa facilidad. No debe escaparse al alumno que uno de los usos ms extendidos del Visual Basic en el mundo informtico es como Front End de aplicaciones que manipulan bases de datos. Visual Basic 3.0 implementa el acceso a bases de datos a travs del gestor de bases de datos de Microsoft Access 1.1 (Access es el producto estrella de Microsoft en el campo de la gestin de bases de datos y se est convirtiendo en un estndar de facto). Antes de introducir al alumno en el uso de este control vamos a repasar toda una serie de conceptos relacionados con las bases de datos y su gestin.

20.2.- BASES DE DATOS - CONCEPTOS BSICOS

Una base de datos es una coleccin de informacin relacionada con un tema o propsito particular. Por ejemplo, los registros de los empleados de una gran fbrica, los datos de una agenda telefnica, un conjunto de facturas, etc. Un sistema de administracin de bases de datos (DBMS) es un sistema que almacena, recupera y gestiona la informacin de una base de datos. En nuestro sistema el DBMS es el motor del Access 1.1 y que forma parte del kernel de Visual Basic 3.0 . Access es un sistema de bases de datos relacionales. De ese modo, es posible organizar los datos por temas que nos facilitarn la bsqueda y verificacin de los datos deseados. Pero veamos un ejemplo de lo expuesto anteriormente: Imaginemos una pequea empresa de distribucin. Como tal, dispondr de toda una serie de informacin de muy distinta naturaleza pero relacionada por su uso en la misma empresa. Entre esta informacin podemos destacar : listas de proveedores, listas de clientes, agenda telefnica, facturas, informacin sobre los productos a distribuir, etc.

Como se puede observar toda esta informacin parece dispersa y la nica relacin que podemos establecer a priori, es la que nos viene dada por el uso de toda ella en la misma empresa. Posiblemente, esta informacin se encuentre almacenada en diferentes medios y/o formatos (as por ejemplo, las facturas estaran en soporte magntico, las listas de proveedores se encontraran bajo papel impreso y el directorio telefnico se reduce simplemente a una ingente cantidad de tarjetas en un cajn). Vemos claramente que hay toda una serie de informacin repetida, los telfonos pueden ser de los clientes o proveedores, los clientes y proveedores aparecern repetidos en las facturas, etc. Si dispusiera esta empresa de la posibilidad de incorporar para su funcionamiento de una base de datos relacional, podramos establecer toda una serie de relaciones entre los diversos tipos de datos que maneja dicha empresa, facilitando su uso y por tanto aumentando la productividad. Si utilizramos un gestor de bases de datos no relacionales, para la gestin de la informacin de la empresa del ejemplo anterior, tendramos un solo fichero que contendra mucha informacin duplicada, as por ejemplo en las facturas se duplicaran los productos coincidentes. Por el contrario cuando utilizamos un gestor de bases de datos relacionales, podemos disponer de varias tablas relacionadas que evitarn la duplicacin de la informacin y facilitarn la modificacin de la estructura de la base de datos. Los datos se podrn utilizar en una variedad de formatos como por ejemplo: etiquetas postales, listas, formularios, informes y grficos, etc. En nuestro gestor de bases de datos relacionales, los datos se almacenan en forma de tablas. Podemos definir la tabla como una coleccin de datos sobre un tema en particular. Los datos de las tablas se representan en formato tabular, es decir, en filas y en columnas. Las filas representan los registros que contienen toda la informacin relacionada con un determinado artculo. Las columnas representan los campos, que son las categoras de la informacin. Imaginemos una tabla que represente la informacin contenida en nuestro carnet de identidad. En dicha tabla habra mas de 20.000.000 de registros, correspondientes a los carnets de identidad de los espaoles mayores de 18 aos. Cada registro ( DNI ) tendra al menos 8 campos, a saber: Nombre, Apellidos, Direccin, Localidad, Provincia, Fecha de Nacimiento , Numero del DNI y Fotografa del Titular ( el contenido de un campo no est restringido a informacin de tipo textual y puede contener informacin fotogrfica, de video, de sonido o cualquier otro tipo de informacin ). Cada registro (fila)en una tabla tiene el mismo nmero de campos (columnas) a lo largo de toda la tabla y cada campo contiene el mismo tipo de informacin en cada registro.

Volviendo al ejemplo anterior, cada registro tiene el mismo nmero de campos y el campo NmeroDNI solo podr contener nmeros (la asignacin de caracteres o cualquier otro tipo de informacin, ser flagelada como error por el gestor de la base de datos en uso) y no podr variar a lo largo de los diferentes registros que componen la tabla correspondiente a la base de datos del carnet de identidad. Para hacer mas rpido el acceso a los datos, la mayora de las bases de datos usan ndices. Las tablas de ndices son listas ordenadas que permiten una bsqueda ms rpida de la informacin. Cada entrada de la tabla ndice apunta a la fila en la que se encuentra el registro buscado. Si no existe un ndice el gestor de la base de datos deber ir buscando secuencialmente, registro por registro, hasta satisfacer las condiciones de la pregunta realizada. Cuando hemos almacenado toda una serie de informacin en una base de datos, podemos emplear un lenguaje especialmente diseado para interrogar a las bases de datos que se llama SQL (lenguaje estructurado de interrogacin) que posee una cierta similitud con la gramtica del ingls. Este lenguaje esta ampliamente difundido y se le considera el lenguaje estndar de interrogacin a las bases de datos. Imaginemos que queremos obtener los nombres de todos los espaoles que hayan nacido antes de 1964. Para ello emplearemos nuestra base de datos del DNI. La sentencia en SQL sera la siguiente: " Select Nombre from DNI where FechaNacimiento < 1965 " Como vemos, es casi un ingls perfecto que traducido sera: Selecciona el Nombre de la base de datos DNI donde el valor del campo FechaNacimiento sea menor que 1965. Esta sintaxis es bastante directa y facilmente comprensible. Por supuesto es posible emplear el SQL en nuestras preguntas a las bases de datos gestionadas por Visual Basic. Una consulta a la base de datos, es una pregunta acerca de los datos contenidos en las tablas. Los datos resultantes de las consultas pueden provenir de una o de varias tablas. Las respuesta a una consulta se la denomina hoja de respuestas dinmicas. Las hojas de respuestas dinmicas son, un conjunto dinmico de registros que contienen los datos extrados de una o mas tablas y obedecen al resultado de las consultas realizadas previamente. Si cambiamos los datos de una hoja de respuestas dinmicas, nuestro gestor de bases de datos se encargar automticamente de actualizar estos cambios en sus tablas de origen, haciendo estos cambios estables en las tablas originales. De hecho el manejo de tablas y el manejo de hojas de respuestas dinmicas, es casi idntico desde el punto de vista del usuario.

20.3.- CREACIN DE UNA TABLA

Ante todo debemos hacer constar que un fichero de bases de datos compatible con el formato de Microsoft Access 1.1, puede contener en su interior tablas de datos, consultas, formularios e informes macros y mdulos. Como podemos observar, el fichero de bases de datos es como un gran contenedor de objetos. Para definir el contenido de una tabla podemos seguir tres caminos diferentes: A.- Creacin de la tabla bajo Microsoft Access 1.1. B.- Creacin de la tabla mediante el Data Manager incluido en Visual Basic 3.0. C.- Creacin de la tabla en tiempo de ejecucin. La primera opcin expuesta anteriormente, queda fuera del mbito temtico de este libro, pues se trata de un producto aparte de Microsoft. Si bien el alumno debe saber que mediante las funciones de manejo de bases de datos incorporadas en Visual Basic 3.0 podemos manejar cualquier tabla anteriormente creada bajo el entorno de Microsoft Access 1.1. Vamos a concentrarnos en la creacin de tablas mediante el Data Manager incluido en Visual Basic. Para entrar en este programa tan solo tenemos que seleccionar del men Windows la opcin DataManager lo que nos permitir operar con esta utilidad. Data Manager nos permite crear una nueva base de datos, abrir una base de datos existente, compactar una base de datos y reparar una base de datos. Cuando se hacen muchos cambios en una base de datos, sta se va fragmentando (queda almacenada en zonas dispersas del disco). De ese modo, el espacio del disco se utiliza de manera poco ptima y aumenta el tiempo requerido para las bsquedas de datos. Para desfragmentar el archivo de base de datos debers compactarlo cada cierto tiempo y de una forma peridica. Para compactar tus bases de datos podrs utilizar la opcin Compact Database del men File del Database Manager. Normalmente el archivo compactado ser menor que el archivo original. Por supuesto, antes de compactar una base de datos debers cerrarla y asegurarte que existe suficiente espacio en disco para la base de datos original y la base de datos compactada, en caso contrario la operacin de compactacin fallar. Si por algn motivo, el usuario de un programa que maneje bases de datos sale de dicho programa sin cerrar previamente las bases de datos o si se produce un corte fortuito de suministro elctrico, posiblemente los ficheros de bases de datos en uso en ese momento se daarn. Si intentamos abrir un fichero daado previamente por alguna de las causas anteriores, Visual Basic nos informar de que estamos intentando abrir una base de datos daada. Puede suceder que se haya daado nuestra base de datos y Visual Basic no sea capaz de detectar dicho dao. Sin embargo, es posible reparar dicha base de datos. Para reparar las bases de datos daadas recurriremos a la opcin Repair Database" del men File del Database Manager. Como ejemplo de construccin de una base de datos vamos a crear la base de datos "ejemplo" con una sola tabla denominada "DNI" y que contendr los campos anteriormente especificados.

Inicialmente ejecutaremos el programa Data Manager desde el men Windows de Visual Basic 3.0 . Una vez ejecutado, seleccionaremos del men File, la opcin New Database y se nos presentar un submen en el que seleccionaremos "Access 1.1" (no seleccionamos Access 1.0 pues es un formato ya antiguo y menos eficiente que el del Access 1.1). Automticamente aparecer un cuadro de dilogo que nos interrogar sobre el nombre que le daremos al fichero de base de datos (recuerde el alumno que un fichero de bases de datos puede contener en su interior varias tablas, preguntas, etc.). En nuestro caso denominaremos al fichero de base de datos "Ejemplo.mdb". Se nos muestra una ventana con el nombre del fichero de base de datos recin creado (ejemplo.mdb) y con cuatro botones que nos permitirn elegir entre las siguientes opciones: A.- Aadir una nueva tabla al fichero de la base de datos (New). B.- Abrir una tabla de la base de datos( Open ) . C.- Disear la estructura de una tabla de la base de datos ( Design). D.- Borrar una tabla del fichero de la base de datos (Delete). En nuestro caso, lo primero que tendremos que hacer, es aadir una nueva tabla. Esto lo haremos seleccionando el botn New. Automticamente obtendremos una caja de dilogo en la que se nos pide el nombre de la tabla a incorporar. El nombre que introduciremos ser "DNI". Despus de esto se muestra una ventana cuyo ttulo es el nombre de la tabla recin creada. En esta ventana aparecen dos listas vacas correspondientes a los campos e ndices a definir para nuestra tabla. Primero definiremos los campos y posteriormente definiremos loa ndices (este ltimo proceso no es imprescindible). Para definir los campos tan solo debemos seleccionar el botn "Add" y obtendremos una nueva ventana que nos preguntar por el nombre del campo a crear, el tipo de dicho campo y su longitud si es que no est predefinida por la definicin de su tipo. Visual Basic nos permite especificar varios tipos de campos: Byte: valor entre 0 y 255 Boolean: valor verdadero o falso Integer: valor entre -32,768 a 32,767 Long Integer: valor entre -2,147,483,648 a 2,147,483,647 Currency: valor entre -922,337,203,685,477.5808 a 922,337,203,685,477.5807 Single: valor entre -3,402,823E38 a -1,401,288E-45 y 1,401,288E-45 a 3,402,823E38 Double: valor entre -1.79769313486232E308 4.94065645841247E -324 a 1.79769313486232E308 Date / Time: fecha u hora. a -4.94065645841247E324 y

Text: String Binary: Formato binario. Memo: String Siguiendo con nuestro ejemplo, crearemos los siguientes campos: Nombre del campo Nombre Apellidos Direccin Localidad Provincia FechaNacimiento NmeroDNI Fotografa Tipo del campo Text Text Text Text Text Date/Time Double Binary Longitud del campo 15 30 30 30 30

A continuacin, aadiremos dos ndices. En primer lugar definiremos el ndice al que denominaremos Primario. Para definirlo seleccionamos el botn Add situado debajo de la etiqueta Indexs. Seguidamente aparece una nueva ventana en la que debemos introducir el nombre del nuevo ndice, en este caso Primario, y despus seleccionamos el campo o campos que formarn parte del ndice. El campo seleccionado ser NmeroDNI y le pedimos que lo ordene en orden ascendente. Como el alumno ya sabe, los ndices son tablas separadas, en las que figuran ordenados los campos que forman dichos ndices, as como punteros a las estructura general de la base de datos. As cualquier bsqueda por los campos que se incluyan en un ndice resultar mucho ms rpida que si no empleramos dicho ndice. El ndice primario, es aquel que incorpora como campo de indexacin la clave principal. Denominamos clave principal a aquel registro que identifica biunivocamente a su registro, es decir, no hay posibilidad de introducir valores coincidentes en un registro que se haya calificado como clave principal. Cuando creamos un ndice, y al campo que forma ese ndice se le califica con la opcin Primary Index, se est marcando ese campo como campo clave de dicha tabla y su ordenacin ser en funcin de dicho campo. Recuerde el alumno que si calificamos a un campo como clave principal, dicho campo no puede poseer valores coincidentes. Segn lo dicho anteriormente, el nico campo disponible para ser calificado como campo clave, es el NmeroDNI, pues este campo es diferente para cada registro. Por tanto, para definir el ndice al que denominamos "Primario" seleccionaremos el registro NumeroDNI y mediante el botn Add(asc) estableceremos su orden ascendente, marcaremos la opcin Primary Index para sealarlo como ndice primario y sin posibilidad de duplicidad de valores en su contenido.

Podemos definir tantos ndices como queramos, pero siempre hay que recordar que, a mayor nmero de ndices mayor tiempo le lleva al gestor de la base de datos el incorporar nuevos registros, pues antes de validarlos tendr que ordenarlos con respecto a todos los ndices. Por tanto, nuestra tarea como diseadores es establecer el equilibrio entre el nmero de ndices y la rapidez de validacin de nuevos registros. Como es fcil suponer, la mayora de las bsquedas de los titulares del carnet de identidad se harn por el Nombre y Apellidos del titular en vez de su nmero de DNI. Por este motivo, nos hemos decidido a incorporar un segundo ndice a nuestra base de datos, al que denominaremos "NombreApellido" y que estar formado por los dos campos siguientes: Nombre + Apellido. Seleccionaremos estos dos campos de la lista y los marcaremos con el botn Add(asc). No marcaremos las opciones Primary Index pues ya existe uno, ni Require unique Index values pues la suma de esos dos campos se puede repetir a lo largo del toda la tabla (imagine el alumno la cantidad de Pedros Perez Garca que puede haber en Espaa). Una vez que hayamos completado tanto la estructura de la tabla como los ndices, tendremos que cerrarla para que todo nuestro trabajo quede grabado en el disco. Data Manager, permite adems de crear bases de datos y sus tablas, introducir, borrar y buscar registros en las tablas previamente creadas. Si queremos tener acceso a alguna de las utilidades anteriores lo podremos hacer seleccionando el botn "Open" de la ventana que nos muestra las tablas de la base de datos en uso. Tras esta seleccin se abrir una nueva ventana en la que figuran todos los campos de la tabla seleccionada. Existen 5 botones que nos permitirn Aadir registros, Actualizar los cambios, Borrar registros, Buscar registros, Refrescar los registros. Siempre que salgamos del Data Manager deberemos cerrar la base de datos en uso. Bien, ya hemos dado un paso muy importante, ya tenemos definida nuestra base de datos, que se compone de la tabla DNI y de los ndices Principal y NombreApellidos. En los siguientes apartados veremos como podemos acceder a los datos contenidos en esa tabla mediante el uso del control de acceso a bases de datos que incorpora Visual Basic 3.0.

20.4.- CONTROL DE ACCESO A BASES DE DATOS

Para incorporar la funcionalidad de este control tan slo hay que seleccionarlo de la caja de herramientas e incluirlo en una form. La siguiente figura muestra la apariencia de este control en la barra de herramientas y cuando se incluye en una Form determinada.

Fig. 20.1.- Representacin del control Data. Como gua a utilizar a lo largo de este captulo, seguiremos empleando la base de datos Ejemplo que hemos creado recientemente. El primer paso que tenemos que dar es crear una Form sobre la que incluiremos el control de acceso a bases de datos. Una vez incluido dicho control (Data1) en la form recin creada, vamos a establecer las propiedades principales de ste control. La primera propiedad a establecer es DatabaseName (Data1.Databasename), a la que asignaremos la base de datos recin creada (Ejemplo.mdb). Posteriormente, asignaremos a la propiedad RecordSource (Data1.RecordSource), la tabla que queramos emplear de la base de datos anteriormente asignada. Como nuestra base de datos tan slo tiene una tabla, la asignacin ser directa: Data1.RecordSource = DNI. Por comodidad y como el ttulo (Caption) del control aparece siempre, asignaremos dicho ttulo al nombre de la tabla en uso: Data1.Caption = "DNI". Estas asignaciones las haremos en la ventana Properties o en el evento Load de la form en curso. En la figura 20.2 podemos observar todo lo anteriormente realizado.

Fig. 20.2.- Establecimiento de propiedades para nuestra base de datos.

Hay que mencionar que la mayora de los controles son sensibles al uso de bases de datos, es decir, poseen propiedades que facilitan el manejo de los datos gestionados por el control de bases de datos. Gracias a estas nuevas propiedades podemos tener una caja de texto que muestre el contenido de un campo del registro actual. Los controles que son sensibles al uso de bases de datos son los siguientes: Check Box Image Label Picture Box Text Box Masked Edir 3D Panel 3D Check Box

Vamos a colocar en nuestra form 7 cajas de texto, 8 etiquetas y una caja de dibujo. Las cajas de texto servirn para mostrar el contenido de los 7 campos que se sealan a su izquierda mediante etiquetas. La caja de dibujo mostrar la fotografa de cada persona. En la siguiente figura se muestra el aspecto del form descrito anteriormente.

Fig. 20.3.- Aspecto del form de nuestra base de datos. Para poder ligar el valor de los campos que forman cada tabla a los controles sensibles a datos, es necesario asignar dos propiedades: la propiedad DataSource y la propiedad DataField.

La primera contiene el nombre del control de manejo de bases de datos que ha sido asignado a la tabla cuyos datos queremos mostrar. En nuestro caso sera: Text1.DataSource = Data1. Mediante la segunda propiedad asignamos a un control determinado el contenido de un campo de una tabla. Para la primera caja de texto esta propiedad quedara: Text1.DataField = Nombre. La asignacin de estas propiedades la realizaremos en la ventana Properties. Para la caja de dibujo la asignacin ser la siguiente: Picture1.Source = Data1 Picture1.DataField = Fotografa Cuando ejecutamos nuestra aplicacin ejemplo, vemos que aparece automticamente el primer registro de la tabla DNI y que pulsando en las flechas del control de datos podemos navegar entre los registros de la base de datos. Por tanto, hemos creado una aplicacin que visualiza y navega a travs de los registros de una tabla determinada sin escribir ni una sola lnea de cdigo. Aqu se desvela la potencia de este control. Como hemos visto el control de manejo de bases de datos nos permite conectarnos con una base de datos local o remota y desplazarnos entre sus registros. Adicionalmente tambin podemos realizar preguntas mediante el uso del SQL, aadir registros a la base de datos, capturar errores que se pueden producir en el acceso a la base de datos o cerrar la base de datos.

20.5.- ABRIR UNA BASE DE DATOS

Para acceder al contenido de cualquier tabla, primero debemos abrir la base de datos en la que est incluida. Podemos abrir diversos tipos de bases de datos. En nuestro ejemplo, estamos abriendo una base de datos en formato Access y sin embargo es posible la utilizacin de bases de datos que estn en otros formatos. Los formatos soportados por el control de manejo de bases de datos son los siguientes: A.- Access B.- Fox Pro C.- Btrieve D.- Paradox E.- dBase Durante el tiempo de diseo es posible abrir las bases de datos anteriores tan slo asignando a las propiedades siguientes los valores correctos en cada caso: DatabaseName y Conect.

Si asignamos valores a estas propiedades en tiempo de ejecucin, tendremos que usar el mtodo Refresh para que se produzca la apertura de la base de datos deseada. La propiedad DatabaseName deber contener el nombre de la base de datos que queramos utilizar. En caso de que esta base de datos no est en formato Access deberemos complementar est propiedad con la asignacin de datos a una segunda propiedad; Connect. Los valores a asignar a la propiedad Connect varan segn la naturaleza de la base de datos a utilizar: Formato de la base de datos Access Fox Pro V: 2.0 Fox Pro V: 2.5 dBASE III dBASE IV Paradox Btrieve DatabaseName Path y Fichero MDB Path y Fichero Path y Fichero Path y Fichero Path y Fichero Path y Fichero Path y Fichero Connect FoxPro 2.0 FoxPro 2.5 dbase III dbase IV paradox; pwd=clave btrieve

La propiedad DatabaseName contiene la descripcin del fichero de la base de datos. Este fichero puede estar situado en un disco local del sistema o situado en un servidor lejano. Hay que mencionar que la base de datos puede ser compartida por otros usuarios. La propiedad RecordSource nos permite escoger la taba que queramos abrir de la base de datos en uso. Tambin podemos asignar a esta propiedad el nombre de una consulta (query) de Microsoft Access o asignar el texto de una consulta SQL. Si asignamos una pregunta SQL, sta se llevar a cabo tras la ejecucin del mtodo Refresh. Una consulta de Access es un fichero contenido en la base de datos, que contiene el cdigo procedente de una metodologa de consulta denominada Consulta grfica segn ejemplo y que viene implementada en Microsoft Access. Las consultas permiten formular preguntas sobre los datos almacenados en una tabla. Las consultas pueden contener cualquier nmero de campos de cualquier nmero de tablas, lo que facilita enormemente el poder de interrogacin a nuestra base de datos. El siguiente cdigo interrogar a nuestra tabla por todos los espaoles nacidos antes de 1950. Para ello emplearemos el SQL. Data1.DatabaseName = "EJEMPLO" Data1.RecordSource = " Select * from DNI where FechaNacimiento < 1/1/1950 " Data1.Refresh Existen otras propiedades complementarias que vamos a comentar sucintamente: La propiedad Exclusive nos permite abrir una base de datos con derechos exclusivos por nuestra parte sobre dicha base de datos. Cualquier intento por parte de otro usuario de abrir nuestra base de datos resultar fallido. Esta posibilidad resulta muy til para bloquear el acceso a

nuestra base de datos durante operaciones que necesitan el uso exclusivo de la base de datos. Si queremos desactivar el modo de exclusividad de la base de datos tan slo tenemos que asignar el valor False (valor por defecto) a la propiedad Exclusive y emplear el mtodo Refresh que cerrar y abrir la base de datos (cerrar en modo Exclusive = True y la abrir con el nuevo valor de Exclusive = False). La propiedad Options permite concatenar una serie de opciones que marcarn el comportamiento de acceso a los datos de una base de datos. Definiremos Recordset como la hoja de respuestas dinmicas, es decir, un grupo de registros seleccionados por el usuario en tiempo de ejecucin. Las opciones son las siguientes: Constante DB_DENYWRITE DB_DENYREAD DB_READONLY DB_APPENDONLY Funcin Otros usuarios tienen acceso de escritura al recordset Otros usuarios tienen acceso de lectura al recordset Cuando la aplicacin puede escribir en una tabla en el recordset La aplicacin slo aade y no lee del recortes

Si quisisemos abrir un recortset de nuestra tabla DNI y restringir el acceso de escritura a otros usuarios ejecutaramos el siguiente cdigo: Data1.Databasename = "ejemplo.mdb" Data1.RecordSource = "DNI" Data1.Options = DB_DENYWRITE ; ningn usuario puede escribir en la tabla DNI Data1.Refresh ; Cierra y abre la base de datos. El uso de la propiedad ReadOnly es casi inmediato. Asignando un valor True a sta propiedad, estamos impidiendo que se lleve a cabo ningn cambio en el contenido de la tabla en uso. Cuando se produce un cambio de esta propiedad en tiempo de ejecucin, ste no tiene efecto hasta que no se ejecuta el mtodo refresh.

20.6.- RECORDSET
Podemos definir el objeto Recordset con su simple traduccin del ingls, esto es: el conjunto de registros con el que estamos actualmente trabajando o el resultado de una consulta dinmica. Con los siguientes mtodos que se aplican al objeto Recordset podemos navegar a lo largo de nuestra base de datos as como aadir o borrar registros. Para aadir nuevos registros emplearemos el mtodo AddNew, que aadir un registro en blanco al final de la tabla asociada a un determinado control de manejo de bases de datos.

El siguiente cdigo muestra la sintaxis correcta: Data1.Recordset.AddNew Si queremos grabar los nuevos registros utilizados tras, por ejemplo, haber aadido 5 nuevos registros con el mtodo anterior, tendremos que emplear el mtodo Update. Su sintaxis es la siguiente: Data1.Recordset.Update Existen mtodos de posicionamiento, como por ejemplo MoveFirst y MoveLast, que como es fcil deducir nos permitirn ir al principio y final de nuestra tabla. Tambin existen mtodos para moverse adelante y atrs del registro actual con los siguientes mtodos: MoveNext y MovePrevious. Data1.Recordset.MoveFirst Data1.Recordset.MoveLast Data1.Recordset.MoveNext Data1.Recordset.MovePrevious Si lo que queremos hacer es borrar un determinado registro, tan slo tenemos que emplear el mtodo Delete. Data1.Recordset.Delete Data1.Recordset.MoveNext Quiz parezca una equivocacin que siga el mtodo MoveNext al mtodo Delete, pero no es as y su explicacin es sencilla. Cuando se ejecuta el mtodo Delete, el registro actual se borra y el puntero al registro actual se invalida, por no existir dicho registro pues ha sido borrado. Por tanto cualquier intento de acceso a dicho registro ser tratado como error. Por este motivo y para evitar dicho error empleamos seguidamente el mtodo MoveNext, lo que nos devolver un registro actual vlido. Pero hemos hablado del registro actual o Current Record y no lo hemos explicado. Intentemos solucionar esta desagradable situacin. Nuestro Control de base de datos y nuestro RecordSet slo nos permiten el acceso a un nico registro. Dicho registro es el registro actual. Toda nuestra atencin se debe dedicar a que dicho registro siempre sea vlido, es decir, no intentemos acceder a un registro recin borrado o un registro que no existe (intentamos acceder a un registro anterior al primer registro de nuestra tabla, o a un registro posterior al ltimo registro). Para controlar la validez del registro actual podemos utilizar las siguientes propiedades: BOF = Comienzo de la tabla. Esta propiedad devuelve un valor True cuando el registro actual se encuentra en el primer registro de la tabla. EOF = Fin de la tabla. Devuelve un valor True cuando el registro actual se encuentra en el registro final de la tabla.

Si EOF y BOF devuelven los dos True, nos indica que nuestra tabla esta vaca y por tanto el registro actual es invlido. Si EOF y BOF devuelven los dos False, nos indica que el registro actual es vlido a menos que hayamos borrado el ltimo registro y no nos hayamos movido hacia atrs para actualizar y validar el registro actual. Tenemos la posibilidad de almacenar el valor del registro actual y volver mas tarde a la misma posicin. Esto es posible gracias a la propiedad Bookmark, que slo contiene el puntero al registro actual. Almacenando dicho valor podemos volver a nuestro registro cuando queramos y sin importarnos el registro donde nos hallemos. El siguiente cdigo almacena el puntero al registro actual, va al final de la tabla, aade un registro en blanco e inmediatamente vuelve al registro inicial. Dim PunteroRegistroActual As Variant PunteroRegistroActual = Data1.Recordset.Bookmark Data1.Recordset.MoveLast Data1.Recordset.AddNew Data1.Recordset.Update Data1.Recordset.Bookmark = PunteroRegistroActual Es posible validar el permiso de cambio de nuestro Recordset en tiempo de ejecucin, gracias a la propiedad Updatable. Si esta propiedad es True, el Recordset aceptar cambios en tiempo de ejecucin. Si por el contrario el valor de dicha propiedad es False cualquier intento de modificar el Recordset producir un error.

20.7.- AADIR, EDITAR Y BORRAR REGISTROS

Vamos a examinar el cdigo que nos permitir aadir, editar y borrar registros a nuestra base de datos "ejemplo" y a su tabla "DNI". Para crear un nuevo registro, necesitamos primero emplear el mtodo AddNew, que crear un nuevo registro al final de la tabla y lo dejar vaci, de manera que el registro actual ser automticamente movido al registro recin creado. Posteriormente, asignaremos los valores que queramos a cada uno de los campos que forman nuestra tabla. Para finalizar, utilizaremos el mtodo Update que devolver el puntero al registro actual a su valor inicial, es decir, al registro donde nos encontrbamos antes de emplear el mtodo AddNew. El cdigo que sigue muestra lo explicado anteriormente. Data1.DatabaseName = " Ejemplo.mdb" Data1.RecordSource = ""DNI" Data1.Refresh Data1.Recordset.AddNew Data1.Recordset.("Nombre") = " Carlos "

Data1.Recordset.("Apellidos") = " Perez Perez " Data1.Recordset.("Direccin") = " Gran Va" Data1.Recordset.("Localidad") = " Madrid " Data1.Recordset.("Provincia") = " Madrid" Data1.Recordset.("NmeroDNI") = " 10000009 " Data1.Recordset.("FechaNacimiento") = " 1/1/56" Data1.Recordset.Update Si queremos editar un registro, lo primero que tenemos que hacer es posicionarnos sobre dicho registro. Una vez colocados donde debemos, modificaremos los campos que queramos con la ayuda que nos brindan los controles sensibles a bases de datos y emplear el mtodo Update o simplemente movernos a otro registro. Vamos a cambiar el campo "Nombre" del registro aadido anteriormente. Este cambio lo realizaremos cambiando el contenido de la propiedad Text del control Text1 cuyas propiedades DataSource (Text1.DataSource) y DataField (Text1.DataField) han sido asignadas a "Data1" y a "Nombre" respectivamente, en tiempo de diseo de la form. Esta forma no requiere codificacin y resulta automtica. Tambin podemos hacerlo de una manera codificada: Data1.Recordset.("Nombre") = "Juan" Data1.Recordset.Update El cdigo anterior cambiar el valor del campo Nombre por su nuevo valor "Juan". Este cambio se realizar sobre el registro actual. Hay diversas maneras de referirnos al valor de un determinado campo de un registro de una tabla cualquiera. Por ejemplo, el siguiente cdigo muestra diversas formas de modificar el segundo campo (Apellidos) de la tabla "DNI". Data1.Recordset.Field(1).Value: El primer campo de la tabla es el cero, por tanto el segundo campo es el 1. Data1.Recordset.Field("Apellidos"): no es necesario referenciar la propiedad Value. Data1.Recordset("Apellidos"): no es necesario referenciar la propiedad Field Data1.Recordset(1) : podemos emplear el nmero de orden del campo a acceder o su nombre. Para borrar un determinado registro tan slo tenemos que posicionarnos sobre el registro a borrar y emplear el mtodo Delete. Es posible borrar ms de un registro a la vez. El siguiente cdigo borrar todos los registros de nuestra tabla "DNI" que tengan por valor del campo "FechaNacimiento" un valor menor de "1/1/1930". Para hacer esto, primero abriremos nuestra base de datos y haremos la pregunta que seleccionar todos registros que posean una fecha de nacimiento anterior a "1/1/1930". Los registros que cumplen dicha propiedad sern los que componen nuestro Recordset, y por tanto borraremos todos los elementos del Recordset. Para controlar el nmero de elementos a borrar

nos ayudaremos de la propiedad EOF que nos indicar cuando hemos llegado al final del Recordset. Data1.DatabaseName = " Ejemplo.mdb" Data1.RecordSource = "Select * from DNI where FechaNacimiento < 1/1/1930 " Data1.Refresh Do While Data1.Recordset.EOF = False Data1.Recordset.Delete Data1.Recordset.MoveNext Loop Como sabemos, los campos pueden contener texto que exceda de 64K que es la limitacin actual de los String de Visual Basic. Para evitar esta limitacin, Visual Basic 3.0 no provee de tres nuevos mtodos que nos permitirn manejar sin dificultad los campos memo, aunque exceda de 64K de datos. Estos mtodos son los siguientes : FieldSize, nos devuelve el nmero de bytes de un campo memo . GetChunk nos devolver todo o una porcin de un campo memo. Sus dos argumentos indicarn el desplazamiento a partir del cual obtendremos el nmero de bytes de texto especificado en el segundo parmetro. AppendChunk aade los datos a un campo memo. Con estos mtodos podemos trabajar con grandes campos meno sin estar limitados por la capacidad inherente a las variables String de Visual Basic.

20.8.- CONCEPTOS AVANZADOS

El concepto de transaccin est ligado a los grandes sistemas informticos, que tras su implementacin en Visual Basic, nos permite cancelar o validar toda una serie de acciones que hayamos realizado en un determinado Recordset. Usaremos las transacciones cuando queramos verificar cualquier cambio que se produzca en el sistema antes de validar la incorporacin de dichos cambios en nuestra base de datos. Imaginemos que hemos diseado un programa de manejo de activos burstiles. Una de las acciones de dicho programa es tratar con una gran cantidad de transacciones financieras, pero queremos incorporar una capacidad adicional a nuestro programa que nos permita cancelar todos los cambios cuando determinados activos estn por debajo de un nivel predeterminado. Esta caracterstica se podra incorporar con el uso de las transacciones. Nuestro cdigo tendr que explicitar cuando comienza una transaccin con la sentencia BeginTrans. Mientras esta transaccin permanezca abierta cualquier cambio que se realice puede ser cancelado posteriormente con la sentencia Rollback. Cuando finalmente decidimos finalizar la transaccin, pues nos hemos asegurado que todos los cambios son correctos, emplearemos la sentencia CommitTrans. Cuando cerramos la transaccin con la anterior

sentencia los cambios no se pueden recuperar, es decir, son hechos permanentes en nuestras tablas. Cuando abrimos una base de datos, podemos decir que estamos en modo auto-commit, por lo tanto, cualquier cambio que se realice en las tablas, es llevado a cabo inmediatamente sin posibilidad de recuperacin. Para que podamos emplear las tres sentencias anteriores tenemos que validar la propiedad: Transactions = True. El siguiente ejemplo aprovecha cdigo ya explicado anteriormente y muestra las facilidades de las transacciones. Como vemos en nuestro ejemplo, primero iniciamos la transaccin, despus procedemos a borrar toda una serie de registros y posteriormente una caja de mensajes pregunta al usuario si realmente quiere borrar los registros. Si el usuario contesta que si, validamos la transaccin y realmente se borran los mensajes. Si el usuario dice que no, la sentencia Rollback es la encargada de deshacer todos los cambios y por tanto no se produce el borrado de ningn registro. Data1.DatabaseName = " Ejemplo.mdb" Data1.RecordSource = "Select * from DNI where FechaNacimiento < 1/1/1930 " Data1.Refresh BeginTrans Do While Data1.Recordset.EOF = False Data1.Recordset.Delete Data1.Recordset.MoveNext Loop Mensaje$ = "Realmente quiere borrar los datos" DefinicionDialogo% = MB_YESNO + MB_ICONSTOP + MB_DEFBUTTON2 Respuesta% = MsgBox( Mensaje$ , DefinicionDialogo%, "ATENCION" ) if Respuesta% = IDYES then CommitTrans Else Rollback EndIf El uso de transacciones es muy simple a la vez que muy til. Nuestro control de manejo de bases de datos cuenta con un evento que nos ser muy til para poder chequear cualquier cambio en la base de datos. Este evento se denomina Validate y se dispara antes que cualquier registro se convierta en el registro actual, antes del mtodo Update y antes de las operaciones Delete, UnLoad y Close. Este evento posee dos parmetros que son Accin (Action) y Grabar (Save). Accin nos indicar que accin ha disparado el evento y Grabar nos indicar si ha cambiado el contenido del control asociado. Por ejemplo, si tenemos asociado un control de texto, Save nos indicar si la propiedad Text1.Text ha cambiado o no.

20.9.- ESTRUCTURA INTERNA DE LAS BASES DE DATOS

Podemos ver directamente desde Visual Basic la estructura interna de nuestras bases de datos. Gracias a esta caracterstica podemos describir los nombres de las diversas tablas que pueden residir en un nico fichero de bases de datos, as como la estructura interna de las tablas, campos de dichas tablas e ndices. Visual Basic puede manejar directamente dos categoras diferentes de bases de datos: A.- Formato Microsoft Access: este es el formato nativo empleado por Visual Basic y es el que nos ofrece unos mejores resultados de velocidad y de flexibilidad. B.- Bases de datos externas: en esta categora incluimos formatos tan populares como el formato dBase, Paradox, Foxpro y Btrieve. Desde la versin profesional de Visual Basic 3.0 es posible crear nuevas bases de datos o modificar la estructura de las existentes.Es posible acceder a las bases ODBC entre las que se incluyen Microsoft SQL Server y Oracle. Una base de datos en formato Access posee la estructura que muestra el grfico siguiente:

Fig. 20.4.- Estructura de una base de datos en formato Access. Para alcanzar un entendimiento ptimo de la estructura interna de las bases de datos definiremos los siguientes objetos: Objeto Database, Objeto TableDef, Objeto Field y Objeto Index. Cada uno de estos objetos ser comentado brevemente a continuacin, pero antes explicaremos algn otro concepto complementario.

Definimos el termino coleccin como un conjunto de objetos relacionados. Nos referiremos posteriormente a dichos objetos como miembros de la coleccin. Cada miembro de la coleccin tiene un nico nombre que lo identifica. Visual Basic maneja las colecciones como si de los elementos de una caja de lista se tratara. Por tanto, a cada elemento le corresponde un ndice que comienza con el cero, y el nmero de elementos de una coleccin nos viene dado por la propiedad Count. Cada objeto Database describe el contenido de una base de datos a la que est asociada por el control de acceso a bases de datos. Este objeto contiene la coleccin TableDef, que a su vez, contiene como elementos, los nombres de las diferentes tablas que componen el fichero de base de datos. Cada elemento en la coleccin TableDef corresponde al nombre de un objeto TableDef. Mediante la propiedad Count podemos obtener el nmero de elementos de dicha coleccin. Cada objeto TableDef contiene el nombre de la tabla a la que representa, un coleccin de Field y una coleccin de Index. En la coleccin Field estn todos los objetos Field de cada tabla. Corresponde el nombre de cada elemento de la coleccin con el nombre de cada campo de la tabla en cuestin Cada Objeto Field contiene el nombre del campo, el tamao de la informacin que contendr el campo, el tipo de la informacin de dicho campo as como sus atributos. Toda esta informacin es accesible a travs de las propiedades siguientes: Name, Size, Type, Attributes. En la coleccin Index se encuentran representados todos los ndices existentes para una determinada tabla. Cada elemento se corresponde con un objeto Index. Cada objeto Index contiene la siguiente informacin: el nombre del ndice, el campo o los campos que componen dicho ndice, as como el valor de las propiedades Unique y Primary. Toda esta informacin es accesible a travs de las propiedades siguientes: Name, Fields,Unique y Primary.

CAPTULO 21

ACCESO A BASES DE DATOS:OBJETOS DE ACCESO A DATOS 21.1.- INTRODUCCIN

Este captulo cubre las diferentes tcnicas de creacin y acceso a bases de datos desde Visual Basic 3.0. El alumno habr estudiado en el captulo previo, el acceso a bases de datos a travs del control incorporado en Visual Basic 3.0 (edicin estndar). Sin embargo, las tcnicas aqu descritas slo son accesibles desde la versin profesional de Visual Basic 3.0 e incorporan un mayor grado de dificultad que las precedentes. No hay que ocultar, que la facilidad de uso, que nos ofrece el control de acceso a bases de datos, est acompaada por la limitacin de sus capacidades. En informtica se cumple casi obligatoriamente la 5 ley de Murphy: a mayor facilidad de uso, mayor limitacin de capacidades, menor posibilidad de errores y menor productividad. No obstante, ser el programador quien deba elegir entre la facilidad de uso y las limitaciones del control de manejo de bases de datos o la complejidad y las enormes posibilidades del utilizar las funciones de creacin y acceso a bases de datos incorporadas en la edicin profesional. Como ya vimos Visual Basic est equipado con la tecnologa que incorpora la base de datos de Microsoft: Access 1.1. Esta tecnologa nos permite crear y manejar bases de datos en formato nativo (formato Access) o aprovechar cualquiera de los formatos ya existentes en el mercado, como por ejemplo, Btrieve, dBASE, FoxPro, Oracle, Paradox, Microsoft SQL Server, etc. En este captulo vamos a estudiar las propiedades y los mtodos de los ocho objetos de acceso a datos: Objeto Database, Objeto Dynaset, Objeto Table, Objeto Snapshot, Objeto Field, Objeto Index, Objeto TableDef y Objeto QueryDef.

21.2.- CREACIN DE UNA BASE DE DATOS.

Como ya vimos, podamos crear las bases de datos de tres formas diferentes, pero ahora vamos a estudiar la creacin de una base de datos desde Visual Basic mediante la funcin CreateDatabase. Con la incorporacin de esta funcin a nuestros desarrollos, podemos ofrecer al usuario la posibilidad de creacin de bases de datos en tiempo de ejecucin. Hay que decir que esta funcin solo soporta el formato nativo, es decir, el formato Access. La funcin CreateDatabase devuelve un objeto Database, que usaremos posteriormente para manejar la base de datos recin creada.

La estructura de esta funcin es la siguiente: Set NombreObjetoDatabase = CreateDatabase (NombreDatabase, Localizacin, Opciones) La base que estamos creando se abre en modo esclusivo, es decir, ningn usuario puede acceder a ella hasta que no est creada en su totalidad. Una vez que hemos obtenido el objeto Database (Un objeto Database es un puntero interno a la base de datos asignada a ese objeto y que la identifica biunvocamente ) podemos aadir tablas e ndices a nuestra base de datos. Antes de crear la base de datos tenemos que dimensionar una variable de tipo Object Database,que ser la variable que contendr el objeto Database devuelto por la funcin. La funcin CreateDatabase tiene tres parmetros de los cuales el ltimo es opcional, vamos a estudiarlos uno a uno. NombreDatabase: este parmetro nos sirve para incluir el nombre completo de la base de datos a crear y su path. Ejemplo: "c:\database\Clientes.MDB" . Localizacin: en este parmetro incluiremos una constante que indicar al sistema el lenguage y el cdigo de pgina necesario para que Visual Basic pueda ejecutar correctamente las tareas de ordenacin de datos. Las constantes del sistema que califican dicho parmetro son las siguientes: Constante DB_LANG_DUTCH DB_LANG_GENERAL DB_LANG_ICELANDIC DB_LANG_NORWDAN DB_LANG_SPANISH DB_LANG_SWEDFIN Pais PAISES BAJOS INGLS, ALEMN y FRANCS ISLANDS NORUEGO y DANS ESPAOL SUECO y FINLANDS

Este parmetro no tiene valor por defecto por lo que debemos incluir siempre una constante vlida. Opciones: es opcional y no es necesaria su inclusin. Este parmetro nos permite o encriptar la base de datos recin creada o crear una base de datos que puede ser utilizada desde Microsoft Access 1.0 (hay que mencionar que el formato de bases de datos de Microsoft Access 1.0 es ligeramente diferente al del Access 1.1). El valor por defecto de este parmetro permite crear una base de datos sin encriptar y con formato Access 1.1. Una vez que hemos obtenido nuestro objeto Database con la funcin CreateDatabase, vamos a incluir una tabla y dos ndices. Para aadir una tabla a una base de datos recin creada o a una base de datos ya existente, primero debemos cerrar todos los objetos Recordset que estuvieran abiertos (en el caso que la base de datos sea de reciente creacin esto no sera necesario, pero es una buena costumbre de codificacin).

Aadir una nueva tabla es simplemente aadir un objeto TableDef a la base de datos. Aadir nuevos campos a una tabla es tan solo aadir objetos Field al objeto TableDef. Como ya vimos en el captulo anterior, disponemos de una utilidad muy importante para el diseo y exploracin dinmica de las bases de datos: las colecciones. La coleccin TableDef contiene una lista de cada tabla que compone la base de datos. Las descripciones de cada tabla son mantenidas en objetos TableDef cuyos nombres coinciden con los elementos almacenados en la coleccin TableDef. Expresado de una manera ms tcnica, la coleccin TableDef mantiene una coleccin de punteros a objetos TableDef, los cuales a su vez contienen la estructura de cada tabla asociada a una determinada base de datos. La coleccin Fields contiene el conjunto de todos los objetos Field de objeto DataField. La coleccin Indexes contiene el conjunto de todos los objetos Index asociados con un determinado objeto DataField. Cuando queramos aadir o borrar miembros a una coleccin deberemos emplear los mtodos estndar que Visual Basic provee para manejar los miembros de una coleccin. Los mtodos que nos permiten manejar los elementos de una coleccin son los siguientes: Append : aade un nuevo elemento a la coleccin especificada. Si existe un miembro que posea el mismo nombre del elemento que se quiere ingresar se produce un error. Delete: este mtodo permite eliminar un determinado miembro de la coleccin especificada. Si no existe el elemento que se quiere eliminar se generar un error. Hasta aqu ya tenemos creada nuestra base de datos, ahora vamos a ver el proceso de asignar tablas a nuetra base recin creada. Pero vayamos paso a paso. Como ejemplo de codificacin vamos a recrear nuestro ejemplo del captulo anterior. Definiremos la base de datos Ejemplo y la tabla DNI con tres campos Nombre, Apellidos, NumeroDNI. Primero dimensionaremos los objetos pertinentes (Database, TableDef, Field) para que el compilador reserve espacio para estos objetos. Dim BaseDatos As Database Dim Tabla As New TableDef Dim CampoNombre As New Field Dim CampoApellido As New Field Dim CampoNumeroDNI As New Field Ahora vamos a emplear la ya conocida funcin, CreateDatabase. Set BaseDatos = CreateDatabase ("C:\ejemplo.mdb", DB_LANG_SPANISH) Ahora empecemos con la tabla, a la que denominaremos DNI.

Como hemos declarado el objeto Tabla como objeto TableDef, vamos a asignarle valores a sus propiedades: Tabla.Name = "DNI" Procedamos a crear los objetos Field y a asignarles sus propiedades. Asignaremos a la propiedad Name el nombre del campo y a la propiedad Type la constante pertinente (DB_TEXT, DB_LONG, DB_DATE, etc) que indicar la naturaleza de la informacin que contendr dicho campo. Tambin asignaremos la propiedad Size que especificar la longitud de la informacin que contendr dicho campo. CampoNombre.Name = "Nombre" CampoNombre.Type = DB_TEXT CampoNombre.Size = 30 CampoApellido.Name = "Apellidos" CampoApellido.Type = DB_TEXT CampoApellido.Size = 30 CampoNumeroDNI.Name = "NmeroDNI" CampoNumeroDNI.Type = DB_DOUBLE Posteriormente vamos a aadir cada uno de estos objetos a la coleccin Fields perteneciente al objeto TableDef. Recordemos que al principio de nuestro cdigo hemos declarado el objeto TableDef denominado Tabla. Para aadir cada objeto Field a la coleccin Fields perteneciente al objeto TableDef utilizaremos el mtodo Append ya comentado anteriormente. Tabla.Fields.Append CampoNombre Tabla.Fields.Append CampoApellidos Tabla.Fields.Append CampoNumeroDNI Por ltimo, vamos a aadir la tabla DNI a la coleccin TableDefs perteneciente al objeto Database y posteriormente cerrar la base de datos. BaseDatos.TableDefs.Append Tabla BaseDatos.Close. Con estas ltimas lneas, hemos cerrado la base de datos recin creada, a la que hemos aadido una tabla llamada DNI que tiene tres campos denominados Nombre, Apellidos y NmeroDNI. Esta base de datos puede ser abierta inmediatamente para aadir los registros que se deseen, es decir, est operativa. Pero vamos a intentar complicar un poco nuestros problemas y vamos a aadir dos ndices a nuestra tabla DNI. Un ndice ser el ndice primario y contendr como campo ndice, el campo NmeroDNI y el otro ndice contendr como campos ndice la suma de los campos Nombre y Apellidos. Primero dimensionaremos dos nuevos objetos Index y posteriormente asignaremos las diferentes propiedades a los objetos Index recin creados.

Dim IndicePrincipal As New Index Dim IndiceSecundario As New Index IndicePrincipal.Name = "Principal" IndicePrincipal.Fields = "NmeroDNI" IndicePrincipal.Primary = True IndiceSecundario.Name = "NombreApellidos" IndiceSecundario.Fields = "Nombre ; Apellidos" IndiceSecundario.Primary = False Seguidamente asignaremos los objetos ndices recin creados a la coleccin Indexes perteneciente al objeto Tabla. Posteriormente aadiremos el objeto Tabla a la coleccin TableDef perteneciente al objeto Base Datos. Tabla.Indexes.Append IndicePrincipal Tabla.Indexes.Append IndiceSecundario BaseDatos.TableDefs.Append Tabla

21.3.- LOS OBJETOS Y SUS PROPIEDADES

Una vez visto el cdigo necesario para la creacin de la estructura de bases de datos con tablas e ndices vamos a comentar brevemente las diferentes propiedades de dichos objetos. 21.3.1.- Objeto FIELD Name: esta propiedad contiene el nombre que recibir el campo. En el formato nativo de Access la longitud de esta propiedad no puede exceder de 64 caractres. Cada nombre debe ser nico, esto es, no podemos tener nombres coincidentes dentro de una misma tabla. Type: esta propiedad califica el tipo de la informacin que contendr el campo que est siendo definido. Las siguientes constantes son las que indicarn el tipo de informacin de cada campo: Constante DB_BYNARY DB_BOOLEAN DB_BYTE DB_CURRENCY DB_DATE DB_DOUBLE DB_INTEGER Valor 9 1 2 5 8 7 3 Tamao 0 1 1 8 8 8 2 Uso Datos binarios Verdadero / Falso 0 a 255 Nmeros Fechas Nmeros (Double) Nmeros (Integer)

DB_LONGBINAR Y DB_MEMO DB_SINGLE DB_TEXT

11 12 6 10

0 0 4 n

Objetos Binarios Campos memo Nmeros (Single) Cadena de caracteres.

Algunos de los tamaos especificados por las constantes pueden variar dependiendo de la implementacin en una determinada base de datos. As el tipo de datos String est limitado en Access a una longitud mxima de 64K mientras que el mismo tipo est limitado en el Microsoft SQL Server a 2 gigabites. Size: esta propiedad indica el tamao en bytes de cada campo. Generalmente este tamao viene dado automticamente, es decir, un campo de tipo DB_SINGLE tendr como valor de la propiedad Size el valor 4. Sin embargo, existen otros campos en los que el valor de esta propiedad indicar la longitud mxima de datos que el usuario puede introducir. As por ejemplo, un campo de tipo DB_TEXT puede tener hasta 64K de caracteres, pero asignando un valor a la propiedad Type limitamos la longitud de la entrada de informacin evitando as que desperdiciemos memoria de almacenamiento. Attributes: determina cmo ser tratado el campo por Visual Basic. A continuacin se muestran los tres posibles valores de esta propiedad. DB_AUTOINCREMENT: indicar a Visual Basic que se trata de un campo de tipo contador y el propio Visual Basic se encargar de incrementarlo. DB_FIXFIELD: Indica que este campo pertenece a un tipo de datos con longitud fija, esto es, no se trata de campos de tipo DB_TEXT, DB_MEMO o DB_BYNARY. DB_UPDATABLEFIEL: Indica si el campo es susceptible de ser modificado. CollatingOrder: esta propiedad indicar como se ordenar un determinado campo, dependiendo de los parmetros locales de cada pas. Esta propiedad es suministrada a la base de datos en la funcin CreateDatabase atravs del parmetro Localizacin. OrdinalPosition: determina el orden lgico que corresponde al orden de ingreso de cada registro. SourceTable: es una propiedad de solo lectura que indica cual es la tabla origen. SourceField: tambin es de solo lectura que indica cual es campo origen. Estas dos ltimas propiedades son muy tiles cuando se ha cambido los nombres originales en una pregunta SQL.

21.3.2.- Objeto INDEX

Name: esta propiedad contiene el nombre que recibir el INDICE, en el formato nativo de Access. La longitud de esta propiedad no puede exceder de 64 caracteres. Cada nombre debe ser nico, no podemos tener nombres coincidentes dentro de una misma base de datos. Fields: muestra el campo o los campos que constituirn el ndice. Esta propiedad tiene como longitud mxima 254 caracteres. En caso de que el ndice est formado por mltiples campos, estos irn separados por puntos y coma. Si el ndice causara que los campos sean ordenados en orden descendente o ascendente, se deber especificar dicho orden precediendo a cada nombre del campo que deba ser ordenado el signo + o - para indicar un orden ascendente o descendente respectivamente. El siguiente ejemplo muestra un ndice compuesto por dos campos ordenados de forma ascendente el primero y de forma descendente el segundo. IndiceEjemplo.Fields = +Nombre ; -Apellidos Primary: Esta propiedad slo posee dos valores, Verdadero/Falso e indica si el ndice es el ndice primario. Recuerde el alumno que para cada tabla pueden existir tantos ndices como combinaciones de campos podamos establecer pero tan solo puede existir un solo ndice primario. Unique: tambin posee solo dos valores, Verdadero/Falso e indica si el campo que contiene el ndice puede contener valores que pueden estar repetidos.

21.4.- ABRIENDO UNA BASE DE DATOS Para abrir una base de datos tenemos dos opciones, emplear el control de acceso a bases de datos (ya comentado en el captulo anterior) o emplear la funcin OpenDatabase. La funcin OpenDatabase nos permite abrir una base de datos y por tanto instanciar un nuevo objeto Database (que es idntico al objeto creado cuando abrimos una base de datos con el control de acceso a bases de datos). La funcin OpenDatabase tiene 4 parmetros de los que los tres ltimos son opcionales. OpenDatabase (NombreBaseDatos, Exclusivo, SoloLectura, Conexin) Vamos a revisar cada uno de estos parmetros. NombreBaseDatos: Indica el nombre que tiene la base de datos que deseamos abrir. Es una cadena de caracteres que contiene el path y el nombre de la base de datos. Conexin: contiene una cadena de caracteres que identifica la naturaleza de la base de datos que se quiere abrir. La tabla siguiente muestra los valores correctos para cada uno de los dos parmetros anteriores.

Formato de la base de datos Access Fox Pro V: 2.0 Fox Pro V: 2.5 dBASE III dBASE IV Paradox Btrieve

NombreBaseDatos Path y Fichero MDB Path y Fichero Path y Fichero Path y Fichero Path y Fichero Path y Fichero Path y Fichero

Conexin ---------------------FoxPro 2.0 FoxPro 2.5 dbase III dbase IV paradox; pwd=clave btrieve

Exclusivo: este parmetro es de naturaleza booleana (Verdadero/Falso) e indica si usuarios adicionales pueden tener acceso a la base de datos. SoloLectura: al igual que el anterior, puede tomar los valores Verdadero o Falso e indica si la base de datos es abierta en modo de solo lectura. Si esta propiedad es igual a True, la base de datos no puede ser modificada pero las consultas a dicha base de datos sern ms rpidas, pues hemos librado al gestor de bases de datos de la sobrecarga que supone todo lo relacionado con la incorporacin y edicin de nuevos datos. Podemos abrir diferentes tipos de bases de datos, no solo las bases en formato nativo Access. Para poder abrir otro tipo de bases de datos tenemos que emplear dos de los parmetros anteriores: NombreBaseDatos y Conexin. La siguiente tabla nos muestra todas la posibilidades: Formato Access Fox Pro V: 2.5 dBASE III dBASE IV Paradox Btrieve Funcin OpenDatabase OpenDatabase("ejemplo.mdb", False,False,"") OpenDatabase("c:\ejemfox", False,False,"Foxpro2.5") OpenDatabase("c:\ejdbase3", False,False,"dBase III") OpenDatabase("c:\ejdbase4", False,False,"dBase IV") OpenDatabase("c:\ejpara2", False,False,"paradox; pwd=hola") OpenDatabase("c:\ejemplo.ddf", False,False,"betrieve")

21.5.- COMPACTACIN DE BASES DE DATOS Cuando se produce un periodo largo de trabajo con nuestra base de datos, podemos observar que el tamao de nuestro fichero ha crecido ms de lo que cabra esperar, en base a los datos que hemos aadido o borrado. Visual Basic no se desprende de mucha informacin interna de manejo de dicha base de datos hasta que no se compacta la base de datos con lo que se asegura un ptimo mantenimiento de la base de datos y un mantenimiento de la velocidad de tratamiento de los datos. Sin embargo esto tiene un coste en espacio de disco. El proceso de compactacin consiste en copiar la base de datos de un fichero a otro y durante este proceso reorganizar los datos. Mediante la sentencia CompactDatabase solo es posible compactar bases de datos en formato nativo. Si intentamos compactar una base de datos que est abierta en el momento de su compactacin o que no est en formato nativo se generar un error.

Por lo dicho anteriormente, una base de datos no puede ser compactada sin antes haber sido cerrada o compactar una base de datos en medio de una transaccin. Durante el periodo de compactacin es posible encriptar la base de datos o desencriptarla. La sintaxis de la sentencia CompactDatabase es la siguiente: CompactDatabase BaseDatosOriginal, BaseDatosDestino, Local, Opciones donde, BaseDatosOriginal: es el nombre y el path completo de la base de datos a compactar. BaseDatosDestino: es el nombre y el path completo de la base de datos donde residir la base de datos recin compactada. No es posible especificar el mismo nombre de BaseDatosOriginal y de BaseDatosDestino Local: igual que el parmetro Local ya explicado en anteriores funciones ( CreateDatabase) Opciones: igual que el parmetro Opciones ya explicado en anteriores funciones (CreateDatabase).

21.6.- REPARACIN DE BASES DE DATOS

Puede que desafortunadamente su base de datos sufra un dao motivado por caidas sbitas de tensin, fallo del sistema, bloqueo del sistema operativo, etc. Gracias a la sentencia RepairDatabase podemos reparar la mayor parte de las bases de datos en formato nativo daadas por alguna de las anteriores causas. El procedimiento empleado por esta sentencia consiste en chequear todas las tablas de la base de datos y sus dependencias as como validar los ndices. RepairDatabase solo toma un nico argumento que, como habrs podido adivinar es el nombre completo y el path de la base de datos a reparar. Para reparar nuestra base de datos Ejemplo.mbd tendriamos que escribir: RepairDatabase "C:\ejemplo.mbd" Es buena idea compactar la base de datos recin reparada para eliminar las pginas sobrantes. Con lo que nuestro cdigo de reparacin quedaria como sigue: RepairDatabase "C:\ejemplo.mbd" CompactDatabase "C:\ejemplo.mbd" , "C:\ejemplo1.mbd"

21.7.- MANIPULACIN DE DATOS

La manera ms sencilla de manipular informacin es a travs de una variable Recorset. Esta variable puede contener objetos como Table, Dynaset o Snapshot y por tanto es posible navegar entre los datos que contienen dichos objetos a travs de la variable Recorset. Pero el alumno exclamar y con cierta razn, pero qu demonios son los objetos Dynaset y Snapshot?. Bueno, vayamos poco a poco. Vamos a estudiar detenidamente los tres objetos anteriores. Tabla: es un conjunto de informacin relacionada almacenada en una base de datos, que cuando se producen cambios entre sus miembros, es decir se aaden, editan o se borran, estos cambios pueden ser observados al navegar entre los datos que contiene la variable Recordset que previamente ha sido asignada a un objeto Table. Dynaset: Es el conjunto de informacin relacionada que resulta de una determinada consulta. Los cambios que otro usuario realiza (adicin o borrado de registros) no aparecen en nuestro Dynaset. Sin embargo, los cambios que sufra cualquier dato miembro de nuestro Dynaset ser visto por cualquier usuario que acceda a ese dato. Un Dynaset puede contener campos de una o ms columnas. Snapshot: Es el conjunto de informacin relacionada que resulta de una determinada consulta. Los cambios que otro usuario realiza (edicin o borrado de registros) no aparecen en nuetro Snapshot. Podemos definir tambin a un Snapshot como un tipo de Dynaset cuyos datos no pueden ser cambiados. Digamos que un Snapshot es una fotografia de nuestros datos, que generalmente es usado para generar reports. Para acceder a los datos de una deteminada tabla, debemos primero declarar las variables de tipo Database y de tipo Table y asignarlas sus correspondientes objetos. El siguiente cdigo asigna a la variable BaseDatos un objeto Database que resulta de la funcin OpenDatabase. Seguidamente, utilizamos el mtodo OpenTable del objeto BaseDatos que nos devolver un objeto Table que ser asignado a la variable Tabla. Dim BaseDatos As Database Dim Tabla As Table Set BaseDatos = OpenDatabase ( "C:\ejemplo.mdb") Set Tabla = BaseDatos.OpenTable("DNI") Pero los Dynasets nos ofrecen ms facilidades que las variables de objetos Table. As cuando utilizamos el control de bases de datos o la funcin OpenDatabase estamos creando en realidad un objeto Dynaset. Es posible crear un Dynaset a partir de los datos contenidos en otro Dynaset. Esto facilita el sucesivo filtrado de datos hasta obtener la respuesta deseada.

El siguiente ejemplo crea la variable Dynaset del mismo modo que creamos la anterior variable Tabla, a travs del mtodo CreateDynaset. Dim BaseDatos As Database Dim RespuestaDinamica As Dynaset Set BaseDatos = OpenDatabase ( "C:\ejemplo.mdb") Set RespuestaDinamica = BaseDatos.CreateDynaset("DNI") Tambin podemos crear una variable Dynaset como resultado de una consulta SQL. El siguiente cdigo muestra el Dynaset correspondiente a una cosulta SQL que nos devolver el conjunto de registros de nuestra tabla DNI que han nacido antes de 1959. Dim BaseDatos As Database Dim RespuestaDinamica As Dynaset Dim ConsultaSQL As String ConsultaSQL = "Select Nombre from DNI where FechaNacimiento < 1959" Set BaseDatos = OpenDatabase ("C:\ejemplo.mdb") Set RespuestaDinamica = BaseDatos.CreateDynaset("ConsultaSQL") Como ya hemos dicho, podemos obtener una Dynaset cuando usamos el control de bases de datos. El siguiente cdigo muestra cmo podemos obtener un Dynaset a partir del control de acceso a bases de datos Data1 y de su propiedad Recordset. Dim RespuestaDinamica As Dynaset Set RespuestaDinamica = Data1.Recordset Vamos a obtener un Dynaset de otro Dynaset. Ahora escribiremos el cdigo que nos permitir obtener todos los registros de nuestra Tabla DNI que hayan nacido antes de 1950 y despus de 1930 y posteriormente los ordenaremos por el campo Nombre. Como el alumno puede ver, la primera variable Dynaset, RespuestaDinamica1 contendr los registros de los espaoles nacidos antes de 1950. La variable Dynaset RespuestaDinamica2 contendr los espaoles nacidos entre 1930 y 1950 y adems ordenados por el campo Nombre. Dim BaseDatos As Database Dim RespuestaDinamica1 As Dynaset Dim RespuestaDinamica2 As Dynaset Dim ConsultaSQL1 As String Dim ConsultaSQL2 As String ConsultaSQL1 = " Select Nombre from DNI where FechaNacimiento < 1950 " Set BaseDatos = OpenDatabase ( "C:\ejemplo.mdb") Set RespuestaDinamica1 = BaseDatos.CreateDynaset("ConsultaSQL") ConsultaSQL2 = " Select Nombre from DNI where FechaNacimiento > 1930 " RespuestaDinamica1. Filter = ConsultaSQL2 RespuestaDinamica1. Sort = "[Nombre]" Set RespuestaDinamica2 = RespuestaDinamica1.CreateDynaset() Es posible aadir registros a un determinado Dynaset. Estos registros sern aadidos al final del Dynaset (no importa si existe un orden prefijado en el dynaset). Imediatamente Visual Basic aadir estos registros a la base de datos, a menos que la incorporacin de dichos registros

al dynaset haya sido realizado en medio de una transaccin. En ese caso los registros no sern incorporados a la base de datos hasta que no se ejecute la sentencia CommitTrans. De la misma forma, si borramos un registro de un Dynaset, Visual Basic lo borrar inmediatamente de la base de datos a menos que nos encontremos en medio de una transaccin. Por otra parte, si editamos un registro que se encuentre en un Dynaset, no cambiar de posicin aunque afecte el cambio de alguno de los campos a los ndices de dicha tabla. Si hemos utilizado un Dynaset que comparte registros con otro Dynaset, cualquier adicin o borrado de registros del primero, estas modificaciones no aparecern en el segundo hasta que no se reconstruya. Para reconstruir un Dynaset tan solo debemos ejecutar el cdigo siguiente Set RespuestaDinamica1 = RespuestaDinamica1.CreateDynaset () Una vez vista la creacin y utilizacin de los Dynaset, vamos a crear las variables Snapshot. Como ya dijimos, crear un SnapShot es muy similar a la creacin de un Dynaset. Las siguientes lneas de cdigo crearn un Snapshot de la tabla DNI, observe el alumno la similitud entre este cdigo y el cdigo que anteriormente nos sirvi para crear el correspondiente Dynaset. Dim BaseDatos As Database Dim RespuestaEstatica As Snapshot Set BaseDatos = OpenDatabase ( "C:\ejemplo.mdb") Set RespuestaEstatica = BaseDatos.CreateSnapshot("DNI") Es posible crear un Snapshot de una variable Snapshot o de un Dynaset. El cdigo siguiente nos permitir obtener todos los registros de nuestra Tabla DNI que hayan nacido antes de 1950 que formarn el Dynaset y despus obtendremos un Snapshot que contendr los espaoles nacidos entre 1550 y 1930, ordenados por el campo Nombre. Como el alumno puede ver, la primera variable Dynaset, RespuestaDinamica contendr los registros de los espaoles nacidos antes de 1950. La variable Snapshot RespuestaEstatica contendr los espaoles nacidos entre 1930 y 1950 y adems ordenados por el campo Nombre. Dim BaseDatos As Database Dim RespuestaDinamica As Dynaset Dim RespuestaEstatica As Dynaset Dim ConsultaSQL1 As String Dim ConsultaSQL2 As String ConsultaSQL1 = " Select Nombre from DNI where FechaNacimiento < 1950 " Set BaseDatos = OpenDatabase ( "C:\ejemplo.mdb") Set RespuestaDinamica = BaseDatos.CreateDynaset("ConsultaSQL1") ConsultaSQL2 = "Select Nombre from DNI where FechaNacimiento > 1930" RespuestaEstatica.Filter = ConsultaSQL2 RespuestaEstatica.Sort = "[Nombre]" Set RespuestaEstatica = RespuestaDinamica.CreateSnapshot() Hay que mencionar que no es posible crear un Dynaset a partir de un Snapshot existente.

21.8.- PROPIEDADES DE LOS OBJETOS: TABLE, DYNASET, SNAPSHOT

Filter: Aplicable a Dynaset y SnapShot solamente. Condicin de filtro que ser aplicada cuando se crea un Dynaset o un SnapShot. Index: Aplicable solamente a Table. El nombre del ndice de una tabla. Sort: Aplicable a Dynaset y SnapShot. Condicin de ordenacin que ser aplicada cuando se crea un Dynaset o un SnapShot. BOF: Aplicable a Table, Dynaset y SnapShot. Devolver True si estamos situados en el primer registro y False en caso contrario. EOF: Aplicable a Table, Dynaset y SnapShot. Devolver True si estamos situados en el ltimo registro y False en caso contrario. Bookmark: Aplicable a Table, Dynaset y SnapShot. Devolver un puntero al registro acrual, que ser posteriormente utilizado para volver a este registro. Bookmarkable: Aplicable a Table, Dynaset y SnapShot. Devolver True si existe la posibilidad de utilizar Bookmark, False en caso contrario. LastModified: Aplicable a Table, Dynaset y SnapShot. Devolver un puntero al ltimo registro que ha sido insertado o editado. NoMatch: Aplicable a Table, Dynaset y SnapShot. Devolver True si el ltimo mtodo Seek o Find no hubieran encontrado registros. Connect: Aplicable a Table, Dynaset y SnapShot. Contiene el string de conexin para las tablas adicionales. Para las tablas base su contenido est vaco. DateCreated: Aplicable a Table, Dynaset y SnapShot. Devolver la fecha de creacin . LastUpdated: Aplicable a Table, Dynaset y SnapShot. Devolver la fecha de la ltima modificacin.

21.9.- ORDENACIN DE REGISTROS

Vamos a ver los diferentes mtodos de ordenacin de los registros en una tabla, recorset y snapshot. El orden de los registros en una tabla es el del orden de ingreso de stos en dicha tabla. Si no necesitamos presentar los datos de la tabla en un orden predeterminado podemos utilizar el orden fsico de los registros.

Tambin es posible acceder a los registros de una tabla de acuerdo al orden especificado por alguno de sus ndices. Para sto tan solo tenemos que asignar a la propiedad Table.Index el nombre del ndice que queramos emplear. El cdigo que sigue corresponde a la creacin de la variable Tabla que contendr los datos de la tabla DNI ordenados segn el ndice NombreApellidos. Dim BaseDatos As Database Dim Tabla As Table Set BaseDatos = OpenDatabase ("C:\ejemplo.mdb") Set Tabla = BaseDatos.OpenTable("DNI") Tabla.Index = "NombreApellidos" Si queremos determinar el orden de los registros en un Dynaset o en un Snapshot lo tenemos que explicitar durante su creacin. No es posible ordenar el contenido de un Dynaset o un Snapshot una vez que ha sido creado, pero podemos ordenarlo creando otro Dynaset u otro Snapshot especificando durante su creacin el orden deseado. El cdigo que sigue, primero crea un Dynaset que contiene los datos sin ordenar de la tabla DNI. Posterirmente se crea un nuevo Dynaset basado en el primero cuyos registros estarn ordenados segn registro Nombre y de forma descendente. Dim BaseDatos As Database Dim RespuestaDinamica As Dynaset Dim RespuestaDinamicaOrdenada As Dynaset Set BaseDatos = OpenDatabase ("C:\ejemplo.mdb") Set RespuestaDinamica = BaseDatos.CreateDynaset("DNI") RespuestaDinamica.Sort = "Nombre Desc" Set RespuestaDinamicaOrdenada = RespuestaDinamica.CreateDynaset () La cadena de caracteres que asignamos a la propiedad Sort debe ser una cadena que sea vlida para la realizacin de una consulta. Si queremos que la ordenacin se haga en base a ms de un campo, deberemos explicitar el nombre de dichos campos separados por comas. Si aadimos la palabra Asc o Desc a los nombres de los campos, stos se ordenarn de forma ascendente o decendente respectivamente.

21.10.- NAVEGACIN ENTRE REGISTROS

Para navegar entre los diferentes registros perteneciente a una Tabla, Dynaset o Snapshot, Visual Basic crea la figura del Registro actual , es decir, el registro que es directamente accesible y que es nico (slo podemos acceder a un registro en un determinado instante). Para posicionarnos en un determinado registro podemos utilizar varios mtodos: Seek, Move o Find que posteriormente explicaremos detenidamente. Debemos buscar el mtodo de posicionamiento que ms rpido nos permita posicionarnos en un determinado registro. La siguiente tabla muestra los mtodos de acceso ms adecuados para cada caso.

Accin
Moverse a un registro adyacente o muy prximo Comienzo o Final de la tabla Moverse a un determinado registro en una tabla Moverse a un determinado registro en un Dynaset o snapshot Volver a un determinado registro

Mtodo
MoveNext o MovePrevious MoveFirst o MoveLast Seek Find Utilizamos la propiedad Bookmark

Cuando queremos acceder a un registro o grupo de registros que no pueden ser accedidos de una manera eficiente con ninguno de los mtodos anteriores tendremos que utilizar una consulta (Query). En los ejemplos siguientes veremos el cdigo necesario para avanzar hacia delante y hacia atrs, al principio y final de un Dynaset determinado. Sub MoverAdelante () Dim BaseDatos As DataBase Dim RespuestaDinamica As Dynaset Set BaseDatos = OpenDatabase ( "ejemplo.mdb") Set RespuestaDinamica = BaseDatos.CreateDynaset ( DNI ) RespuestaDinamica .MoveNext RespuestaDinamica.Close BaseDatos.Close End Sub Sub MoverAtras () Dim BaseDatos As DataBase Dim RespuestaDinamica As Dynaset Set BaseDatos = OpenDatabase ( "ejemplo.mdb") Set RespuestaDinamica = BaseDatos.CreateDynaset ( DNI ) RespuestaDinamica .MovePrevious RespuestaDinamica.Close BaseDatos.Close End Sub Sub MoverAlPrincipio() Dim BaseDatos As DataBase Dim RespuestaDinamica As Dynaset Set BaseDatos = OpenDatabase("ejemplo.mdb") Set RespuestaDinamica = BaseDatos.CreateDynaset(DNI) Do Until RespuestaDinamica.EOF RespuestaDinamica .MoveNext Loop RespuestaDinamica.Close BaseDatos.Close End Sub Sub MoverAtras () Dim BaseDatos As DataBase Dim RespuestaDinamica As Dynaset

Set BaseDatos = OpenDatabase ("ejemplo.mdb") Set RespuestaDinamica = BaseDatos.CreateDynaset (DNI) Do Until RespuestaDinamica.BOF RespuestaDinamica .MovePrevious Loop RespuestaDinamica.Close BaseDatos.Close End Sub Como el alumno podr observar, si solo dispusiramos de los mtodos anteriores para navegar entre los registros de una tabla, sera algo penoso y de poca utilidad. Ya vimos anteriormente que Visual Basic dispone del mtodo Find, el cual puede ser empleado para buscar un registro que concuerde con un determinado criterio de bsqueda. El mtodo Find solo puede ser empleado en Dynasets o Snapshot. Los objetos Tables no poseen este mtodo. La tabla siguiente muestra los diversos mtodos Find, su utilidad y el punto de comienzo de la bsqueda.
Mtodo FindFirst criterio FindLast criterio FindNext criterio Findprevious criterio Lo que busca El primer registo que cumpla el criterio El ltimo registro que cumpla el criterio El siguiente registro que cumple el criterio El registro previo que cumple el criterio Punto de comienzo de la bsqueda Primer Registro ltimo Registro Registro Actual Registro Actual

El criterio como ya se mencion anteriormente debe ser una cadena de caracteres que puede ser susceptible de ser usada en una clusula WHERE de una sentencia SQL. Los mtodos Find anteriores no producen ningn cambio en la naturaleza de los registros de un determinado Dynaset o Snapshot, tan solo localizan un determinado registro que responde a un determinado criterio de bsqueda. El ejemplo que se codifica a continuacin, crea un Dynaset de nuestra tabla DNI de la base de datos "Ejemplo.MBD" y busca todos los registros cuyo nombre es PABLO e introduce el valor del campo Nombre y del campo Apellidos en una caja de lista. Sub EcuentraPablo(CajaLista as ListBox) Dim BaseDatos As Database Dim RespuestaDinamica As Dynaset Dim Criterio As String Criterio = "Nombre LIKE *PABLO*" Set BaseDatos = OpenDatabase ("C:\ejemplo.mdb") Set RespuestaDinamica = BaseDatos.CreateDynaset(DNI) RespuestaDinamica.FindFirst Criterio Do Until RespuestaDinamica.NoMatch CajaLista:AddItem RespuestaDinamica.FindNext RespuestaDinamica ("Nombre") & ""RespuestaDinamica ("Apellidos") Loop RespuestaDinamica.Close BaseDatos.Close

End Sub Si tenemos una variable Table indexada, existe una forma de bsqueda de datos extremadamente rpida. Esta bsqueda rpida se logra empleando el mtodo Seek. Hay que decir que el mtodo Seek usa inescusablemente un ndice. De hecho la rapidez que caracteriza a esta bsqueda se debe en gran parte al uso de dicho ndice. El ejemplo siguiente busca todos los registros cuya primera letra del campo nombre sea una P. Dim BaseDatos As Database Dim Tabla As Table Dim Criterio As String Criterio = " Nombre LIKE *PABLO* " Set BaseDatos = OpenDatabase("C:\ejemplo.mdb") Set Tabla= BaseDatos.OpenTable(DNI) Tabla.Index = "NombreApellidos" Tabla.Seek "=" , "P" If Tabla.NoMatch then MsgBox "No he encontrado niguna P en el campo Nombre" Else MsgBox Tabla.("Nombre") & " " & Tabla.("Apellidos") End If Tabla.Close BaseDatos.Close

21.11.- UTILIZACIN DE LAS CONSULTAS

Definimos QueryDef como una variable objeto que contiene una sentencia SQL que describe una consulta. Por tanto, utilizaremos las QueryDef para grabar consultas predefinidas en el fichero de la base de datos. Una Querydef no almacena registros, sino que almacena la definicin de una determinada consulta que ser aplicada sobre un determinado conjunto de registros. Si queremos crear una nueva consulta tan solo tendremos que ejecutar el cdigo siguiente: Dim BaseDatos As Database Dim Consulta As QueryDef Set BaseDatos = OpenDatabase ("C:\ejemplo.mdb") Set Consulta = BaseDatos.CreateQueryDef ("ConsultaNueva") Ya tenemos el objeto QueryDef al que hemos llamado Consulta. Ahora debemos de asignar una sentencia SQL vlida a la consulta recin creada. El siguiente cdigo asigna una sentencia SQL que ser la encargada de buscar el nombre de todos los espaoles que hayan nacido despus de 1980. Consulta.SQL = "Select Nombre from DNI where FechaNacimiento > 1980"

Tambin es posible codificar la consulta de un solo paso, esto es: Dim BaseDatos As Database Dim Consulta As QueryDef Set BaseDatos = OpenDatabase ("C:\ejemplo.mdb") Set Consulta = BaseDatos.CreateQueryDef ("ConsultaNueva", "Select Nombre from DNI where FechaNacimiento > 1980") Si bien, hemos definido la consulta, todava no la hemos realizado sobre ningn conjunto de datos. Para ejecutar dicha consulta, tan solo debemos crear el Dynaset o SnapShot correspondiente. Dim BaseDatos As Database Dim RespuestaDinamica As Dynaset Dim Consulta As QueryDef Set BaseDatos = OpenDatabase("C:\ejemplo.mdb") Set Consulta = BaseDatos.CreateQueryDef ("ConsultaNueva", "Select Nombre from DNI where FechaNacimiento > 1980") Set RespuestaDinamica = Consulta.CreateDynaset() Consulta.Close RespuestaDinamica.Close BaseDatos.Close Como vemos en el ejemplo anterior, el objeto Consulta debe ser Cerrado al igual que los dems objetos. Si queremos borrar una consulta previamente definida, emplearemos el mtodo DeleteQueryDef. Consulta.DeleteQueryDef "ConsultaNueva" Tambin podemos utilizar consultas que existen previamente. El siguiente cdigo cargar la consulta "ConsultaNueva" grabada anteriormente y obtendremos un Dynaset que contendrn los registros ya filtrados por dicha consulta previamente grabada. Dim BaseDatos As Database Dim RespuestaDinamica As Dynaset Dim Consulta As QueryDef Set BaseDatos = OpenDatabase ("C:\ejemplo.mdb") Set Consulta = BaseDatos.OpenQueryDef ("ConsultaNueva") Set RespuestaDinamica = Consulta.CreateDynaset ( ) Consulta.Close RespuestaDinamica.Close BaseDatos.Close

CAPTULO 22

DISTRIBUCIN DE APLICACIONES VISUAL BASIC 22.1.- INTRODUCCIN

Cuando creamos una aplicacin para que sea utilizada por otras personas o bien porque sea cedida o bien porque se distribuye desde un punto de vista comercial, es importante que dicha aplicacin pueda incorporar un programa de instalacin. La misin del programa de instalacin no solo consiste en hacer ms bonito un programa, sino que tambin consiste en ir indicando al usuario los diferentes pasos que hay que dar para la correcta instalacin de la aplicacin. La elaboracin de atractivos programas de instalacin est muy unida al desarrollo de los interfaces grficos de usuario, de los cuales Windows es un fenomenal ejemplo. Actualmente, no hay aplicacin bajo Windows que se precie y que no contenga un programa de instalacin. En ese programa de instalacin el usuario toma partido en el sentido de que es l quien decide dnde quiere instalar la aplicacin, decide si quiere una instalacin completa o tan solo alguna parte e incluso puede elegir opciones de ms bajo nivel relacionadas con la memoria del sistema entre otras cosas. En caso que el usuario no se sienta lo suficientemente fuerte para elegir entre diferentes opciones, ser el propio programa el que sugiera unas opciones de instalacin por defecto. En resumen, decir que si bien un programa de instalacin no hace que una aplicacin sea o no buena, si que ayuda por un lado a una mejor venta del producto al hacer ms amigable la aplicacin, y por otro a que se pueda distribuir a usuarios no especialistas ya que les indicar los pasos a seguir para instalar el programa.

22.2.- UTILIDAD SETUPWIZARD

La versin 3.0 de Visual Basic, incorpora en su edicin estndar el programa SetupWizard, indicado para crear discos de distribucin para las aplicaciones que hagamos en Visual Basic. Las principales caractersticas de esta utilidad son: - creacin de un programa de instalacin, - construir el fichero ejecutable de la aplicacin, - comprimir los ficheros a distribuir, - notifica el nmero de disquetes que necesitaremos, - coloca los ficheros en los diferentes disquetes.

22.2.1.- CREACIN DE DISCOS DE DISTRIBUCIN

El primer paso que tenemos que dar es grabar en formato ASCII text todos los ficheros que forman nuestra aplicacin. De todos debe ser conocido que la forma de hacer esto es seleccionando la casilla Save As Text que se encuentra en el cuadro de dilogo de la opcin Save File As (men File). El resto, queda en manos de SetupWizard, lo cual hace muy fcil la labor del programador. 1.- Ejecutar la aplicacin SetupWizard que se encuentra en el grupo de programas de Visual Basic. 2.- Introducir el path completo del fichero .MAK de nuestra aplicacin. Esto se hace dentro de la ventana que aparece al ejecutar SetupWizard. Es importante sealar aqu, que si nuestra aplicacin no contiene un fichero .EXE el programa SetupWizard lo crea automticamente.

Fig. 22.1.- Ventana del programa SetupWizard.

3.- Seleccionar, en la nueva ventana que aparece, aquellas caractersticas que soporta nuestra aplicacin. Estas quedan reflejadas en la siguiente figura.

Fig. 22.2.- SetupWizard. Caractersticas de nuestra aplicacin. 4.- Especificar el nombre de la unidad de disco y la densidad de ste, en la que vamos a distribuir los ficheros.

Fig. 22.3.- SetupWizard. Unidad del disco de distribucin.

Fig. 22.4.- SetupWizard. Lista de ficheros que la aplicacin requiere. 5.- Al introducir estas caractersticas, el propio programa inicia la compresin de ficheros y su instalacin en la unidad de disco especificada.

22.3.- HERRAMIENTAS DE INSTALACIN PERSONALIZADA

Hemos visto la sencillez con la que SetupWizard puede crear discos de instalacin de aplicaciones Visual Basic. Sin embargo, si se quiere disear un programa de instalacin ms completo y a voluntad del programador, la utilidad SetupWizard se queda corta y necesitaremos de algo ms potente. Visual Basic incorpora un kit de instalacin que nos permitir disear programas de instalacin a medida. Entre las cosas que podemos hacer con este kit, destacan: - ajustar la tasa de compresin de los ficheros al tamao del disco de distribucin, - preinstalacin de ficheros requeridos para la instalacin propiamente dicha, - aspecto grfico del programa personalizado, - instalar los ficheros en el directorio de Windows adecuado, - instalacin de la aplicacin en la mquina del usuario, - capacidad para decidir si un fichero debe ser copiado en el sistema del usuario o no debe copiarse, - creacin de grupos de programas dentro de Windows con los iconos correspondientes a nuestra aplicacin.

El kit de desarrollo de programas de instalacin que incluye Visual Basic, est formado por seis ficheros:

SETUP.EXE SETUP1.EXE SETUP.LST SETUP1.BAS SETUPKIT.DLL VER.DLL El primero de ellos, SETUP.EXE, corresponde a un programa de preinstalacin, el cual se ejecutar desde el ordenador del usuario e inicia la copia de los ficheros necesarios para la instalacin. SETUP1.EXE podra entenderse como un programa desarrollado en Visual Basic y que servir de modelo para crear nuestro propio programa de instalacin. SETUP.LST es un fichero de texto en el cual se debe indicar en primer lugar el nombre de nuestro programa de instalacin y a continuacin el nombre de los diferentes ficheros que SETUP.EXE preinstalar en el ordenador del usuario. SETUP1.BAS contiene una coleccin de funciones de Visual Basic. SETUPKIT.DLL es una librera que contiene algunas de las funciones usadas en el fichero anterior. VER.DLL contiene las funciones necesarias para copiar y descomprimir los ficheros.

22.3.1.- UTILIZACIN DE LAS HERRAMIENTAS DE INSTALACIN PERSONALIZADA

Aunque no vamos a describir con detalle todos y cada uno de los procesos necesarios para hacer la instalacin personalizada, si que enunciaremos todos ellos de forma abreviada. La razn fundamental de no explicar todos los pasos no es otra que evitar que el eunciar aqu docenas de ficheros que deben incluirse y enumerar funciones se salga del nivel del presente curso, y haga perder claridad al alumno. Adems, ya se ha descrito el programa SetupWizard el cual permite de una manera sencilla realizar discos de instalacin. La curiosidad del alumno puede satisfacerse en el manual del programador suministrado con Visual Basic, en el cual se indica con mayor detalle cmo construir un programa de instalacin personalizado. Los pasos necesarios para crear discos de distribucin para una aplicacin hecha en Visual Basic son: 1.- Tener una idea clara de todos los ficheros que vamos a distribuir. 2.- Editar el fichero SETUP.LST e incluir en l los nombres de los ficheros a distribuir. 3.- Comprimir los ficheros. 4.- Determinar que ficheros deben ir en cada disco de instalacin.

5.- Determinar en qu lugar del ordenador del usuario se deben colocar los ficheros. 6.- Escribir el programa de instalacin propiamente dicho. 7.- Creacin de los discos de distribucin. 8.- Probar que todo funciona de forma correcta y que el programa se instala tal y como queramos.