Impresiones Con Visual Basic 2010

5/6/2018 Impresiones Con Visual Basic 2010 - slidepdf.com

http://slidepdf.com/reader/full/impresiones-con-visual-basic-2010 1/24

Impresiones con Visual Basic 2010

Pese a que vivimos en una era digital y todo (bueno, casi todo) se hace por

internet y con la computadora, aún hay momentos en que el papel es necesario.

Hace tiempo escribí un post donde indicaba cómo imprimir usando Visual Basic

6, pero no había tenido la oportunidad de hacer lo mismo con el Visual Basic

.net. Y eso precisamente es lo que pienso hacer en esta ocasión: mostrar como usar los controles y

cajas de diálogo para imprimir y la forma de imprimir tanto texto como imágenes.

Antes de continuar con rollo, código, ejemplos y demases, voy a describir brevemente los

componentes que tiene Visual Basic 2010 para imprimir.

Control PrintDocument

Este control se debe agregar a cualquier proyecto en el que se quiera imprimir algo. Haz de cuenta

que es la hoja en blanco donde puedes dibujar diferentes objetos, escribir texto y colocar imágenes

de mapa de bits. Cuando acabes de dibujar, escribir, etc., se llama el método Print para que la

impresora escupa la hoja. Acepta todos los métodos de dibujo que usa el objeto Graphics (mismo

del que di ejemplos aquí y aquí), es decir que si tienes que escribir texto, usas el

método DrawString; si quieres dibujar un marco alrededor del texto, puedes

usar DrawLine o DrawRectangle. Aunque el control es invisible (no aparece en la ventana ni hay

forma de ir viendo conforme se va dibujando), es muy útil.

Control PrintDialog

Este control hace aparecer la ventana default que te permite elegir y configurar la impresora que se

desea emplear. Si no se usa, la impresión se hace en la impresora que se tiene definida como default

con las propiedades que trae por default (o sea con lo default de lo default ). Para que aparezca,

se debe usar el método ShowDialog.

Control PageSetupDialog

Este control hace aparecer la ventana que te permite configurar el papel a usar: tamaño,

orientación, márgenes, etc. Se debe usar su método ShowDialog para que aparezca, igual que con

el control PrintDialog.



Control PrintPreviewDialog

Este control hace aparecer una vista previa de lo que se va a imprimir. Como mostraré más

adelante, se debe vincular este control con lo el control PrintDocument para que todo lo que se va

a imprimir, en lugar de ir a la impresora, aparezca en esta ventana. También hay que tener cuidado:

si no se tiene acceso a la impresora que está seleccionada (por ejemplo, una impresora de la red a la

cual no tengo acceso en este momento o la que tengo conectada está apagada), no aparece la

ventana y te marca error. Es necesario recibir este error (con un Try«Catch) para que no termine

abruptamente el programa solo porque no halla la impresora (cosa que no hago en este post, por

cierto).

Ejemplo de su uso

Después de este rollo (que espero que haya sido breve), voy a ejemplificar el uso de estos controles

en un programa que hice con mis queridísimos alumnos de 4TPO. Es un ejemplo muy simple que

solo muestra como se usan los controles. Sin embargo, creo que con estas bases ya le pueden echar

vuelo a la imaginación para aplicarlo en otros contextos.

Antes que nada, les muestro el diseño de la ventana principal. Consta de 3 etiquetas, 3 cajas de

texto (txtNombre, txtDir y txtRFC), un PictureBox (picCanoa) que sirve para mostrar como

imprimir una imagen de mapa de bits, 7 botones cuyo código explicaré más adelante, 2

controles PrintDocument, un PrintDialog, un PageSetup y unPrintPreviewDialog. Estos

5 últimos no aparecen en la ventana: cuando los agregas a la ventana aparecen en la parte inferior.



Para que un PrintDocument funcione, es necesario editar su evento PrintPage. Si le das doble

clic al icono PrintDocument1, verás este código:

