1. Introducción a los controles3. Creación de un control4. Manos a la obra5. Creación de las propiedades del control textbox especial6. Creación de los eventos7. Creación de las propiedades y funciones personalizadas8. Finalización de un Control9. Conclusión10 .Introducción a las Clases 11. Propiedades, Funciones y Eventos12. Diseño de clase en Visual Basic13. Creación de la Clase "ASISTENTE"14. Conclusión final
1. Introducción a los controles
Este manual esta dirigido a programadores que posean los conocimientos básicos del Lenguaje de programación Visual Basic, se requiere conocimientos sobre, funciones, métodos, propiedades y todo lo que un manual o libro de Referencia pueda enseñar, aunque en realidad el diseño de controles y clases no es tan complicado este documento lo que trata o su finalidad es de explicar de la manera más fácil la creación de los mismo, con ejemplos que ustedes podrán emplear en sus propios proyectos.
Esta ventana la cual se encuentra en el lado izquierdo de la pantalla cuando se inicia Visual Basic, es donde se encuentran todos los controles, los predeterminados y los que usted añada para el desarrollo de su proyecto, los controles se pueden definir como una herramienta la cual presenta ciertas características y funciones las cuales ayudan a resolver un problema, por ejemplo, el TEXBOX nos ayuda a introducir información, la cual será mostrada en pantalla.
Ahora donde esta la ventaja de un control, bueno imagínese, que no hubiera un control TEXBOX y ustedes como programadores tuvieran que diseñar una forma de mostrarle la información al cliente de manera presentable, bueno desde una perspectiva, lo que haríamos seria PINTAR una parte de la pantalla de color blanco (o cualquier otro) y cuando mostremos el TEXTO ubicarlo en la posición donde fue pintada la pantalla, esto se asemejaría a una programación en DOS, pero como queremos darle presentación, imagínense que dibujamos líneas alrededor, para que pareciera un cuadro, pero como no convence o se sigue viendo como un programa de DOS, tratamos de hacerlo 3D, pintando dos líneas de GRIS y dos de NEGRO lo que simularía un efecto de sombra, y tendríamos que codificar muchas veces lo mismo, porque imagínense que necesitáramos alrededor de 20 TEXTBOX en un formulario, UHY no me gustaría ver ese código.
2. Propiedades, métodos, Funciones y Eventos.
Cuándo nace la programación orientada a objetos una de los principios más importantes era la reutilización de código, es decir, codificando una sola vez, podríamos usar ese control en cualquiera de nuestros proyectos sin volver a codificarlos, IMPRESIONANTE NO!!!, pero los controles tienen 4 características importantes que son: PROPIEDADES, METODOS, FUNCIONES y EVENTOS, las propiedades son como las partes que constituyen al objeto, (Como por ejemplo, una persona se podría decir que presenta propiedades como sus: ojos, oreja, labios, pies, color, etc), estas propiedades constituyen al control ya que ellas presentan valores, que le dan forma al mismo control, que quiero decir, si seguimos con el ejemplo de la persona las propiedades mencionadas tienen valores cuando nosotros nacemos (por ejemplo Ojos = Verdes, Orejas = Grandes, PIES = Planos, etc), como pueden ver estos valores no dan a nosotros nuestra forma, igual es con un control los valores de las propiedades son la que definen su forma.
Otra ventaja de la programación orientada a objetos es lo que se llama ENCAPSULACION, esto significa que podemos tener un control 50 veces en un formulario, y si le cambiamos una propiedad a un control solamente se cambia en él y no en los 49 controles restantes, es decir, cada control mantiene encapsulado sus propiedades, con este ejemplo se entenderá mejor:
Cuando nos referimos a una propiedad de un control tenemos que colocar su nombre y el nombre de la propiedad, ejemplo:
Nombre_de_Control.Propiedad = Valor
Si continuamos con el ejemplo de una persona sería algo parecido:
Maria.Ojos = Castaños
En un programa de Visual Basic seria de la siguiente manera:
Text1.text = "HOLA"
Donde Text1 es un control TEXTBOX, Text es una propiedad del control TEXTBOX, y "HOLA" es una cadena String que se le pasa a la propiedad (Text) de Text1 (CONTROL).
Perfecto, entonces un ejemplo de Encapsulación seria el siguiente supongamos que tenemos 2 TEXTBOX en un formulario Text1 y Text2 si hacemos lo siguiente:
Text1.text = "HOLA MUNDO"
Este texto nada mas es para el Text1, no se modifica la propiedad "Text" del Text2 (ESO ES ENCAPSULAMIENTO)
Ahora, ya entendido de lo que son las propiedades vamos a ver los métodos y Funciones, los métodos y las funciones son muy similares la diferencia radica en que los métodos (NO RETORNAN VALOR), y las funciones (SIEMPRE RETORNAN UN SOLO VALOR). Ejemplo en código de visual basic es:
Método:
Sub Nombre_del_Metodo (Parámetros_Requeridos)
.
.
.
.
.
.
(líneas de código)
End sub
Funciones:
Function Nombre_de_la_Funcion (Parámetros_Requeridos) as Valor_a_devolver
.
.
.
.
.
.
(líneas de código)
Nombre_de_la_funcion = Valor
End function
Como ya supongo que ustedes saben ya de esto, ahora vamos a explicar los Eventos, los eventos son aquellas reacciones de un control sobre algo que sucede a su alrededor, es decir, cuando se pulsa una tecla en un control se produce un evento que se llama Keypress, nosotros podemos ahí codificar como va reaccionar el control cuando se presione una determinada tecla, los eventos son muchos (MOUSEDOWN, MOUESUP, GETFOCUS, etc) dependiendo del tipo de control, cuando nosotros creamos un control podemos utilizar eventos ya creados o crear nuestros propios eventos.
3. Creación de un control
Ahora vamos a lo que en realidad queremos, CREAR UN CONTROL, antes de crearlo un control tiene un ciclo de vida el cual se compone de la siguiente manera:
Al nacer: Initialize, InitProperties, ReadProperties, Resize.
Al morir: WriteProperties, Terminate.
Ahora, que es todo eso que escribir arriba, bueno esos son eventos de un control cuando se esta diseñando (OJO: estos eventos nada mas se ven cuando se diseña el control, no cuando usamos el control en algunos de nuestros proyectos), lo que quiero decir que para que un control funcione adecuadamente hay que añadir unas líneas de código en estos eventos para el buen funcionamiento del mismo, no se preocupen que eso le vemos mas adelante.
Vamos a diseñar un TEXTBOX pero especial, ahora que tiene de especial, bueno lo especial es que este TEXTBOX_ESPECIAL, lo vamos a diseñar para que acepte los caracteres del teclado que nosotros queremos que acepte, es decir, si han usado un TEXTBOX normal verán que si quieren que el TEXBOX solamente acepte números tienen que codificar las restricciones en cada TEXTBOX, con este TEXTBOX_ESPECIAL las restricciones solamente las codificamos una sola vez para TODOS LOS PROGRAMAS que vayamos a diseñar.
Para empezar ejecutemos el programa Visual Basic y cuando le aparezca la ventana "NUEVO PROYECTO" igual a la figura n.2, seleccionen el icono "Control Activex", y le dan Doble Click.
Ahora vemos una pantalla gris parecida a un formulario, con la diferencia que no tiene ni marco, ni los botones de minimizar, maximizar, y cerrar, esto es por que un control no es un Formulario. Ahora, como vamos a diseñar un control TEXTBOX_ESPECIAL; en la ventana propiedades donde dice UserControl1 (Propiedad "NAME"), borre eso y coloque TEXTBOX_ESPECIAL, luego añadimos un TEXBOX común y silvestre en el fondo gris no importa donde, ni el tamaño, ya que eso lo arreglaremos a nivel de código, pueden notar que en la ventana controles aparece una figura desactivada como la que se muestra en la figura N.3:
Esta figura es nuestro control, pero como no hay ningún formulario para añadirlo no se activa. Ahora vamos a añadir un formulario a nuestro proyecto, denle click al segundo botón de la barra de herramienta de Visual Basic la cual al posicionar el mouse en él le indicara que es para añadir un nuevo formulario, cuando le aparezca la ventana de "Añadir un Formulario", seleccione el formulario Normal y le dan al botón Aceptar.
Repasemos, debemos de tener un proyecto con un control llamado TEXTBOX_ESPECIAL y un formulario llamado Form1.
Continuemos, ahora vamos a ver nuestro control en el formulario, para habilitar el control en la ventana de controles, dele doble-click al control TEXTBOX_ESPECIAL en la ventana Proyecto, verán el control con un textbox normal, ahora cierre la ventana dándole click al botón cerrar ("X") el cual se encuentra al lado derecho del menú, verán que se cierra el control y se ve el formulario y se habilita el control en la barra de controles, ahora sigua estos pasos:
- Dele doble click a nuestro control, al darle verán a nuestro control pero, de una manera un poco desordenado ya que el control tiene un marco mas grande que el TEXTBOX, anda intenta mover el control para que veas que feo se ve!!!!.
Ahora es aquí donde vamos a CODIFICAR NUESTRO CONTROL, denle doble-click al control TEXTBOX-ESPECIAL en la ventana "PROYECTO", cuando vean el control le dan doble-click en él para meternos en el código y ahora siga con estos pasos:
Private Sub UserControl_Resize()
Text1.Top = 0
Text1.Left = 0
Text1.Height = Height
Text1.Width = Width
End Sub
- Colóquese en el evento RESIZE de USERCONTROL, y escriba este código:
- En la ventana de propiedades de USERCONTROL coloque HEIGHT = 385 y WIDTH = 1590.
Con esto lo que estamos haciendo es adaptando al TEXTBOX de nuestro control al tamaño que el control presenta, ahora cierre otra vez la ventana de diseño del control, y cuando vea habilitado el control en la ventanas de controles, seleccione el formulario borre el control antiguo que inserto y vuélvale a dar doble-click a nuestro control notara que ahora tiene una presentación mas aceptable e intente de aumentar y disminuir su tamaño para que vea como el control TEXTBOX se adapta a nuestra exigencia. Y notara que si ve las propiedades de nuestro control no aparece ni el BACKCOLOR, FONT, PASSSORDCHAR, entre muchos otros, y que en los eventos no aparece ni KEYPRESS, MOUSEDOWN, etc, esto se debe a que todo eso hay que codificarlos nosotros mismos, pero no se preocupen eso es mas fácil de lo que ustedes se imaginan.
5. Creación de las propiedades del control textbox especial
Ahora vamos adaptar algunas de las propiedades mas importantes o la que mas utilizamos del TEXTBOX (OJO: no es obligatoria colocar todas), en nuestro control nada mas habilitaremos o mostraremos las propiedades: FONT, FORECOLOR, BACKCOLOR, TEXT, ALINEACIÓN, ENABLED, LOCKED, MAXLENGHT y PASSWORDCHAR, para hacer esto introduzca en la ventana de código del control lo siguiente:
Public Property Get Font() As Font
Set Font = text1.Font
End Property
Public Property Get ForeColor() As OLE_COLOR
ForeColor = text1.ForeColor
End Property
Public Property Get BackColor() As OLE_COLOR
BackColor = text1.BackColor
End Property
Public Property Get Text() As String
Text = text1.Text
End Property
Public Property Get Enabled() As Boolean
Enabled = text1.Enabled
End Property
Public Property Get Locked() As Boolean
Locked = text1.Locked
End Property
Public Property Get MaxLenght() As Integer
MaxLenght = text1.MaxLength
End Property
Public Property Get PasswordChar() As String
PasswordChar = text1.PasswordChar
End Property
Public Property Set Font(ByVal NuevoValor As Font)
Set text1.Font = NuevoValor
PropertyChanged "Font"
End Property
Public Property Let ForeColor(ByVal NuevoValor As OLE_COLOR)
text1.ForeColor() = NuevoValor
PropertyChanged "ForeColor"
End Property
Public Property Let BackColor(ByVal NuevoValor As OLE_COLOR)
text1.BackColor() = NuevoValor
PropertyChanged "BackColor"
End Property
Public Property Let Text(ByVal NuevoValor As String)
text1.Text = NuevoValor
PropertyChanged "Text"
End Property
Public Property Let Enabled(ByVal NuevoValor As Boolean)
text1.Enabled = NuevoValor
PropertyChanged "Enabled"
End Property
Public Property Let Locked(ByVal NuevoValor As Boolean)
text1.Locked = NuevoValor
PropertyChanged "Locked"
End Property
Public Property Let MaxLenght(ByVal NuevoValor As Integer)
text1.MaxLength = NuevoValor
PropertyChanged "MaxLenght"
End Property
Public Property Let PasswordChar(ByVal NuevoValor As String)
text1.PasswordChar = NuevoValor
PropertyChanged "PasswordChar"
End Property
NOTA: le recomendaría que guardaran el proyecto no vaya ser que se vaya la luz y perdamos todo el tiempo invertido (NO QUEREMOS ESO)
Se deben de estar preguntando ("QUE ES TODO ESTO"), bueno empecemos la explicación:
Cuando se crean propiedades, se deben de utilizar lo siguiente:
Property Let
Property Get
Property Let se ejecutara cada vez que nosotros cambiamos alguna de las propiedades del control en el formulario del proyecto ya sea a nivel de diseño o de código.
Property Get se ejecutara cada vez que solicitemos alguna información de nuestras propiedades por ejemplo que una variable quiera tomar una propiedad:
Nombre_Variable = TEXTBOX_ESPECIAL.Text
Por ejemplo voy a explicar una propiedad y la explicación es lo mismo para todas las propiedades:
Public Property Get Text() As String
Text = text1.Text
End Property
Public Property Let Text(ByVal NuevoValor As String)
text1.Text = NuevoValor
PropertyChanged "Text"
End Property
En Property Get lo que hacemos es que cuando solicitamos información del texto que esta introducido en el TEXTBOX_ESPECIAL hacemos Text que es nuestra propiedad igual a Text1.Text, siendo text1 el control que nosotros colocamos en nuestro control.
Por ejemplo:
Variable = TEXTBOX_ESPECIAL.text
Cuando hacemos esto, sin darnos cuenta nuestro control invoca Property get de la propiedad Text y tomamos el valor el cual seria Text = text1.Text , y ese valor se le asigna a la variable que lo invoco en este caso "Variable"
En Property Let lo que hacemos es que cuando le asignamos un nuevo valor a nuestra propiedad Text (OJO "NUESTRA PROPIEDAD"), ejemplo:
TEXTBOX_ESPECIAL.text = "HOLA"
Sin darnos cuenta se ejecuta el código que adentro se encuentre, en este caso le asignamos al Text1.text = NuevoValor siendo "nuevoValor" el texto que aparecerá en el control. El ByVal se debe a que el valor se pasa por copia y no por Referencia, léanse la ayuda sobre métodos y Funciones.
Cuando dije (OJO "NUESTRA PROPIEDAD") quise decir, que nosotros pudimos haber llamado esa propiedad como nosotros queramos, es decir, que en ves de llamarlo Text, lo pudiésemos haber llamado "TEXTO", "CADENA", "PEPE", "PEPITO", como nosotros queramos, lo que sucede que para no confundir a los usuarios que usen el control, respeto ya el estándar del Textbox existente. Recuerden no estamos creando desde cero un TEXTBOX, lo que estamos haciendo es un control que posee un control TEXTBOX común y silvestre, pero que se adaptara a nuestra exigencias (En este caso lo que mencione al principio, un Textbox_Especial que acepte los caracteres del teclado que nosotros queramos, ya que el Textbox normal no lo hace de manera automática)
Si ahora insertan nuestro control en el formulario con esta modificaciones van a notar en la ventana propiedades que ahora aparecen MAS PROPIEDADES QUE ANTES, y que se pueden modificar "MAGNIFICO NO!!!!" poco a poco aprendemos mas. Anda cambia la propiedad Text de nuestro control a nivel de diseño para que vea como cambia en el formulario.
Ahora vamos a aprender algo más, para empezar inserten un control TEXTBOX común y corriente (ES DECIR EL DE VISUAL BASIC) en el formulario donde estamos trabajando, y en la ventana propiedades denle Click a la propiedad "Alignment", verán que se habilita un botón con una flecha hacia abajo y si le dan click le mostrara una lista de las opciones posibles; a lo que quiero llegar es que ustedes se deben de estar preguntando "COMO SE HACE ESO?" , bueno es fácil primero en la sección de "Declaraciones", en la ventana de código (de nuestro control), insertaremos la declaración de la siguiente variable:
Enum Tipo_Alineacion
Izquierda = 0
Derecha = 1
Centro = 2
End Enum
Ahora vamos a crear la propiedad de la manera siguiente:
Public Property Get Alineacion() As Tipo_Alineacion
Alineacion = Text1.Alignment
End Property
Public Property Let Alineacion(ByVal NuevoValor As Tipo_Alineacion)
Text1.Alignment = NuevoValor
PropertyChanged "Alineacion"
End Property
Si ahora insertan nuestro control con las modificaciones hechas, en el formulario podrán notar que añadió una nueva propiedad que se llama "ALINEACION", y si le dan click verán el botón de al lado con la flecha hacia abajo, y si dan click al botón verán una lista con las opciones disponibles "INCREÍBLE NO!!!", siempre cuando ustedes desean mostrar una lista en alguna de las propiedades usen la declaración ENUM (VEASE EN LA AYUDA las variables de tipo ENUM).
Algo que se me ha olvidado explicar es el PropertyChanged, esto se tiene que escribir cuando una propiedad cambia su estado
Abran notado que todavía no hemos ejecutado el proyecto, es decir solamente hemos visto nuestro control a nivel de diseño y no a nivel de ejecución, bueno ahora vamos a ejecutarlo, pero primero cambien el color de nuestro control, al color que ustedes quieran, y en la alineación coloquen la opción de "CENTRO", muy bien para ejecutar el proyecto primero debemos de hacer los siguientes paso dele click a "PROYECTO" en el menú, luego a "Propiedades del Proyecto1", en el cuadro de "TIPO DE PROYECTO", seleccionen "Exe estándar" y en "OBJETO INICIAL", seleccionen Form1 y luego le dan aceptar.
Bueno, debemos de tener un control con un fondo que ustedes hayan elegido, con el texto Centrado, ahora ejecuten el proyecto……………………………….., podrán haber notado que tanto el fondo como la alineación no esta como nosotros la colocamos en el diseño, es decir, estamos viendo un fondo blanco, con la alineación a la izquierda, bueno esto en realidad fue intencional, por que todavía nos falta echar unas pocas líneas de código para que funcione.
Cierren el programa en ejecución, y metanse en el código de nuestro control y añadan las siguientes líneas:
Private Sub UserControl_WriteProperties(PropBag As PropertyBag)
On Error Resume Next
Call PropBag.WriteProperty("BackColor", Text1.BackColor, &H80000005)
Call PropBag.WriteProperty("Font", Font, Ambient.Font)
Call PropBag.WriteProperty("ForeColor", Text1.ForeColor, &H80000008)
Call PropBag.WriteProperty("Alineacion", Text1.Alignment, 0)
Call PropBag.WriteProperty("Enabled", Text1.Enabled, True)
Call PropBag.WriteProperty("Locked", Text1.Locked, False)
Call PropBag.WriteProperty("MaxLenght", Text1.MaxLength, "")
Call PropBag.WriteProperty("PasswordChar", Text1.PasswordChar, "")
Call PropBag.WriteProperty("Text", Text1.Text, "")
End Sub
Private Sub UserControl_ReadProperties(PropBag As PropertyBag)
On Error Resume Next
Set Font = PropBag.ReadProperty("Font", Ambient.Font)
Text1.ForeColor = PropBag.ReadProperty("ForeColor", &H80000008)
Text1.BackColor = PropBag.ReadProperty("BackColor", &H80000005)
Text1.Alignment = PropBag.ReadProperty("Alineacion", 0)
Text1.Enabled = PropBag.ReadProperty("Enabled", True)
Text1.Locked = PropBag.ReadProperty("Locked", False)
Text1.MaxLength = PropBag.ReadProperty("MaxLenght", "")
Text1.PasswordChar = PropBag.ReadProperty("PasswordChar", "")
Text1.Text = PropBag.ReadProperty("Text", "")
End Sub
En estos momentos si ustedes estaban confundidos, o le costaba entender el cómo se hace un control, deben de estar peor al ver este poco de líneas que seguro ni entienden por que la escribieron; bueno para empezar con estos dos métodos se deben de "MECANIZAR" que quiero decir con esto, todo control cualquiera fuera su tipo siempre va a tener estos dos Eventos, y se usan igual para todos los controles que ustedes diseñen.
WriteProperties: en este método o evento declaramos líneas como esta
Call PropBag.WriteProperty("BackColor", Text1.BackColor, &H80000005)
Donde:
- "BackColor" : es el nombre de la propiedad.
- "Text1.BackColor", es el nombre de la propiedad original.
- "&H80000005", es el valor inicial de esta propiedad o el valor por DEFECTO. (&H80000005 es equivalente en Hexadecimal al color blanco"
Siempre y esto que quede claro cuando ustedes crean una propiedad tienen que meterla en WritePropery, no se preocupen por entender "Call PropBag.WriteProperty", esto no importa lo que si es importa es que sepan que tienen que poner como primer valor el nombre de la propiedad, luego el nombre de la propiedad original, y por ultimo el valor por defecto.
ReadProperty: en este método o evento declaramos líneas como esta:
Text1.BackColor = PropBag.ReadProperty("BackColor", &H80000005)
Donde:
- "BackColor" es el nombre de la propiedad de nuestro control.
- Y &H80000005 es el valor por defecto Noten que estamos haciendo Text1.BackColor (nombre de la propiedad del Texbox que estamos usando en nuestro control) = PropBag.ReadProperty("BackColor", &H80000005)
Al igual que WriteProperty, no se preocupen de buscar el "POR QUE HACEMOS ESTO", lo que importa es que cuando añadan una nueva propiedad en Readproperty tienes que poner el nombre de la propiedad a utilizar (En este caso Text1.BackColor) igual a Propbag.ReadProperty(Nombre_de_la propiedad_nuestra, valor original o por defecto).
Esta parte reconozco que es un poco complicada de entender, por eso mencione que para estos dos métodos MECANÍCENSE, no lo busquen el por que, tan sencillamente háganlo de esa manera, si desean averiguar sobre estos Eventos (Vean en la ayuda de MSDN de Microsoft)
Ahora, vamos al formulario del proyecto, quiten el control viejo y vuelvan a insertar nuestro control con los nuevos cambios, verán que tanto físicamente como en las propiedades no ha cambiado, pero ahora, cámbienle el color y la alineación póngala centrada y ejecuten…………………………. habrán notado que ya el color y la alineación se mantienen ¡QUE BUENO!, pera que vean lo poderosas con son esas instrucciones.
Ya pasamos lo mas difícil que era la declaración de propiedades, ahora viene lo mas fácil, si ustedes se meten en el código del formulario e intentan ver los eventos del TEXTBOX_ESPECIAL, verán que no ven todos lo eventos, sino unos pocos; ahora nuestra misión es hacer que se vean los eventos que nosotros usamos en un TEXBOX.
Para eso inserten las siguientes líneas de código en la declaración de variables (DE NUESTRO CONTROL):
Public Event Changed()
Public Event MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single)
Public Event MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single)
Public Event MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single)
Public Event Keypress(KeyAscii As Integer)
Public Event KeyDown(KeyCode As Integer, Shift As Integer)
Public Event KeyUP(KeyCode As Integer, Shift As Integer)
Public Event Click()
Public Event DbClick()
NOTA: ustedes pueden añadir mas eventos, yo solamente añadí los mas usados.
Ahora, lo que acabamos de hacer es declarar los eventos, ¡pero como lo invocamos!, bueno lo que hacemos es que en cada evento del TEXBOX que tenemos un nuestro control, añadimos lo siguiente:
RaiseEvent Nombre_del_Evento
Por ejemplo en el Evento KeyPress de Text1 (Este TextBox es el que esta adentro de nuestro control) añadimos lo siguiente:
Private Sub Text1_KeyPress(KeyAscii As Integer)
RaiseEvent Keypress(KeyAscii)
End Sub
En keyup:
Private Sub Text1_KeyUp(KeyCode As Integer, Shift As Integer)
RaiseEvent KeyUP(KeyCode, Shift)
End Sub
En MouseMove:
Private Sub Text1_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single)
RaiseEvent MouseMove(Button, Shift, X, Y)
End Sub
Y así sucesivamente…… (Háganlo en todos los eventos que declare arriba)
Con esto nuestro control tiene algunos de los eventos del TEXTBOX original y su misma funcionalidad.
NOTA: todos los eventos que invocan con RaiseEvent deben de estar declarados previamente.
Vieron que era mas simple, ahora vayamos al formulario de nuestro proyecto, quitemos el control viejo e insertemos un nuevo control con las modificaciones hechas, ahora si se meten en el código del formulario y seleccionan a nuestro control, y verifican los eventos notaran que aparecen los eventos que ya venían por defecto y los que nosotros añadimos, cada vez hacemos un control mas REAL.
Bueno ya tenemos un control DECENTE, pero ustedes se estarán preguntando que carrizo estoy haciendo, este control es igualito al TEXTBOX normal, y peor por que tiene menos propiedades y eventos que el original, HAAAAA!!!! lo que sucede es que ahora es que vamos a codificar lo bueno.
7. Creación de las propiedades y funciones personalizadas
Muy bien, el objetivo de este control es que el usuario elija que quiere que el TEXTBOX_ESPECIAL acepte al escribir sobre él, (por ejemplo NUMEROS, LETRAS, FECHA, etc), bueno pera eso tenemos que declarar otra variable ENUM en la ventana de código del control en la parte de declaraciones y una variables:
Enum Tipo_Text
Texto = 0
Letras = 1
Numérico = 2
Fecha = 3
Monetario = 4
Mayúsculas = 5
Custom = 6
End Enum
Dim mTipo As Integer
Y añadimos otro propiedad la cual se va a llamar "TIPO":
Public Property Get Tipo() As Tipo_Text
Tipo = mTipo
End Property
Public Property Let Tipo(ByVal NuevoValor As Tipo_Text)
mTipo = NuevoValor
PropertyChanged "Tipo"
End Property
Ahora, por que uso una variable "mTipo", si en las otras propiedades uso Text1.propiedad = "valor", bueno por la simple razón que el TEXBOX original no tiene esta propiedad, aquí es donde esta el poder del diseño de controles, estamos utilizando un control que ya existe (TEXTBOX) pero adaptándolo a nuestras exigencias, uso una variable "mTipo", por que esta es una propiedad exclusiva de nuestro control, y no existe en el TEXTBOX original.
No se les olvide colocar en:
WriteProperty:
Call PropBag.WriteProperty("Tipo", mTipo, Tipo_Text.Texto)
Dense cuenta que como segundo parámetro esta mTipo, por lo que dije, esta es una propiedad exclusiva de nosotros y no del TextBox.
ReadProperty:
mTipo = PropBag.ReadProperty("Tipo", Tipo_Text.Texto)
Donde el valor por defecto, es Tipo_Text.Texto, (Por esta razón cuando ustedes insertan un control, en la propiedad "Tipo" van a haber que se encuentra ubicado en la opción 0.- Texto)
Muy bien, ahora vamos al formulario quitemos nuestro control viejo, y coloquemos el nuevo, vera que en las propiedades esta "Tipo", ahí le aparecerá una lista desplegadle, en la cual usted señalara que quieres que acepte el TEXTBOX_ESPECIAL, si quiere que sea numero, texto, etc. Seleccione Numero, y ejecute el proyecto, e intente escribir, notara que puede escribir cualquier cosa ¡PERO HOMBRE ESO ES OBVIO TODAVÍA NO HEMOS HECHO EL CODIGO DE LAS RESTRICCIONES!, sal del programa en ejecución, y metete en el código de nuestro control y añade las siguientes Funciones:
Public Function Numeros (Tecla As Integer) As Integer
Dim strValido As String
strValido = "0123456789"
If Tecla > 26 Then
If InStr(strValido, Chr(Tecla)) = 0 Then
Tecla = 0
End If
End If
Numeros = Tecla
End Function
Public Function VLetras(Tecla As Integer) As Integer
Dim strValido As String
strValido = "qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM,.*-}¿'!%&/()=?¡]¨*[Ñ;:_"
If Tecla > 26 Then
If InStr(strValido, Chr(Tecla)) = 0 Then
Tecla = 0
End If
End If
VLetras = Tecla
End Function
Public Function VFecha(Tecla As Integer) As Integer
Dim strValido As String
strValido = "0123456789/"
If Tecla > 26 Then
If InStr(strValido, Chr(Tecla)) = 0 Then
Tecla = 0
End If
End If
VFecha = Tecla
End Function
Public Function VDinero(Tecla As Integer) As Integer
Dim strValido As String
strValido = "0123456789,-"
If Tecla > 26 Then
If InStr(strValido, Chr(Tecla)) = 0 Then
Tecla = 0
End If
End If
VDinero = Tecla
End Function
Public Function VCadenas_Mayusculas(Tecla As Integer) As Integer
VCadenas_Mayusculas = Asc(UCase(Chr(Tecla)))
End Function
Public Function VPersonalizado(Tecla As Integer) As Integer
Dim strValido As String
strValido = mPersonalizado
If Tecla > 26 Then
If InStr(strValido, Chr(Tecla)) = 0 Then
Tecla = 0
End If
End If
VPersonalizado = Tecla
End Function
No voy a explicar cada una de las funciones tan sencillamente por que ustedes ya deben de poseer los conocimientos necesarios para entender este código, lo único que dijo es que las funciones reciben el Carácter en ASCII, y verifican si se encuentra en el parámetro que se acepta en este caso es la variable "strValido", la función retorna, el mismo código ASCII si es valido o retorna un 0 si no es valido..
Ahora, como o en que parte se llaman las funciones, bueno cuando nosotros apretamos una tecla en nuestro control, se ejecuta el Evento KeyPress (del TextBox que esta en nuestro control), lo que tenemos que hacer es invocar la validación desde el evento, es decir, copie este código en el evento keyPress (del Text1 de nuestro control) , el cual quedaría de esta manera:
Private Sub Text1_KeyPress(KeyAscii As Integer)
Select Case mTipo
Case 1
KeyAscii = VLetras(KeyAscii)
Case 2
KeyAscii = Numeros(KeyAscii)
Case 3
KeyAscii = VFecha(KeyAscii)
Case 4
KeyAscii = VDinero(KeyAscii)
Case 5
KeyAscii = VCadenas_Mayusculas(KeyAscii)
Case 6
KeyAscii = VPersonalizado(KeyAscii)
End Select
RaiseEvent Keypress(KeyAscii)
End Sub
Vamonos al formulario y quitemos nuestro control viejo y añadimos uno nuevo, en la propiedad "Tipo", coloca numérico, y ejecuta el programa veras que si te colocas en nuestro control e intentas escribir no podrás escribir ninguna letra, carácter especial y nada sino solamente números, AHHH ahora si se esta poniendo mejor la cosa, pero tenemos un defecto; salgan del programa en ejecución podrán ver que nosotros colocamos en tipo numero, pero si intentan cambiar el Text a nivel de diseño el le acepta cualquier tecla, es solamente a nivel de ejecución donde se valida la entrada, para solucionar esto hacemos lo siguiente:
- O le dejamos así, y quedara en ustedes programadores diseñar una forma de restringir la entrada a nivel de diseño
- O Hacer que esta propiedad funcione nada mas a nivel de ejecución y no de diseño.
Bueno, voy a explicar como hacer la opción 2, si quieren desarrollar la opción 1, quedara en su cuenta ya que tampoco voy a dar 10 paginas de puro código cuando lo que estamos explicando es como crear un control, mas no las mil y un funciones, que debería de tener un control.
Como lo opción 2 es una tontería, la voy a explicar ya que es importante saber como hacer que una propiedad trabaje nada mas a nivel de ejecución, para esto añadan el siguiente código en Property Let de la propiedad Text de nuestro control:
Public Property Let Text(ByVal NuevoValor As String)
If Ambient.UserMode = False Then
MsgBox "No se puede editar este control a nivel de diseño", vbInformation + vbOKOnly, "TextBox Especial"
Else
Text1.Text = NuevoValor
PropertyChanged "Text"
End If
End Property
Puede notar que añadimos un par de líneas la primera e importante Ambient.UserMode esta es la propiedad que determina si el control se esta ejecutando a nivel de código o Diseño, cuando inserten esto, AH, se me había olvidado, dele doble-click al control TEXBOX_ESPECIAL en la ventana de proyecto, cuando vean nuestro control asegúrense que la propiedad Text, del Textbox que nosotros insertamos este en blanco, es decir, que no muestre nada; continuamos, cuando hayan insertado el código nuevo, váyanse al formulario borren el viejo control, inserten uno nuevo e intenten cambiar la propiedad Text a nivel de diseño vera que cuando presione ENTER le aparecerá un Msgbox, indicándole que no puede editar este control a nivel de diseño.
Bueno esto tiene su pro y sus contra; por ejemplo si nosotros tenemos una variable:
Variable_T = "HOLA"
Y en cualquier parte del código hacemos:
TextBox_Especial1.text = Variable_T
Y tenemos a la propiedad "Tipo" como Numero, verán que acepta a la variable_T y mostrara "HOLA", pero bueno nada es perfecto, es decir, la validación nada mas se hará cuando escribamos en el TEXTBOX_ESPECIAL, no cuando le asignemos otra variable como el ejemplo anterior. Bueno pero ese es un ejercicio para ustedes, recuerden con los controles se puede hacer lo que quiera.
Ahora, si colocamos a tipo como numero (Sabemos que el TEXTBOX_ESPECIAL nada mas aceptara números), Texto (aceptara todo tipo de letra), Monetario (Aceptara números y una coma), si ponemos fecha (aceptara el / y los números) pero en la fecha si podemos cometer errores, por ejemplo podemos escribir 33/99/3000, esta no es una fecha valida si queremos evitar codificar en el programa las validaciones, vamos hacer la validación en el control.
Para realizar la validación vamos a insertar el código siguiente en el evento LostFocus del TEXTBOX (Text1) de nuestro control:
Private Sub text1_LostFocus()
If mTipo = 3 Then
If Not IsDate(text1.Text) Then
MsgBox "Esta Fecha no es Valida", vbInformation + vbOKOnly, "Text Box Especial"
text1.Text = vbNullString
text1.SetFocus
End If
End If
End Sub
Ahora, regresemos al formulario quiten el control viejo, inserta uno nuevo y en la propiedad "Tipo" selecciona fecha, ejecuta el programa, introduce una fecha incorrecta, y dale el Foco a otro control veras que te aparece un mensaje diciendo que la fecha no es valida. BUENO NO!!!!!!
No se preocupen, que ya falta poco para terminar la parte de controles, vamos a introducir una sola propiedad MAS!, vamos añadan en el código del control lo siguiente:
Dim mPersonalizado As String
Public Property Let Personalizado(ByVal NuevoValor As String)
mPersonalizado = NuevoValor
PropertyChanged "Personalizado"
End Property
Public Property Get Personalizado() As String
Personalizado = mPersonalizado
End Property
En ReadProperty:
mPersonalizado = PropBag.ReadProperty("Personalizado", "")
En WriteProperty:
Call PropBag.WriteProperty("Personalizado", mPersonalizado, "")
Esta propiedad lo que realiza es que cuando seleccionan en "Tipo", la opción de CUSTOM, y colocan la letra A en la propiedad de personalizado, solamente la letra A se podrá escribir en la ejecución del control……
| Página siguiente |