1.
Introducción a los
controles
3. Creación de un
control
4. Manos a la
obra
5.
Creación de las propiedades del control textbox
especial
6. Creación de los
eventos
7. Creación de las propiedades y
funciones personalizadas
8. Finalización de un
Control
9.
Conclusión
10 .Introducción a las
Clases
11. Propiedades, Funciones y
Eventos
12. Diseño de clase en
Visual Basic
13. 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  |