Básicamente uso el parámetro e, que es ³la hoja invisible´ sobre la que voy a dibujar, para escribir 3

cadenas, un rectángulo y la imagen de la canoa. Como mencioné con anterioridad, son las mismas

funciones que se usan para dibujar gráficos sobre la ventana cosa que ya escribí en este post y en

este también.

Una vez que tienes este evento listo, puedes mandar imprimir con la función Print. Yo lo hago con

el botón cuya etiqueta dice Imprimir y este es el código:



El PrintDocument2 muestra una idea para imprimir formatos. Dibujé el esqueleto de un formato,

lo guardé como PNG, lo importé a Visual Basic y lo puse en

un PictureBox(llamado PictureBox1) en la ventanafrmPicts. Aquí está la

ventana frmPicts y abajo el código que lo usa (primero elel botón que tiene la etiqueta Imprimir

formato,btnImprime2, y luego PrintPage).

Configurar la impresora es muy simple usando el control PrintDialog. Este es el código del

botón con la etiqueta C onfigurar impresora. Fíjate en la manera en que copio las propiedades

puestas por el usuario en este cuadro de diálogo en los dos controlesPrintDocument (en las 2

últimas instrucciones):



A la hora de ejecutarse, el control PrintDialog hace que aparezca esta ventana:

También es sencillo modificar la configuración de la página. Este es el código del botón

etiquetado C onfigurar página:

Antes del ShowDialog es necesario igualar sus propiedades a los que ya tiene

unPrintDocument (en las dos instrucciones que siguen al comentario). Al correr este evento,

aparece esta ventana:



Una vista previa (o presentación preeliminar) de lo que se va a imprimir suele ser bastante útil para

muchos usuarios. Hacer que aparezca es sencillísimo. Lo único que hay que hacer es hacer que, en

lugar de que el evento PrintPage de un PrintDocument lo mande a la impresora, se le envía a

esta caja de diálogo. Abajo pongo el código y luego la ventana que aparece que muestra la vista

preeliminar:



También es posible jugar con la configuración de la impresora. Para leer algunas propiedades de las

impresoras, hice el botón etiquetado Lista de impresoras que abre la

ventana frmImpresoras desde donde se pueden ver la lista de impresoras instaladas y al

seleccionar una de ellas, se ven algunas de sus propiedades. Esta es la ventanafrmImpresoras en

la vista diseño:

Tiene una lista donde voy a escribir la lista de impresoras (ListBox1), etiquetas que muestran los

valores de las copias, si es duplex (si puede imprimir por ambas caras de la hoja), el número

máximo de copias permitidas y si puede recibir documentos a color

(lblCopias, lblDuplex, lblCopiasMax y lblColor, respectivamente). También es necesario

un PrintDocument para poder ver estas propiedades. Pero antes que nada, veamos el código con

que llena ListBox1:



Nótese que estoy haciendo uso de la

colecciónPrinting.PrinterSettings.InstalledPrinters misma que contiene la lista de

todas las impresoras instaladas en el equipo donde se está ejecutando. Estoy usando la

instrucciónWith para abreviar un poco y no escribir este rollo a cada rato.

No necesito escribir un evento PrintPage para el PrintDocument1 porque no voy a imprimir nada:

solo lo necesito para poder mostrar las propiedades. Por esta razón el otro código interesante es el que se

ejecuta cuando ListBox1 cambia de elemento seleccionado:

Este es un ejemplo de como se ve esta ventana con una impresora seleccionada:



Menus en Visual Basic .net y 2005

Hay dos tipos de menus que se pueden poner en aplicaciones hechos en Visual Basic .NET: el menú

principal (MenuStrip) y el contextual (ContextMenuStrip). Como dijo Jack el destripador, vámonos

por partes...

El menú principal es el que aparece en las aplicaciones abajo de la barra de la ventana (o sea, la

tirita que dice "Archivo, Edición, etc."). Para crear uno, se tiene que arrastrar el objetoMenuStrip a

la ventana. El ambiente de diseño cambia un poco: el "control" aparece en la parte inferior, fuera de

la ventana y en la parte superior de la ventana (o forma) que estás creando, aparece una cajita que

dice "Escriba aquí". La pantalla se ve algo así:

Al darle click sobre ese mensaje, te permite escribir un texto (el letrero del primer menú) y aparecen

"huecos" para escribir más opciones.

Las siguientes imágenes muestran el efecto que tiene ir tecleando opciones del menú.



Visualmente quedó muy padre. Ahora, ¿qué hacemos? Programar las opciones se hace como con

cualquier otro control. En este caso, le dí un doble click sobre la leyenda "FamousStar" y me aparece

la ventana de código así:



Ya que solo es un ejemplo y no quiero complicarme la vida, solo voy a hacer que aparezca una

ventana que diga lo que eligió, así que agrego el código que hace aparecer un MessageBox de la

siguiente manera:

Al correr el programa y al seleccionar la hamburguesa "FamousStar", aparece esta ventana:

Fácil, ¿no? Ahora toca retar a un menu contextual a un duelo. Bueno, exageré. Pero de todos modos

vamos a crear un menu contextual. Es muy similar al menú principal, con algunas pequeñas

variantes que iré detallando. Para empezar, tenemos que añadir el controlContextMenuStrip a la

ventana para que quede abajo de la ventana que estoy diseñando. Algo así:

Como observarás es casi idéntico que el menú principal, solo que aquí no puedes cambiar el texto

ContextMenuStrip1. Ahora puedes escribir las diferentes opciones de la misma manera en que lo

hice con el menú principal. A mí me quedó así:



No te vayas a sacar de onda: si le das click afuera de la ventana del menú contextual que aparece,

desaparece. Para volverlo a abrir, haz un doble click sobre el ContextMenuStrip1 (suponiendo que

no le has cambiado el nombre) que está abajo de la ventana.

Al hacerlo, vuelve a aparecer el menú para que puedas seguir trabajando en él.

Agregar código a las opciones del menú contextual es idéntico a la manera en que se agregan en el

menú principal (cosa que ya expliqué más arriba). Pero para que funcione, tenemos que programar



el momento en que queremos que aparezca ese menú. Lo más común es hacer aparecer un menú

contextual al darle un click con el botón derecho del mouse. Así que hay que programar el evento

MouseDown. Yo programé el evento MouseDown de una etiqueta (Label1) porque me interesa que

abra cuando estoy sobre el label, pero si quieres que aparezca cuando le das click derecho sobre la

ventana, pon este código bajo el evento MouseDown del Form.

Espero que se haya entendido porque lo estoy programando bajo Label1_MouseDown() y no

bajo Form1_MouseDown() como probablemente harías en tu proyecto, así que ahora hay que

decirle al programa que si el botón presionado es el derecho, que haga aparecer el menú contextual.

Se supone que en otra parte ya programamos lo que va a hacer cada opción (de la misma manera en

que lo hacíamos para las opciones del menú principal). Esto sería así:

¡Y ya! Usamos la función Show que sirve para mostrar el menú en las coordenadas dadas. En

nuestro caso, le estamos pasando las coordenadas del lugar donde está el cursor de nuestro mouse

(e.X y e.Y).



Heredando la pura guapura«

Algo que me da mucha flojera al programar con Visual Basic 6 o 2005 es el tener que dibujar

interfaces de las ventanas (o formularios o formas, como dicen algunos porque por defáult se

llaman Form1, Form2, etc.). Es muy importante tardar un rato diseñando el interfaz porque de eso

depende que el usuario pueda y quiera usar tu programa, si le es de utilidad y, si es tu caso, si te lo

compra. Es importante que no solo sea bello, sino funcional (hace tiempo escribí un artículo sobre

las interfaces gráficas, o GUIs, que puedes ver aquí).

Lo peor de este rollo es cuando tienes que dibujar otra ventana que es muy similar a otra. O una de

dos: o creas otra ventana y la dibujas de nuevo, o copias el archivo de la ventana (en VBasic 6 tiene

la extensión.frm

) y lo pegas con otro nombre e importas este nuevo archivo a tu proyecto.

Cualquiera de las dos alternativas no es muy natural que digamos y, si estoy usando un lenguaje

quesque orientado a objetos (digo quesque porque el único lenguaje de programación que conozco

que totalmente orientado a objetos es el SmallTalk ), debería poder aprovechar la herencia para

evitar andar repitiendo cosas. Si no, ¿para qué me sirve la OOP (programación orientada a

objetos)?

¡Buenas noticias! La gente deMicrosoft ha escuchado las plegarias de muchos programadores y han

agregado una manera ³natural´ de crear formas similares: la herencia visual. En este artículo, voy aexplicar como es que se heredan las ventanas.

Para explicar esto, voy a hacer un programa muy sencillo: una ventana con una etiqueta, una caja de

texto y dos botones. Luego, voy a agregar una ventana (o formulario) heredado para que se vea

como heredo la interfaz.

Para iniciar, creo un nuevo proyecto y diseño mi Form1 de esta manera:



Voy a agregar código al botón Salir (Button2) que haga que el programa se excite (o sea, haga

un Exit): le incluyo la instrucción End. Para poder heredar esta forma, es necesario generar el

proyecto (si no se compila Form1, no se puede heredar). Para hacerlo fácil, me voy al menú Generar

y escojo la opción Generar HerenciaVisu

Ahora sí, vamos ³tirando rostro´. Para heredarForm1, me voy al menú Proyecto (también puedo

hacer clic derecho sobre el nombre de la solución, en este caso HerenciaVisual, y salen las mismas

opciones) y selecciono la opción Agregar Clase« como se ve en la siguiente figura:



Al hacer esto, aparece la siguiente ventana, donde vamos a seleccionar la opción Formulario

heredado:

Después de esto, te aparece una ventana como esta:



En dado caso que no te aparezca así, vuelve a generar el proyecto. Ahora selecciono la opción

Aceptar para decirle que herede la ventanaForm1 (en mi caso, la única que existe). En este

momento, mi explorador de soluciones me aparece Form2, como se ve aquí:

Y Form2 se ve así:

Fíjate que los controles de Form2 tienen un signo chiroliro en su esquina superior izquierda, como

dos cajitas con una flechita. Eso indica que el control está heredado.

Para terminar, fíjate que al seleccionar uno de los controles, te aparece un candado que indica que

no lo puedes eliminar. En Form2, seleccioné el primer botón, Button1, y el ³candadito´ se ve así:

Tampoco se puede agregar código a los controles. Si le das doble clic al control, no se abre la

ventana de código ni nada. Abrí el código desde el botoncito de código que está en la ventana de

soluciones. Si te fijas, no me aparecen los controles heredados:



En conclusión, puedes heredar controles pero no su código. Esto te ahorra mucha lata. Se puede

hacer una ventana ³base´ y heredar las partes comunes a muchas ventanas y en cada una agregarle

³el saborcito´ individual. Espero que esto les ahorre lata y trabajo extra. Si quieres agregar algo

acerca de tus propias experiencias con la heredada de ³guapuras´, de sus interfaces gráficos

chiroliros, deja un comentario. ¡Hasta la próxima!



¿Alguna vez has escuchado alguna frase relacionada a los "azares del destino"? No sé que tan cierto

es eso que el destino sucede al azar (algunos están en desacuerdo con esta idea, como lo está Amado

Nervo en su poema " Vida nada te debo"), pero los programadores no creen en que hay tanto azar en

las cosas porque, aunque es posible (y muy útil) hacer archivos que se puedan accesar de manera

aleatoria, se obtiene solamente lo que se ha grabado en ellas.

A lo mejor ya los hice bolas con los poemas (lo mencioné como simple cultura general) y los

programadores. La idea es que puedo crear archivos por medio de los archivos de programación

(aunque ahorita me interesan los que se pueden hacer en Microsoft Visual Basic .net) que pueden

ser accesados de manera aleatoria. Esto del acceso aleatorio es una manera rimbombante de decir

que podemos accesar cualquier parte del archivo que se nos pegue la gana en el momento en que se

nos pegue la gana. Como habrás notado si leíste algunos de mis posts anteriores, este tipo de

archivo difiere de los archivos secuenciales en que éstos últimos solamente pueden ser leídos desde

el principio hasta el final, o sea, no es permitido saltar a cualquier parte del archivo y agarrarnos

leyendo. No es que un tipo de archivo sea mejor que otro: cada uno tiene sus propios usos.

Como no todo es al azar, los programadores decidieron ponerle cierta estructura a las cosas para

que no todo fuera tan alocado. Gracias a estas estructuras, podemos usar un archivo de acceso

aleatorio como una tabla de una base de datos.

Para ilustrar como funciona esto, hice una pequeña aplicación que le podría servir a la biblioteca

personal de alguien. Esta es la imágen del programa en funcionamiento:

La aplicacion usa las cajas de texto para llenarlos de valores y guardar el registro o para mostrar los

datos de un libro leído. Todo esto funciona por medio de los botones, pero solo para farolear y

aumentar mi ego y autoestima, decidí también tener un menú contextual que sirva para hacer lo

mismo. Así es el diseño del menú:



Ahora, vámonos al código. Pero, como diría Jack el destripador, vámonos por partes. Para empezar,

esta es la estructura que voy a usar para guardar los datos de los libros y algunas variables globales

que me van a ser útiles. Todo esto va a dentro del PublicClass Form1.

No voy a redundar con una explicación acera de cómo se hacen las estructuras porque ya escribí

acerca de ellos aquí. De las variables, solo quiero aclarar lo que guardar. Librote es la instancia de la

clase Libro que voy a usar, NombreArch es una cadena que tiene el nombre del archivo (toda la ruta

completa) y NoReg guarda el número de registros que están almacenados en el archivo.

Todo esto se inicializa en el Form1_Load como se ve en esta figura. Lo primero que hace es asignarle

el nombre Biblioteca.tvr a la cadena NombreArch (fíjate que al usar

elDirectory.GetCurrentDirectory , estoy diciendo que ese archivo va a estar en la misma carpeta

donde se encuentra el archivo .EXE de esta aplicación). Luego consigo un número de archivo

disponible (con el FreeFile()) y lo abro. Se te fijas, el uso de FileOpen() cambia un poco en relación a

su uso con los archivos secuenciales. Como en el código no se ve toda la instrucción, más adelante

(después de este código). Luego cuento el número de registros y guardo en dato en NoReg. Para

hacer esto, comienzo a leer todos los registros usando la instrucción FileGet(), uno a uno, e ir

acumulando en NoReg cuantas veces he leído hasta llegar al final del archivo (uso EOF() para saber

si ya llegué al final). Y no hay que olvidar cerrar el archivo al final. Esto lo hago con FileClose().



En este mismo bloque de código, puse lo que tiene el Form1_MouseDown que se va a encargar de

mostrar el menú contextual chiroliro que puse.

Ahora sí: la instrucción FileOpen() completo :

FileOpen(NoArch,NombreArch,OpenMode.Random,OpenAccess.ReadWrite,OpenShare

.Default,Len(Librote))

Arriba expliqué lo que contiene NoArch y NombreArch.OpenMode.Random indica que vamos a

usar un archivo de acceso aleatorio, OpenAccess.ReadWrite indica que vamos a poder leer datos del

archivo y escribir datos a él. OpenShare.Defaultmaneja toda la movida que pasa cuando varias

personas quieren abrir el archivo al mismo tiempo. Se puede bloquear de escritura, lectura, etc. Con

el Default le estoy dejando la bronca a VBasic .NET y le digo que ahi le encargo la bronca, que lo

resuelva como mejor le parezca. Al final, uso la función Len() para que me devuelva el tamaño en

bytes de la estructura, o sea, el tipo de dato de la variable Librote (o sea, una instancia de la

estructura Libro). Esto es muy necesario para poder manejar las estructuras en el archivo. Si no le

digo cuanto mide cada registro, es imposible que lo pueda hallar a la primera cuando le digo "quiero

el registro 1355 y lo quiero rapidito". En el archivo, mide le número de bytes que se tiene que

"saltar" para leer ese registro, o sea, el tamaño de Librote * 1355. ¿Entendido? ¡Adelante pues con lo

que sigue!

Para cada acción que puede realizar el usuario tengo dos eventos donde lo puede hacer ya sea

puchurrando (nuevo verbo, jeje) el botón o usando el menú contextual farol. Por esta razón, hice

funciones que hicieran estas tareas vanas y rutinarias. Aquí está el ejemplo del código de los eventos

que pone en blanco a todas las cajas de texto de la ventana y luego los eventos que guardan la

información que está en la pantalla. Está tan fácil, que ni necesita explicadera.



El código que limpia la ventana (muy original, se llama LimpiaVentana) no tiene ninguna ciencia.

Limpia la ventana (o sea, quita cualquier resto de texto que haya quedado por allí... pensándolo

bien, nunca hay texto por allí... en fin, esa es la idea) e inicializa la estructura en ceros. Después hay una función Asigna Libro que copia los valores que hay en Librote a las cajas de texto de la ventana.

Ahora sí, algo más interesante. A continuación está la funciónG uarda Libro que se encarga de

meterlo en su lugar quesque-aleatorio en el archivo. Hace lo mismo que hace Form1_ Load al

principio: encuentra un número de archivo que se puede usar y abre el archivo. Después le asigna

a Librote los valores que hay en los Textboxes y al final le agrega uno al número total de registros

para poder poner allí, en esa posición del archivo (en este caso, al final) el contenido de Librote. Una

vez terminado, escribo el registro usando la función FilePut(), lo cierro y uso la función que limpia

la ventana.



Sería inútil en este mundo guardar cosas si no los voy a usar. Bueno, eso pasa en nuestras casas

cuando vamos acumulando tilichero, pero en las computadoras intentamos reducir el tilichero al

máximo. Depsués de divagar en tiliches, intento decir que es muy importante consultar los datos

que almacenamos porque si no los consultamos, mejor dedíquense a otra cosa y no se esfuercen en

hacer programas. Pero como queremos hacer algo útil, ahi va la manera de accesar los datos que

hemos guardado.

Hay 3 botones (y 3 elementos del menú farol) que hacen diferentes consultas. Dos de ellas son muy

similares, el que busca por el título y el que busca por el ISBN (nada que ver con el INSEN). Los dos

hacen prácticamente lo mismo: van desde el principio del archivo leyendo registros y

comparándolos con el título o ISBN dado en un InputBox chafa que puse allí (mi idea es la de

ejemplificar, no la de hecer una aplicación 100% terminada y fresón). El funcionamiento es también

muy similar a lo que expliqué en el Form1_Load(), así que escribo aquí el código de la

función BuscaISBN.

La otra manera de buscar sería la de accesar de forma directa el registro que quiero y leer los datos,

o sea, la función quesque aleatoria del archivo. Para hacer esto, hay de dos sopas: usar la

función FileGet() con el último parámetro que indica el número de registro que quier leer o usar la

función Seek() para moverse al lugar en el archivo donde está ese registro y luego usar

el FileGet() sin el parámetro del número del registro. Como es un mero ejemplo, lo hice de las dos

maneras en la función BuscaReg, quien es la función encargada de buscar un libro por número de

registro.

Impresiones Con Visual Basic 2010

Documents

Transcript of Impresiones Con Visual Basic 2010