Documento creado por Francisco Noé Martinez Burgos. Este documento se distribuye gratuitamente con fines educacionales.
TRUCOS DE MICROSOFT VISUAL BASIC
FECHA
TÍTULO DEL TRUCO
28/6/99
Cómo ajustar un BitMap al fondo de la pantalla en Visual Basic
25/6/99
Cómo dibujar letras en tres dimensiones en Visual Basic
18/6/99
Cómo obtener el directorio desde donde estamos ejecutando nuestro
programa
11/6/99
Cómo colocar la hora y la fecha en la barra de título de una MDI Form
4/6/99
Cómo pasar de números romanos a árabes
28/5/99
Cómo pasar de números árabes a romanos
21/5/99
Cómo abrir la ventana de Propiedades de agregar o quitar programas
14/5/99
Cómo hacer desaparecer el cursor del ratón
7/5/99
Cómo redondear un número
30/4/99
Cómo pasar de un control a otro pulsando Intro
23/4/99
Cómo llevar el cursor al centro de un objeto
16/4/99
Cómo juntar los contenidos de dos archivos
9/4/99
Cómo pedir confirmación de descarga de un formulario
26/3/99
Cómo comprobar rápidamente si un Recorset es vacío
12/3/99
Comprobación rápida al salir de un formulario
5/3/99
Cómo cambiar la descripción de un complemento personalizado
26/2/99
Cómo escribir al visor de eventos de Windows NT
19/2/99
Cómo saber si un array está correctamente dimensionado
en Microsoft Visual Basic
12/2/99
Cómo abrir una base de datos con seguridad desde ADO
5/2/99
Cómo crear un salvapantallas con Visual Basic
29/1/99
Cómo detectar si una tarjeta de crédito es válida
22/1/99
Cómo dar formato para celdas numéricas en el control DBGRID
15/1/99
Cómo lanzar síncronamente comandos de MS-DOS
18/12/98
Cómo depurar el SETUP1.VBP del asistente para instalar aplicaciones
11/12/98
Cómo personalizar el asistente para instalar aplicaciones
4/12/98
Cómo detectar el estado de una impresora con Microsoft Visual Basic 6
Acceso a los trucos ya publicados de Microsoft Visual Basic
27/11/98
Cómo minimizar todas las ventanas
20/11/98
Cómo cerrar conexiones implícitas
13/11/98
Cómo ejecutar como procedimiento el contenido de un string
6/11/98
Cómo establecer los márgenes de la impresora
30/10/98
Cómo testear la línea de comandos
23/10/98
Ejecución de programas con Drag & Drop
16/10/98
Cómo desplazar el cursor hasta el final de una caja de texto
9/10/98
Cómo obtener la operación realizada sobre un formulario modal
2/10/98
Cómo añadir controles dinámicamente en formularios
25/09/98
Cómo desactivar los repintados de una ventana
18/09/98
Cómo registrar/de-registrar servidores EXE
24/07/98
Cómo desplazar bits de forma similar a los comandos << y >> de Visual C
17/07/98
Cómo obtener un puntero a una variable
10/07/98
Cómo registrar/desregistrar controles ActiveX rápidamente
3/07/98
Cómo evitar utilizar variables no declaradas
26/06/98
Cómo rellenar un ComboBox con los meses del año
19/06/98
Cómo evitar múltiples instancias de una misma aplicación
12/06/98
Cómo evitar que los complementos se ejecuten al lanzar VB
5/06/98
Cómo limpiar las cajas de texto y otros controles de un formulario
29/05/98
Cómo especificar la longitud máxima en un ComboBox
22/05/98
Cómo crear pequeños arrays utilizando el tipo Variant
15/05/98
Cómo mostrar un error de forma detallada al llamar a una API
08/05/98
Cómo comprobar la existencia de un fichero determinado
01/05/98
Cómo mostrar colores degradados en un formulario de VB
24/04/98
Cómo implementar la función "Deshacer" en una caja de texto.
17/04/98
Cómo obtener el nombre del equipo.
10/04/98
Cómo determinar que fuentes están instaladas en el sistema
3/04/98
Cómo obtener el nombre corto (MS-DOS) a partir del nombre largo de un
fichero
27/03/98
Cómo saber qué DLLs están cargadas en memoria y otra información útil del
sistema.
Acceso a los trucos ya publicados de Microsoft Visual Basic
20/03/98
Dónde encontrar los ficheros CABINET que son necesarios cuando se
distribuye una aplicación en Internet.
13/03/98
Cómo incluir dos campos en un control DBCOMBO
06/03/98
Cómo añadir bloques de comentarios en el código de forma sencilla en
Microsoft Visual Basic 5.0.
27/02/98
Cómo realizar una consulta por PASSTHROUGH en RDO.
20/02/98
Cómo depurar Microsoft Visual Basic Documents (VBDS).
13/02/98
Cómo simular el comportamiento de la barra de herramientas de Microsoft
Office 97.
06/02/98
Cómo especificar la posición de un formulario sin necesidad de programar en
VB 5.0.
30/01/98
Cómo desarrollar DLLs en C que puedan ser utilizadas por Visual Basic.
23/01/98
Cómo introducir valores en una celda de un control DBGRID.
16/01/98
Dónde encontrar una herramienta que permita crear bases de datos, editar el
diseño de bases de datos existentes, asistente de consultas, etc....
09/01/98
Solución a los parpadeos que se producen al descargar un formulario con un
control DBGRID.
19/12/97
Cómo implementar en Visual Basic un control similar al Microsoft Calendar
de Office.
12/12/97
Tratamiento de DBCOMBO y el registro actual.
05/12/97
Cómo utilizar en Visual Basic 5.0 controles que se incluían en la versión 4.0
y que Visual Basic 5.0 ya no instala.
28/11/97
Tratamiento de SSPANEL y la barra de progreso.
24/10/97
Cómo obtener una lista de los procesos en memoria en Microsoft Windows
95.
17/10/97
Cómo reproducir un CD de Audio.
10/10/97
Cómo saber si un ejecutable es de Windows o MS-DOS.
03/10/97
Visualización de videos AVI con MCI.
26/09/97
Cómo aumentar el rendimiento del control ListView.
19/09/97
Captura de errores del DBGrid en tiempo de ejecución.
12/09/97
Acceso a bases de datos seguras.
05/09/97
Cómo establecer márgenes cuando se imprime con el RichTextBox.
01/08/97
Cómo solucionar el error al establecer la propiedad MatchEntry del
DBCombo.
Acceso a los trucos ya publicados de Microsoft Visual Basic
25/07/97
Cómo usar CompactDatabase con un base de datos con contraseña.
18/07/97
Cómo cancelar un AddNew/Edit sin abandonar el registro actual.
11/07/97
Cómo enviar un fichero de Windows 95 a la papelera.
04/07/97
Cómo cambiar el tamaño de la caja de herramientas en Visual Basic.
27/06/97
Preguntando al usuario por un directorio en Windows 95.
20/06/97
Cómo crear accesos directos en Windows 95 desde Visual Basic.
25 DE JUNIO DE 1999 Cómo dibujar letras en tres dimensiones en Visual Basic
Cómo dibujar letras en tres dimensiones en Visual Basic
Aplicable a Microsoft Visual Basic 6
Para dibujar letras en tres dimensiones en Visual Basic lo único que hay que hacer crear un formulario
e introducir en él un Command Button con el siguiente código:
Private Sub Command1_Click()
Dim I As Integer, X As Integer, Y As Integer
ForeColor = &HFF0000: X = CurrentX: Y = CurrentY
CurrentX = X: CurrentY = Y: FontSize = 14
For I = 1 To 50
Print "Texto en tres dimensiones"
X = X + 1: Y = Y + 1: CurrentX = X: CurrentY = Y
Next I
ForeColor = &HFF00&
Print "Texto en tres dimensiones"
End Sub
Donde en vez de "Texto en tres dimensiones" pondremos el texto que queramos.
Truco originalmente publicado en http://www.somser.com/
18 DE JUNIO DE 1999 Cómo obtener el directorio desde donde estamos ejecutando nuestro programa en Visual Basic
Cómo obtener el directorio desde donde estamos ejecutando nuestro programa
Aplicable a Microsoft Visual Basic 6
Para obtener el directorio desde donde estamos ejecutando nuestro programa lo único que hay que
hacer es utilizar este código:
Private Sub Form_Load()
Dim Directorio as String
ChDir App.Path
ChDrive App.Path
Directorio = App.Path
If Len(Directorio) > 3 Then
Directorio = Directorio & "\"
End If
Text1.Text = Directorio
End Sub
En este ejemplo el directorio aparecerá en el cuadro de texto Text1.
Función creada por Eduardo Fórneas. Originalmente publicada en http://www.arrakis.es/~eforneas/breves.htm
11 DE JUNIO DE 1999 Cómo colocar la hora y la fecha en la barra de título de una MDI Form en Visual Basic
Cómo colocar la hora y la fecha en la barra de título de una MDI Form
Aplicable a Microsoft Visual Basic 6
Para colocar la hora y la fecha en la barra de título de una MDI Form siga estos pasos:
1. Coloque un objeto timer en el formulario MDI.
2. El valor de la propiedad Interval del objeto timer debe ser 1000.
3. Elimine el valor de la propiedad caption de la forma MDI.
4. En el procedimiento Timer del objeto escriba el siguiente código:
<NombreForm>.Caption = "<Nombre de la aplicación>" &
Format(Date, "dd-mm-yyyy") & " " & Format(Now, "h:nn:ss AM/PM")
Donde NombreForm el el nombre de su formulario MDI y Nombre de la aplicación es el nombre
que le quiere dar.
5. En el procedimiento Load del formualario escriba el siguiente código:
timer1.Enabled = true
Función originalmente publicada en http://www.compuconsult.com.ve/
4 DE JUNIO DE 1999 Cómo pasar de números romanos a árabes en Visual Basic
Cómo pasar de números romanos a árabes
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Para pasar de números romanos a árabes utilice la siguiente función, que coge el número en forma de
cadena y devuelve el número árabe.
Function ConvertirArabe(Romano As String) As Integer
Dim Numero As Integer, Valor1 As Integer
Dim Valor2 As Integer, Cadena As String
If Len(Romano) = 0 Then ConvertirArabe = 0: Exit Function
Cadena = Trim(Romano)
Numero = 0
Do
Valor1 = VerValor(left(Cadena, 1))
Cadena = Right$(Cadena, Len(Cadena) - 1)
Valor2 = VerValor(left(Cadena, 1))
If Valor1 >= Valor2 Then
Numero = Numero + Valor1
Else
Numero = Numero - Valor1
End If
Loop Until Len(Cadena) = 0
ConvertirArabe = Numero
End Function
Function VerValor(Simbolo
Select Case Simbolo
Case "I"
VerValor =
Case "V"
VerValor =
Case "X"
VerValor =
Case "L"
VerValor =
Case "C"
VerValor =
Case "D"
VerValor =
Case "M"
VerValor =
Case "Q"
VerValor =
Case "H"
VerValor =
End Select
End Function
As String) As Integer
1
5
10
50
100
500
1000
5000
10000
Función creada por Maverick. Originalmente publicada en http://www.programando.com/visualbasic/crazy/FAQ.htm
http://www.microsoft.com/spain/support/trucos/vbasic/vb040699.htm [01/03/2001 1:10:00]
28 DE MAYO DE 1999 Cómo pasar de números árabes a romanos en Visual Basic
Cómo pasar de números árabes a romanos
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Para pasar de números árabes a romanos utilice la siguiente función, que coge el número y devuelve una
cadena con el número en romano.
Function
Dim
Dim
Dim
Dim
Dim
ConvertirRomano(Numero As Integer) As String
Romano As String
I As Integer, Digito As Integer, x As Integer
Cadena As String, CadenaTmp As String
Simbolo1 As String * 1, Simbolo2 As String * 1
Simbolo3 As String * 1
Cadena = CStr(Numero)
For x = 1 To Len(Cadena)
If Len(Cadena) = 4 Then
Simbolo1 = "M"
Simbolo2 = "Q"
Simbolo3 = "H"
Digito = CInt(left$(Cadena, 1))
Cadena = Right$(Cadena, 3)
ElseIf Len(Cadena) = 3 Then
Simbolo1 = "C"
Simbolo2 = "D"
Simbolo3 = "M"
Digito = CInt(left$(Cadena, 1))
Cadena = Right$(Cadena, 2)
ElseIf Len(Cadena) = 2 Then
Simbolo1 = "X"
Simbolo2 = "L"
Simbolo3 = "C"
Digito = CInt(left$(Cadena, 1))
Cadena = Right$(Cadena, 1)
ElseIf Len(Cadena) = 1 Then
Simbolo1 = "I"
Simbolo2 = "V"
Simbolo3 = "X"
Digito = CInt(left$(Cadena, 1))
Cadena = ""
End If
If Digito <= 3 Then
For I = 1 To Digito
CadenaTmp = CadenaTmp & Simbolo1
Next I
ElseIf Digito < 5 Then
CadenaTmp = Simbolo1 & Simbolo2
ElseIf Digito = 5 Then
CadenaTmp = Simbolo2
ElseIf Digito <= 8 Then
CadenaTmp = Simbolo2
For I = 1 To Digito - 5
CadenaTmp = CadenaTmp & Simbolo1
Next I
ElseIf Digito = 9 Then
CadenaTmp = Simbolo1 & Simbolo3
End If
Romano = Romano & CadenaTmp
http://www.microsoft.com/spain/support/trucos/vbasic/vb280599.htm (1 de 2) [01/03/2001 1:10:09]
28 DE MAYO DE 1999 Cómo pasar de números árabes a romanos en Visual Basic
CadenaTmp = ""
Next x
ConvertirRomano = Romano
End Function
Función creada por Maverick. Originalmente publicada en http://www.programando.com/visualbasic/crazy/FAQ.htm
Última actualización: 28 de mayo de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb280599.htm (2 de 2) [01/03/2001 1:10:09]
21 DE MAYO DE 1999 Cómo abrir la ventana de Propiedades de agregar o quitar programas desde Visual Basic
Cómo abrir la ventana de Propiedades de agregar o quitar programas
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Para abrir la ventana de Propiedades de agregar o quitar programas desde Visual Basic añada el
siguiente código:
Private Sub Command1_Click()
X = Shell("Rundll32.exe shell32.dll,_
Control_RunDLL appwiz.cpl @0")
End Sub
Función creada por Eduardo Fórneas. Originalmente publicada en http://www.arrakis.es/~eforneas/breves.htm
Última actualización: 21 de mayo de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb210599.htm [01/03/2001 1:10:19]
14 DE MAYO DE 1999 Cómo hacer desaparecer el cursor del ratón en Visual Basic
Cómo hacer desaparecer el cursor del ratón
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Para hacer desaparecer y aparecer el cuesor del ratón pegue el siguiente código en el módulo:
Declare Function ShowCursor Lib "user32" (ByVal bShow_
As Long) As Long
Debe crear dos botones con:
Private Sub Command1_Click()
result = ShowCursor(False)
End Sub
y
Private Sub Command2_Click()
result = ShowCursor(True)
End Sub
Es muy importante que, en el caso del botón2 que hace reaparecer el cursor, permita seleccionarlo desde
el teclado poniendo su propiedad Caption a &Mostrar.
Función creada por Eduardo Fórneas. Originalmente publicada en http://www.arrakis.es/~eforneas/breves.htm
Última actualización: 14 de mayo de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb140599.htm [01/03/2001 1:10:29]
7 DE MAYO DE 1999 Cómo redondear un número en Visual Basic
Cómo redondear un número
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Utilice la siguiente rutina para redondear un número. Le devolverá el número redondeado en formato
Double con tantos decimales como indique en el parámetro 'intCntDec'.
Public Function Redondear (dblnToR As Double,_
Optional intCntDec As Integer) As Double
Dim dblPot As Double
Dim dblF As Double
If dblnToR < 0 Then dblF = -0.5 Else: dblF = 0.5
dblPot = 10 ^ intCntDec
Redondear = Fix(dblnToR * dblPot * (1 + 1E-16) + dblF) / dblPot
End Function
Truco originalmente publicado en http://www.somser.com/
Última actualización: 7 de mayo de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb070599.htm [01/03/2001 1:10:40]
30 DE ABRIL DE 1999 Cómo pasar de un control a otro pulsando Intro en Visual Basic
Cómo pasar de un control a otro pulsando Intro
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Para pasar de un control a otro pulsando Intro utilice la siguiente código en el evento KeyPress de cada
control. El orden que siguen será el marcado en la propiedad TabIndex.
If KeyAscii = 13 Then
SendKeys "{Tab}", True
End If
Función creada por Maverick. Originalmente publicada en http://www.programando.com/visualbasic/crazy/FAQ.htm
Última actualización: 30 de abril de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb300499.htm [01/03/2001 1:10:49]
23 DE ABRIL DE 1999 Cómo llevar el cursor al centro de un objeto en Visual Basic
Cómo llevar el cursor al centro de un objeto
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Utilice la siguiente subrutina para posicionar el puntero del ratón en el centro de un objeto:
Private Declare Function SetCursorPos& Lib "user32" (ByVal x As Long,_
ByVal y As Long)
Private Declare Function GetWindowRect& Lib "user32" (ByVal hwnd As Long,_
lRect As Rect)
Private Type Rect
left As Long
tpo As Long
right As Long
bottom As Long
End Type
Public Sub SetMouseFocus (ByVal Obj As Object)
Dim Rect As Rect
GetWindowRect Obj.hwnd, Rect
SetCursorPos Rect.right - ((Rect.left) / 2),_
Rect.bottom - ((Rect.bottom - Rect.top) / 2)
End Sub
Última actualización: 23 de abril de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb230499.htm [01/03/2001 1:11:00]
16 DE ABRIL DE 1999 Cómo juntar los contenidos de dos archivos en Visual Basic
Cómo juntar los contenidos de dos archivos
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
El comando copy de DOS permite coger los contenidos de dos ficheros y ponerlos secuencialmente en un
tercero. En Visula basic se puede hacer lo mismo utilizando con la siguiente rutina:
Public Function Sub Join Files (Source1 as String,_
Source2 as String, Dest as Sting)
Dim Buffer() as Byte
Open Source1 for Binary Access Read as #1
Open Source2 for Binary Access Read as #2
Open Dest for Binary Access Write as #3
ReDim Buffer(1 To LOF(1))
Get #1, ,Buffer
Get #3, ,Buffer
ReDim Buffer(1 To LOF(2))
Get #2, ,Buffer
Get #3, ,Buffer
Close #1, #2, #3
End Sub.
Última actualización: 16 de abril de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb160499.htm [01/03/2001 1:11:11]
9 DE ABRIL DE 1999 Cómo pedir confirmación de descarga de un formulario en Visual Basic
Cómo pedir confirmación de descarga de un formulario
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Quizás a veces desee dar a los usuarios la opción de confirmar que desean descargar un formulario. En
vez de utilizar una función MsgBox y un Select Case, puede incluir este código en el evento
Form_Unload.
Private Sub Form_Unload (Cancelar as Integer)
Cancelar = (MsgBox ("¿Salir?", vbOKCancel Or _
vbQuestion, "Demo Confirmacion") = vbCancel)
End Sub
Detrás del botón Salir y de la opción Salir del menú, ponga simplemente Unload Me. Cada vez que un
usuario quiera salir se les pedirá confirmación.
Última actualización: 9 de abril de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb090499.htm [01/03/2001 1:11:25]
26 DE MARZO DE 1999 Cómo comprobar rápidamente si un Recorset es vacío en Visual Basic
Cómo comprobar rápidamente si un Recorset es vacío
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Utilice esta rutina para comprobar rápidamente si un Recorset es vacío:
Public Function IsEmptyRecordset (rs As RecordSet) As Boolean
IsEmptyRecorSet=((rs.BOF=True) And (rs.Eof=True))
End Function
Última actualización: 26 de marzo de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb260399.htm [01/03/2001 1:11:35]
12 DE MARZO DE 1999 Comprobación rápida al salir de un formulario en Visual Basic
Comprobación rápida al salir de un formulario
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Al salir de un formulario es conveniente preguntar al usuario si desea salir del mismo, para ello
podemos usar el evento Unload del formulario. Ello implica el tener que usar un MsgBox y una
sentencia Case para comprobar el valor que ha devuelto el usuario. Es posible hacer todo esto en una
sola instrucción, para ello tenemos que comprobar el valor que devuelve MsgBox directamente con
vbCancel de esta forma:
Private Sub Form_Unload(Cancel as Integer)
Cancel = (MsgBox("¿Desea salir ahora?", vbOKCancel Or vbQuestion, "Confirmación rápida")
= vbCancel)
End Sub
Última actualización: 12 de marzo de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb120399.htm [01/03/2001 1:11:47]
5 DE MARZO DE 1999 Cómo cambiar la descripción de un complemento personalizado en Visual Basic
Cómo cambiar la descripción de un complemento personalizado
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Al usar la plantilla de proyecto de complemento "Addin" para crear complementos personalizados, la
descripción que aparece en el Administrador de complementos es siempre "Mi complemento". Aunque
puede parecer sencillo cambiar esta cadena, no lo es tanto. Al principio parece que la cadena
corresponde a la propiedad Description del proyecto, pero realmente corresponde a la propiedad
Description de la clase Connect. Para cambiar esta descripción debe cambiar la descripción de esta
clase, para ello haga doble clic en el Diseñador de complementos AddInDesigner y cambie la descripción
para su complemento.
Última actualización: 5 de marzo de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb050399.htm [01/03/2001 1:12:14]
26 de febrero de 1999 Cómo escribir al visor de eventos de Windows NT en Visual Basic
Cómo escribir al visor de eventos de Windows NT
Aplicable a Microsoft Visual Basic 5, Visual Basic 6
Las aplicaciones de Windows escriben al visor de eventos para proporcionar al usuario información
sobre un error ocurrido, un aviso, etc. En Visual Basic 5 ó 6, el objeto App proporciona métodos para
escribir al registro de eventos:
' Comienzo de registro de eventos
App.StartLogging "", vbLogToNT
' Registro de eventos en NT
App.LogEvent "Información", vbLogEventTypeInformation
App.LogEvent "Error", vbLogEventTypeError
App.LogEvent "Aviso", vbLogEventTypeWarning
Utilice estas funciones sólo en el EXE final ya que son ignoradas en tiempo de diseño.
Última actualización: 26 de febrero de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb260299.htm [01/03/2001 1:12:27]
19 de febrero de 1999 Cómo saber si un array está correctamente dimensionado
Cómo saber si un array está correctamente dimensionado
Aplicable a Microsoft Visual Basic 6
En ocasiones es necesario declarar un array vacío para posteriormente utilizar ReDim y asignarle el
espacio que nosotros indiquemos. En un momento dado, puede ser útil comprobar en el programa si el
array ha sido ya creado o no. La siguiente función devuelve True si el array dinámico no ha sido
dimensionado:
Public Function EstaArrayVacio(aArray as Variant) as Boolean
On Error Resume Next
EstaArrayVacio = UBound(aArray)
EstaArrayVacio = Err ' Error 9 (Subscript out of range)
End Function
Utilice el siguiente código para probar la función:
Private Sub Command1_Click()
Dim aDynamic() as Integer
MsgBox EstaArrayVacio(aDynamic)
ReDim aDynamic(8)
MsgBox EstaArrayVacio(aDynamic)
End Sub
Última actualización: 19 de febrero de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb190299.htm [01/03/2001 1:12:45]
12 de febrero de 1999 Cómo abrir una base de datos con seguridad desde ADO
Cómo abrir una base de datos con seguridad desde ADO
Aplicable a Microsoft Visual Basic 6
La seguridad utilizada convencionalmente por Microsoft Access es una seguridad a nivel de usuario,
controlada desde los ficheros .MDB y .MDA o .MDW (según versión de Microsoft Access).
Microsoft Access 7.0 y Microsoft Access 97 también incorporan otro tipo de seguridad, asociada a la
base de datos (se protege la base de datos con una contraseña que forma parte del fichero .MDB, y que
solamente es solicitada al abrir ésta).
El código aquí incluido permite abrir desde Visual Basic una base de datos cuando hay establecida
seguridad a nivel de usuario.
Previamente, desde el entorno de Microsoft Access se ha asignado al usuario Administrador (que es por
defecto el propietario de todas las bases de datos) una contraseña ("ejemplo"). Esto se hace en Access 97
en la opción de menú Herramientas, Seguridad, Cuentas de usuario y de grupo y, una vez ahí,
accediendo a la pestaña Cambiar contraseña de conexión. A partir de entonces, al abrir Access será
necesario proporcionar el usuario y la contraseña.
También a partir de entonces, para abrir un MDB desde VB será necesario pasarle el usuario y la
contraseña.
Este es el código VB que utiliza objetos de ADO 2.0 para abrir el MDB:
Dim Cn As New ADODB.Connection
Dim strCn As String
strCn = "Provider=Microsoft.Jet.OLEDB.3.51;" & _
"Data Source=nwind.MDB;" & _
"Jet OLEDB:System database=c:\winnt\system32\System.MDW"
Cn.Open ConnectionString:=strCn, _
UserID:="Admin", Password:="moises"
NOTA: Aunque se disponga de Microsoft Access en idioma castellano y el usuario se llame
Administrador, es necesario pasar "Admin" como UserID, y no "Administrador".
Última actualización: 12 de febrero de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb120299.htm [01/03/2001 1:13:09]
5 de febrero de 1999 Cómo crear un salvapantallas con Visual Basic
Cómo crear un salvapantallas con Visual Basic
Aplicable a Microsoft Visual Basic 6
La forma de crear un salvapantallas con Visual Basic es muy simple. Basta con crear un proyecto con
un formulario al que se le añadirán los controles que conformarán el interfaz del salvapantallas, junto al
código que se quiera incluir.
Al generar el fichero ejecutable se debe dar la extensión SCR, y el fichero debe guardarse en el
directorio por defecto de Windows.
Un ejemplo: crear un proyecto estándar en VB y asignar las siguientes propiedades al formulario por
defecto
WindowState = 2 'Maximized
BorderStyle = 0 'None
Incluir en el formulario una etiqueta con un texto descriptivo. Incluir a continuación el siguiente código:
Private Sub Form_Click()
'El salvapantallas se desactiva al hacer click sobre el formulario
Unload Me
End Sub
Private Sub Form_KeyDown(KeyCode As Integer, Shift As Integer)
'El salvapantallas se desactiva al pulsar una tecla
Unload Me
End Sub
Private Sub Form_Load()
'No se permita más de una instancia del salvapantallas
If App.PrevInstance Then Unload Me
End Sub
Generar el fichero ejecutable con la extensión SCR, y guardarlo en el directorio por defecto de
Windows.
Si a continuación indicamos éste como salvapantallas por defecto en las propiedades del escritorio de
Windows, cuando se venza el retardo de tiempo indicado, el formulario maximizado será visualizado
como salvapantallas. Para volver al escritorio bastará con pulsar una tecla o hacer clic con el ratón.
Última actualización: 5 de febrero de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb050299.htm [01/03/2001 1:13:47]
29 de enero de 1999 Cómo detectar si una tarjeta de crédito es válida
Cómo detectar si una tarjeta de crédito es válida
Aplicable a Microsoft Visual Basic 4, Visual Basic 5, Visual Basic 6
En una aplicación de comercio electrónico o una aplicación que necesite validar el número de una tarjeta
de crédito, se puede hace uso del algoritmo ISO 2894. Este algoritmo permite comprobar que la
numeración de la tarjeta es correcta, pero obviamente no indica si la tarjeta sigue siendo válida (no ha
sido anulada, ha caducado, etc.).
A continuación, se muestra el código Visual Basic para comprobar la validez en la numeración de una
tarjeta de crédito:
1. Cree un nuevo proyecto en Visual Basic y añada una caja de texto y un botón.
2. Pegue el siguiente código:
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' EsCCValido
'
' Valida la tarjeta de crédito de acuerdo con el algoritmo ISO 2894
' El algoritmo es:
' 1. Calcular el peso para el primer dígito: si el número de dígitos
'
es par el primer peso es 2 de lo contrario es 1. Después los
'
pesos alternan entre 1, 2, 1, 2, 1 ...
' 2. Multiplicar cada dígito por su peso
' 3. Si el resultado del 2º paso es mayor que 9, restar 9
' 4. Sumar todos los dígitos
' 5. Comprobar que el resultado es divisible por 10
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function EsCCValido(sTarjeta As String) As Boolean
Dim iPeso As Integer
Dim iDigito As Integer
Dim iSuma As Integer
Dim iContador As Integer
Dim sNuevaTarjeta As String
Dim cCaracter As String * 1
iPeso = 0
iDigito = 0
iSuma = 0
'Reemplazar cualquier no digito por una cadena vacía
For iContador = 1 To Len(sTarjeta)
cCaracter = Mid(sTarjeta, iContador, 1)
If IsNumeric(cCaracter) Then
sNuevaTarjeta = sNuevaTarjeta & cCaracter
End If
Next iContador
' Si es 0 devolver Falso
If sNuevaTarjeta = 0 Then
EsCCValido = False
Exit Function
End If
' Si el número de dígitos es par el primer peso es 2, de lo
' contrario es 1
If (Len(sNuevaTarjeta) Mod 2) = 0 Then
http://www.microsoft.com/spain/support/trucos/vbasic/vb290199.htm (1 de 2) [01/03/2001 1:14:01]
29 de enero de 1999 Cómo detectar si una tarjeta de crédito es válida
iPeso = 2
Else
iPeso = 1
End If
For iContador = 1 To Len(sNuevaTarjeta)
iDigito = Mid(sNuevaTarjeta, iContador, 1) * iPeso
If iDigito > 9 Then iDigito = iDigito - 9
iSuma = iSuma + iDigito
' Cambiar peso para el siguiente dígito
If iPeso = 2 Then
iPeso = 1
Else
iPeso = 2
End If
Next iContador
' Devolver verdadero si la suma es divisible por 10
If (iSuma Mod 10) = 0 Then
EsCCValido = True
Else
EsCCValido = False
End If
End Function
Private Sub btnComprobarCC_Click()
If EsCCValido(Text1) Then
MsgBox "Tarjeta válida"
Else
MsgBox "Tarjeta inválida"
End If
End Sub
3. Ejecute la aplicación. En la caja de texto introduzca el número de la tarjeta de crédito y pulse el
botón de comprobación. Puede probar con 4242 4242 4242 4242 que es un número válido.
Última actualización: 29 de enero de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb290199.htm (2 de 2) [01/03/2001 1:14:01]
22 de enero de 1999 Cómo dar formato para celdas numéricas en el control DBGRID
Cómo dar formato para celdas numéricas en el control DBGRID
Aplicable a Microsoft Visual Basic 4, Visual Basic 5, Visual Basic 6
A las columnas numéricas de un dbgrid se les puede aplicar un formato de visualización de los números.
Para establecer este formato a través de código debe utilizarse la propiedad NumberFormat, pero en
base al formato americano. Por ejemplo, imaginemos que la tercera columna en un dbgrid es una
columna numérica en la que aparecen cifras de ventas con valores decimales, y queremos visualizar el
punto para las unidades de millar y dos decimales tras la coma. Tenderemos a escribir el siguiente
código:
DBGrid1.Columns(2).NumberFormat = "#.###,##"
Pues bien, el resultado será que, una vez ejecutado este código, esa columna aparecerá en blanco. La
razón es que esta propiedad debe utilizarse en base al formato americano, o dicho de otro modo, el
punto decimal debe ser una coma (",") y la separación de decimales un punto ("."). De esta forma, si
utilizamos el siguiente código:
DBGrid1.Columns(2).NumberFormat = "#,###.##"
el resultado sí será el correcto, y veremos los valores numéricos en dicha columna, y además con el
formato deseado (por ejemplo, 10.235,27).
PRECAUCIÓN: CUALQUIER UTILIZACIÓN POR SU PARTE DEL CÓDIGO INCLUIDO EN
ESTE ARTÍCULO SE HARÁ A SU CUENTA Y RIESGO. Microsoft facilita este código "tal cual" sin
garantía de ningún tipo, ya sea explícita o implícita, incluyendo expresamente en tal exención de
responsabilidad y, a efectos meramente enunciativos y no limitativos, las garantías legales mercantiles
implícitas y/o la adecuación a un propósito o finalidad en particular.
Última actualización: 22 de enero de 1999
© 1999 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb220199.htm [01/03/2001 1:14:20]
15 de enero de 1999 Cómo lanzar síncronamente comandos de MS-DOS
Cómo lanzar síncronamente comandos de MS-DOS
Aplicable a Microsoft Visual Basic 4, Visual Basic 5, Visual Basic 6
A veces interesa lanzar comandos MS-DOS desde Visual Basic y esperar a que éstos acaben. Una
situación habitual es lanzar ficheros por lotes (.BAT), o comandos "net XXX", que realizan exploración
por distintos servidores en la red y que pueden tardar varios segundos en ser ejecutados.
A continuación se incluye un ejemplo de cómo lanzar un comando MS-DOS y esperar a que éste acabe.
Se utilizan dos funciones del API de Windows. La declaración de éstas se ha obtenido del Visor de Texto
API, un icono que aparece en el grupo de programas de Visual Basic.
Estas funciones son:
OpenProcess(): a partir del identificador de un proceso en ejecución esta función devuelve el
handle de dicho proceso.
GetExitCodeProcess(): recupera el código de salida de un proceso lanzado.
Por otra parte, en el código de ejemplo se incluye una referencia a
Environ$("Comspec") & " /c "
Esta instrucción fuerza a que se cierre la ventana MS-DOS de Windows 95 o Windows 98 después de
que el comando MS-DOS se haya ejecutado. En realidad la anterior instrucción se traduce en
"COMMAND.COM /C"
La utilización de la función Environ con el parámetro Comspec asegura que el command.com se
encontrará aunque no esté en el path.
El ejemplo necesita un proyecto con un Textbox y un Command button, con las propiedades por
defecto. Al ejecutar el proyecto, teclear el comando MS-DOS en el Textbox y pulsar Command1.
Pasados unos segundos (depende del comando a ejecutar), aparecerá el mensaje "El comando ha
acabado".
El código del formulario es el siguiente:
Option Explicit
Private Const PROCESS_QUERY_INFORMATION = &H400
Private Const STILL_ACTIVE = &H103
Private Declare Function OpenProcess Lib "kernel32" _
(ByVal dwDesiredAccess&, ByVal bInheritHandle&, ByVal dwProcessId&) _
As Long
Private Declare Function GetExitCodeProcess Lib "kernel32" _
(ByVal hProcess As Long, lpExitCode As Long) _
As Long
Sub EsperarShell(sCmd As String)
Dim hShell As Long
Dim hProc As Long
Dim codExit As Long
' ejecutar comando
hShell = Shell(Environ$("Comspec") & " /c " & sCmd, 2)
' esperar a que se complete el proceso
hProc = OpenProcess(PROCESS_QUERY_INFORMATION, False, hShell)
Do
http://www.microsoft.com/spain/support/trucos/vbasic/vb150199.htm (1 de 2) [01/03/2001 1:14:33]
15 de enero de 1999 Cómo lanzar síncronamente comandos de MS-DOS
GetExitCodeProcess hProc, codExit
DoEvents
Loop While codExit = STILL_ACTIVE
MsgBox "El comando ha acabado"
End Sub
Private Sub Command1_Click()
EsperarShell (Text1.Text)
End Sub
Última actualización: 15 de enero de 1999
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb150199.htm (2 de 2) [01/03/2001 1:14:33]
18 de diciembre de 1998 Cómo depurar el SETUP1.VBP del asistente para instalar aplicaciones
Cómo depurar el SETUP1.VBP del asistente para instalar aplicaciones
Aplicable a Microsoft Visual Basic 4, Visual Basic 5, Visual Basic 6
Usted puede personalizar el asistente para la instalación de aplicaciones modificando el proyecto
Setup1.vbp. Sin embargo, este proyecto no puede ser depurado en el entorno de desarrollo (IDE) a
menos que se emule el comportamiento de la rutina de instalación.
Para depurar el proyecto Setup1.vbp en el IDE siga los siguientes pasos:
1. Ejecute el asistente para instalar aplicaciones (también conocido como asistente para
empaquetado y distribución) y cree unos discos de instalación en un directorio.
2. Edite el fichero Setup.lst en un editor de texto y haga las siguientes modificaciones:
Visual Basic 4.0 16-bit
Localice:
Setup=setup1.exe
y reemplázelo con:
Setup=c:\vb\vb.exe c:\vb\setupkit\setup1\setup1.vbp /cmd
Visual Basic 4.0 32-bit
Localice:
Setup=setup132.exe
y reemplázelo con:
Setup=c:\vb\vb32.exe c:\vb\setupkit\setup1\setup1.vbp /cmd
Visual Basic 5.0
Localice:
Setup=setup1.exe
y reemplázelo con:
Setup="c:\archivos de programa\devstudio\vb\vb5.exe"
"c:\archivos de programa\devstudio\vb\setupkit\setup1\setup1.vbp" /cmd
Visual Basic 6.0
Localice:
Spawn=setup1.exe
y reemplázelo con:
Spawn="C:\Archivos de Programa\Microsoft Visual Studio\VB98\VB6.exe"
"C:\Archivos de Programa\Microsoft Visual Studio\VB98\Wizards\
PDWizard\Setup1\Setup1.vbp" /cmd
3. Comience la instalación ejecutando Setup.exe.
Cuando Setup.exe termina, se ejecuta el IDE de Visual Basic cargando el proyecto Setup1.vbp.
Establezca los puntos de ruptura que considere oportunos para hacer la depuración y pulse F5 o F8.
Última actualización: 18 de diciembre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb181298.htm [01/03/2001 1:14:48]
11 de Diciembre de 1998 Cómo personalizar el asistente para instalar aplicaciones
Cómo personalizar el asistente para instalar aplicaciones
Aplicable a Microsoft Visual Basic 4, Visual Basic 5, Visual Basic 6
El último paso en el desarrollo de una aplicación es la elaboración de los discos de distribución. Visual
Basic 4.0 y 5.0 incorporan una utilidad llamada "Asistente para instalar aplicaciones", conocida en
Visual Basic 6.0 como "Asistente para empaquetado y distribución", que permite la creación de los
discos de distribución. Sin embargo, en muchas ocasiones es necesario personalizar el proceso de
instalación para, por ejemplo, incluir el logotipo de la compañía en la ventana del instalador.
Visual Basic se suministra con los fuentes de la aplicación que realiza el proceso de instalación. El
proyecto de Visual Basic se llama SETUP1.VBP y se encuentra en el siguiente directorio (suponiendo
que Visual Basic se ha instalado en el directorio por defecto):
En Visual Basic 4
C:\Archivos de Programa\Visual Basic 4.0\Setupkit\Setup1\
En Visual Basic 5
C:\Archivos de Programa\DevStudio\VB\Setupkit\Setup1\
En Visual Basic 6
C:\Archivos de Programa\Microsoft Visual Studio\VB98\Wizards\PDWizard\Setup1\
Edite el proyecto, haga las modificaciones que considere oportunas y, a continuación, cree el
SETUP1.EXE en el directorio por defecto seleccionado por Visual Basic.
Última actualización: 11 de diciembre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb111298.htm [01/03/2001 1:15:30]
4 de Diciembre de 1998 Cómo detectar el estado de un impresora
Cómo detectar el estado de un impresora local
Aplicable a Microsoft Visual Basic 6
Las funciones de la API de Windows para comprobar el estado de una impresora requieren que haya un
documento en el spooler. Esta restricción obliga, en la mayoría de los casos, a mandar un trabajo de
impresión para detectar el estado de la impresora. Para evitar este incoveniente se puede abrir el puerto
de la impresora (normalmente lpt1) con CreateFile y tratarlo como un puerto de comunicaciones
normal. La API ClearCommError permite detectar errores en el puerto.
El siguiente ejemplo muestra cómo examinar el estado de una impresora (este método sólo funciona
para impresoras locales) :
1. Cree un nuevo proyecto.
2. Añada un módulo de proyecto.
3. Copie el siguiente código en el módulo de proyecto:
Public Const GENERIC_WRITE = &H40000000
Public Const GENERIC_READ = &H80000000
Public Const FILE_ATTRIBUTE_NORMAL = &H80
Public Const CREATE_ALWAYS = 2
Public Const OPEN_ALWAYS = 4
Public Const INVALID_HANDLE_VALUE = -1
Public Type COMSTAT
Filler1 As Long
Filler2 As Long
Filler3 As Long
Filler4 As Long
Filler5 As Long
Filler6 As Long
Filler7 As Long
Filler8 As Long
Filler9 As Long
Filler10 As Long
End Type
Declare Function CreateFile Lib "kernel32" _
Alias "CreateFileA" (ByVal lpFileName As String, _
ByVal dwDesiredAccess As Long, ByVal dwShareMode As Long, _
ByVal lpSecurityAttributes As Long, _
ByVal dwCreationDisposition As Long, _
ByVal dwFlagsAndAttributes As Long, ByVal hTemplateFile As Long) _
As Long
Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long
Declare Function ClearCommError Lib "kernel32" (ByVal hFile As Long, lpErrors As
Long, _
lpStat As COMSTAT) As Long
Public Const CE_BREAK = &H10 ' break condition
Public Const CE_PTO = &H200 ' printer timeout
Public Const CE_IOE = &H400 ' printer I/O error
Public Const CE_DNS = &H800 ' device not selected
Public Const CE_OOP = &H1000 ' out of paper
4. Coloque un botón en el formulario y copie el siguiente código:
http://www.microsoft.com/spain/support/trucos/vbasic/vb041298.htm (1 de 2) [01/03/2001 1:15:47]
4 de Diciembre de 1998 Cómo detectar el estado de un impresora
Private Sub Command1_Click()
Dim mHandle As Long
Dim lpErrors As Long
Dim x As COMSTAT
mHandle = CreateFile("lpt1", GENERIC_WRITE Or GENERIC_READ, _
0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)
If mHandle < 0 Then
MsgBox "error de apertura del puerto " & mHandle
Else
If ClearCommError(mHandle, lpErrors, x) = False Then
MsgBox "Error en ClearCommError"
End If
End If
If lpErrors And CE_BREAK Then
MsgBox "Error genérico"
End If
If lpErrors And CE_PTO Then
MsgBox "Timeout de impresora"
End If
If lpErrors And CE_IOE Then
MsgBox "Error de entrada/salida"
End If
If lpErrors And CE_DNS Then
MsgBox "Dispositivo no seleccionado"
End If
If lpErrors And CE_OOP Then
MsgBox "Sin papel"
End If
CloseHandle mHandle
End Sub
5. Ejecute la aplicación y pulse el botón para comprobar el estado de la impresora.
Última actualización: 4 de diciembre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb041298.htm (2 de 2) [01/03/2001 1:15:47]
27 de Noviembre de 1998 Cómo minimizar todas las ventanas
Cómo minimizar todas las ventanas
Aplicable a partir de Microsoft Visual Basic 4.0 32 Bits
En Visual Basic es fácil minimizar todas las ventanas visibles mediante programación
usando el API keybd_event.
El truco consiste en imitar los eventos de teclado requeridos para abrir el menú de la
barra de tareas y enviar la letra "M" para seleccionar la opción "Minimizar todas las
ventanas".
Con tres llamadas al API keybd_event podremos conseguirlo.
El segundo argumento de la llamada a keybd_event es el código de tecla (hardware scan
code), y en este caso podríamos usar el valor 91, sin embargo dado que las aplicaciones
podrían no usar este código, se ha dejado a cero.
Ejemplo paso a paso
------------------1. Inicie un nuevo proyecto EXE. Form1 se crea por defecto.
2. Añada un botón de comando en Form1.
3. Copie y pegue el siguiente código en la ventana de código de Form1.
Private Declare Sub keybd_event Lib "user32" ( ByVal bVk As Byte,_
ByVal bScan As Byte, _
ByVal dwFlags As Long, _
ByVal dwExtraInfo As Long)
Const KEYEVENTF_KEYUP = &H2
Const VK_LWIN = &H5B
Private
' 77
Call
Call
Call
End Sub
Sub Command1_Click()
is the character code for the letter 'M'
keybd_event(VK_LWIN, 0, 0, 0)
keybd_event(77, 0, 0, 0)
keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0)
4. Pulse la tecla F5 para ejecutar la aplicación y haga clic en el botón de comandos,
se minimizarán todas las ventanas visibles.
Última actualización: 27 de Noviembre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb271198.htm [01/03/2001 1:16:17]
20 de Noviembre de 1998 Cómo cerrar conexiones implícitas
Cómo cerrar conexiones implícitas
Aplicable a partir de Microsoft Visual Basic 6.0
En Visual Basic 6.0 es posible abrir objetos recordsets independientes sin asociarlos a ninguna conexión.
Esto es posible gracias al carácter no jerárquico del modelo de programación de ADO. No obstante,
cada vez que se abre un recordset de este tipo, se crea una conexión implícita. Esto supone que si el
objeto recordset se cierra y se abre varias veces en el código del proyecto, se crearán tantas nuevas
conexiones como veces se haya abierto el objeto recordset. Estas conexiones permanecerán abiertas
hasta cerrar el proyecto.
Para impedir esto, y conseguir cerrar la conexión implícita a cada recordset independiente, se puede
utilizar la siguiente técnica, que asocia a una variable Connection la conexión implícita a un recordset
independiente, cerrando dicha conexión antes de reabrir el recordset.
Dim rst1 As New ADODB.Recordset
Dim cnn As New ADODB.Connection
Private Sub Command1_Click()
rst1.Open "authors", "Provider = sqloledb;Data Source=myServer;" & _
"Initial Catalog=pubs;User Id=sa;Password=;", adOpenStatic, _
adLockReadOnly
End Sub
Private Sub Command2_Click()
Set cnn = rst1.ActiveConnection
rst1.Close
cnn.Close
rst1.Open "publishers","Provider = sqloledb;Data Source=myServer;" & _
"Initial Catalog=pubs;User Id=sa;Password=;", adOpenStatic, _
adLockOptimistic
End Sub
Última actualización: 20 de Noviembre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb201198.htm [01/03/2001 1:16:38]
13 de Noviembre de 1998 Cómo ejecutar como procedimiento el contenido de un string
Cómo ejecutar como procedimiento el contenido de un string
Aplicable a partir de Microsoft Visual Basic 4.0
En Visual Basic se está avanzando en la posibilidad de ejecutar el código apuntado por un puntero a
función, tal y como se permite en Visual C++.
Ya en Visual Basic 5.0 se incorporaba la función AddressOf, que permitía obtener la dirección de una
función. Pasando esa dirección a un programa C++, éste podía ejecutar la función.
En Visual Basic 6.0 se avanza un paso más y se crea la función CallByName, que permite ejecutar una
función si se conoce su nombre en tiempo de ejecución. Basta con pasar a CallByName una cadena
(string) como argumento, conteniendo el nombre de la función a ejecutar. Los argumentos que recibe
CallByName son: el objeto contenedor de la función (por ejemplo, un Formulario), la cadena que
contiene el nombre de la función, el tipo de función y los argumentos de ésta.
El siguiente ejemplo crea dos funciones (Divide y Multiplica). Si en Text2 y Text3 colocamos los
argumentos, al pulsar el botón se ejecuta la operación que hallamos escrito en Text1 (Multiplica o
Divide).
Public Function Divide(arg1 As Long, arg2 As Long)
Divide = arg1 / arg2
End Function
Public Function Multiplica(arg1 As Long, arg2 As Long)
Multiplica = arg1 * arg2
End Function
Private Sub Command1_Click()
MsgBox CallByName(Me, Text1.Text, VbMethod, Text2.Text, Text3.Text)
End Sub
Última actualización: 13 de Noviembre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb131198.htm [01/03/2001 1:16:58]
6 de Noviembre de 1998 Cómo establecer los márgenes de la impresora
Cómo establecer los márgenes de la impresora
Aplicable a partir de Microsoft Visual Basic 4.0
Para indicar los márgenes de un trabajo de impresión hay que utilizar las propiedades de escala de la
impresora.
El siguiente ejemplo establece el margen izquierdo a 0'6 pulgadas y el margen superior a 0'7 pulgadas.
El factor 1440 convierte las pulgadas a twips:
Printer.ScaleLeft = -0.6 * 1440
Printer.ScaleTop = -0.7 * 1440
Printer.CurrentX = 0
Printer.CurrentY = 0
Última actualización: 6 de Noviembre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb061198.htm [01/03/2001 1:17:25]
30 de Octubre de 1998 Cómo testear la línea de comandos
Cómo testear la línea de comandos
Aplicable a partir de Microsoft Visual Basic 4.0
Durante el desarrollo de una aplicación en el entorno integrado de Visual Basic, a veces es necesario
probar los parámetros que se le pasan en la línea de comandos. En Visual Basic, se puede indicar la
línea de comandos en tiempo de depuración de la siguiente forma:
En Visual Basic 4:
1. Seleccione el menú Herramientas.
2. Elija Opciones.
3. Muestre la pestaña Avanzado.
4. Introduzca los parámetros en "Argumentos de la línea de comandos".
En Visual Basic 5 y 6:
1. Seleccione el menú Proyecto.
2. Elija la opción Propiedades.
3. Muestre la pestaña Generar.
4. Introduzca los parámetros en "Argumentos de la línea de comandos".
Última actualización: 30 de Octubre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb301098.htm [01/03/2001 1:17:37]
23 de Octubre de 1998 Ejecución de programas con Drag & Drop
Ejecución de programas con Drag & Drop
Aplicable a partir de Microsoft Visual Basic 4.0
Si un usuario arrastra y suelta (drag & drop) uno o más ficheros sobre el nombre de nuestro programa
en el Explorer o en el icono de la aplicación, Windows ejecuta el programa pasándole como parámetro
el nombre de los ficheros sobre los que se hizo drag & drop. Para encontrar el nombre de estos ficheros
utilice la instrucción Command y así obtener la línea de comandos.
Última actualización: 23 de Octubre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb231098.htm [01/03/2001 1:17:52]
16 de Octubre de 1998 Cómo desplazar el cursor hasta el final de una caja de texto
Cómo desplazar el cursor hasta el final de una caja de texto
Aplicable a partir de Microsoft Visual Basic 4.0
En ocasiones es necesario que cuando el usuario sitúa el foco en una caja de texto, la introducción de
datos comience al final del texto previamente introducido.
Para desplazar el cursor al final del texto, teclee el siguiente texto en el evento GetFocus de la caja de
texto:
Private Sub Text1_GotFocus()
Text1.SelStart = Len(Text1.Text)
End Sub
Última actualización: 16 de Octubre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb161098.htm [01/03/2001 1:18:03]
9 de Octubre de 1998 Cómo obtener la operación realizada sobre un formulario modal
Cómo obtener la operación realizada sobre un formulario modal
Aplicable a partir de Microsoft Visual Basic 4.0
A veces es necesario mostrar un formulario modal donde el usuario introduzca una serie de datos y
después pulse Aceptar o Cancelar. En función de la operación realizada (Aceptar o Cancelar) se puede
mostrar un segundo formulario con más información o con los resultados de la operación.
Desafortunadamente, no es posible lanzar otro diálogo desde el formulario modal ya que éste último
debe permanecer en primer plano. Para evitar este problema, se puede utilizar una variable booleana en
el formulario modal que indique la operación realizada por el usuario. Al descargar el formulario, sus
variables no desaparecen sino que siguen memoria, por lo que se pueden consultar desde un segundo
formulario y actuar en consecuencia.
A continuación se muestra un ejemplo:
1. Añada formularios al proyecto (Form1 y Form2)
2. Sitúe un botón (Command1) en Form1
3. Sitúe dos botones (Command1 y Command2)en Form2
4. Escriba el siguiente código en Form1:
Private Command1_Click()
Form2.Show vbModal
If Form2.Operacion Then
MsgBox "Operación A"
Else
MsgBox "Operación B"
End If
Set Form2 = Nothing
End Sub
5. Escriba el siguiente código en Form2:
Public Operacion as Boolean
Private Command1_Click()
Operacion = True
Unload Me
End Sub
Private Command2_Click()
Operacion = False
Unload Me
End Sub
Ejecute el proyecto y pruebe a pulsar el botón del formulario uno y después a pulsar cualquier botón del
formulario dos.
Última actualización: 9 de Octubre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb091098.htm [01/03/2001 1:18:17]
2 de Octubre de 1998 Cómo añadir controles dinámicamente en formularios
Cómo añadir controles dinámicamente en formularios
Aplicable a partir de Microsoft Visual Basic 6.0
Hasta Visual Basic 5.0 si se quería añadir un control a un formulario se utilizaba la función Load, que
permitía añadir un control a un array ya existente. Esta limitación se ha eliminado de Visual Basic 6.0, y
ya es posible añadir y borrar controles a la colección "Controls", sin necesidad de que exista un array ya
creado. Además, el nuevo control puede responder a eventos si se define con la palabra "WithEvents".
Como muestra, un sencillo ejemplo que crea un botón y se añade código al evento:
Dim WithEvents cmdObj1 As CommandButton
Private Sub cmdObj1_Click()
MsgBox "Esto es un control dinámico"
End Sub
Private Sub Form_Load()
Set cmdObj1 = Form1.Controls.Add("VB.CommandButton", "cmdBoton1")
cmdObj1.Caption = "Púlsame"
cmdObj1.Left = 1500
cmdObj1.Top = 1000
cmdObj1.Visible = True
End Sub
Private Sub Form_Unload(Cancel As Integer)
Form1.Controls.Remove "cmdBoton1"
End Sub
Última actualización: 2 de Octubre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb021098.htm [01/03/2001 1:19:14]
25 de Septiembre de 1998 Cómo desactivar los repintados de una ventana
Cómo desactivar los repintados de una ventana
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
En ocasiones es conveniente que durante un cierto tiempo una ventana determinada no produzca
repintados, ya que la información que se quiere mostrar es amplia y no interesa que el usuario vaya
viendo cómo se va generando. La función LockWindowUpdate permite inhibir los repintados hasta que
se vuelva a llamar de nuevo a esta función con el parámetro NULL.
Al llamar a la función LockWindowUpdate, la ventana no procesa los repintados no pudiendo tampoco
el usuario moverla de posición.
A continuación, se muestra un ejemplo:
1. Cree un nuevo proyecto con dos botones y una caja de texto.
2. Copie el siguiente código en el formulario:
Private Declare Function LockWindowUpdate Lib "user32" _
(ByVal hwndLock As Long) As Long
Private Sub Command1_Click()
LockWindowUpdate Me.hWnd
Text1 = "prueba"
End Sub
Private Sub Command2_Click()
LockWindowUpdate 0&
End Sub
3. Pulse el botón Command1. Comprobará que la caja de texto no cambia a pesar de modificar su
propiedad Text. Si pulsa el botón Command2 podrá observar cómo se reflejan los cambios.
Última actualización: 25 de Septiembre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb250998.htm [01/03/2001 1:19:29]
18 de Septiembre de 1998 Cómo registrar/de-registrar servidores EXE
Cómo registrar/de-registrar servidores EXE
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
La utilidad REGSVR32 puede ser utilizada para registrar DLLs y OCXs, pero, ¿cómo registrar
servidores OLE de tipo EXE?.
Utilizando las opciones de la línea de comandos /regserver y /unregserver es posible registrar y
desregistrar cualquier servidor EXE sin necesidad de invocar el interfaz de usuario de la aplicación.
Ejemplo:
miservidor /regserver
miservidor /unregserver
Cuando se crea en Visual Basic un componente ActiveX EXE, la librería de COM añade
automáticamente el procesamiento de estos comandos.
Última actualización: 18 de Septiembre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb180998.htm [01/03/2001 1:19:48]
24 de Julio de 1998 Cómo desplazar bits de forma similar a los comandos << y >> de Visual C
Cómo desplazar bits de forma similar a los comandos << y >> de Visual C
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Las operaciones de desplazamiento de bits << y >> de C no están implementadas en Visual Basic. Sin
embargo, se pueden desarrollar un par de funciones de forma sencilla que nos permitan obtener esta
funcionalidad.
Para desplazar 1 bit a la izquierda hay que multiplicar por 2, para desplazar 2 bits a la izquierda hay
que multiplicar por 4 y así sucesivamente.
Para desplazar 1 bit a la derecha hay que dividir por 2, para desplazar 2 bits a la derecha hay que
dividir por 4 y, así sucesivamente.
A continuación, se muestra la implementación de las funciones aplicando el algoritmo anteriormente
descrito:
Function LShift(iVariable As Integer, _
iNumbits As Integer) As Integer
LShift = iVariable * (2 ^ iNumbits)
End Function
Function RShift(iVariable As Integer, _
iNumbits As Integer) As Integer
RShift = iVariable \ (2 ^ iNumbits)
End Function
Private Sub Command1_Click()
MsgBox LShift(1, 1)
MsgBox RShift(2, 1)
End Sub
Última actualización: 24 de Julio de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb240798.htm [01/03/2001 1:20:03]
17 de Julio de 1998 Cómo obtener un puntero a una variable
Cómo obtener un puntero a una variable
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Una de las características de Visual Basic que los programadores de C o Pascal echan de menos es el uso
de punteros. Visual Basic 5.0 proporciona una serie de funciones no documentadas ni soportadas que
permiten obtener un puntero a una variable, a un objeto o una cadena. Con un poco de imaginación y
gracias a esta nueva funcionalidad se pueden construir listas enlazadas, árboles, etc., que permitan
superar las limitaciones de Visual Basic. A continuación, se describen estas funciones no documentadas:
VarPtr(nombre_variable): obtiene un puntero a una variable de tipo Integer, Long, etc.,
excepto String. StrPtr(nombre_variable_string): obtiene un puntero a una variable de
tipo String. ObjPtr(nombre_variable_objeto): obtiene un puntero a una variable de tipo
objeto.
Ejemplo:
Dim x As String * 255
Dim y As New Form1
Dim z As Integer
MsgBox StrPtr(x)
MsgBox ObjPtr(y)
MsgBox VarPtr(z)
Última actualización: 17 de Julio de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb170798.htm [01/03/2001 1:20:21]
10 de Julio de 1998 Cómo registrar/desregistrar controles ActiveX rápidamente
Cómo registrar/desregistrar controles ActiveX rápidamente
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
A continuación, se indica cómo registrar/desregistrar DLLs y OCXs, asociando un tipo de fichero con
una acción:
1. Desde el "Explorador de Windows" seleccione en el menú Ver\Opciones y elija la pestaña "Tipos
de Archivo".
2. Haga clic en el botón "Nuevo tipo".
3. Rellene el campo "Descripción del tipo". Ejemplos:
Ficheros DLL
Ficheros OCX
4. Rellene el campo "Extensión asociada". Ejemplos:
DLL
OCX
5. Haga clic en el botón "Nueva" para añadir una acción al tipo de fichero.
6. Rellene el campo "Acción". Ejemplos:
Registrar
DeRegistrar
7. En el campo "Aplicación utilizada para realizar la acción" indique la aplicación Regsvr32.exe.
Ejemplos:
❍ Para registrar un fichero utilice Regsvr32.exe.
❍
Para desregistrar un fichero utilice Regsvr32.exe /u.
Observe que Regsvr32 es sólo para ficheros de 32-bit. Si intenta registrar ficheros de 16-bit
ocurrirá un error.
Última actualización: 10 de Julio de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb100798.htm [01/03/2001 1:20:39]
3 de Julio de 1998 Cómo evitar utilizar variables no declaradas
Cómo evitar utilizar variables no declaradas
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Visual Basic ofrece la posibilidad de utilizar variables que no han sido declaradas previamente (con la
instrucción Dim por ejemplo). Cuando esto ocurre, VB asume que las variables no declaradas son de
tipo Variant. El problema de utilizar variables no declaradas es que es complejo depurar una
aplicación.
Se puede evitar esta situación situando la instrucción Option Explicit en la sección General
Declaraciones de un módulo o formulario. Si su código incluye alguna variable no declarada se recibirá
un error en tiempo de compilación.
Última actualización: 3 de Julio de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb030798.htm [01/03/2001 1:21:09]
26 de Junio Cómo rellenar un ComboBox con los meses del año
Cómo rellenar un ComboBox con los meses del año
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
A continuación, se muestra una técnica para llenar de forma sencilla un ComboBox con los meses del
año:
For i = 1 To 12
Combo1.AddItem Format("28/" & i _
& "/1997", "mmmm")
Next
Última actualización: 26 de Junio de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb260698.htm [01/03/2001 1:21:34]
19 de Junio Cómo evitar múltiples instancias de una misma aplicación
Cómo evitar múltiples instancias de una misma aplicación
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Se puede evitar fácilmente que los usuarios ejecuten varias instancias de la misma aplicación, haciendo
uso de la propiedad PrevInstance del objeto App:
If App.PrevInstance Then
MsgBox "La aplicación ya está abierta"
Unload Me
End If
Última actualización: 19 de Junio de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb190698.htm [01/03/2001 1:22:00]
12 de Junio de 1998 Cómo evitar que los complementos se ejecuten al lanzar Visual Basic
Cómo evitar que los complementos se ejecuten al lanzar Visual Basic
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Cuando se ejecuta Visual Basic 4 o 5, también se ejecutan los complementos seleccionados. Si hay un
error en alguno de los complementos, éstos pueden generar fallos de protección general en Visual Basic.
Para prevenir que ocurran este tipo de problemas, se pueden desactivar los complementos editando el
fichero VBAddin.INI que se encuentra en el directorio WINDOWS. Al editar este fichero, aparecen
entradas como la siguiente:
AppWizard.Wizard=1
Cambie todos los "1" por "0" y grabe el fichero. Al ejecutar de nuevo VB no se carga ningún
complemento. Por supuesto, para añadir o quitar complementos dentro de VB, se recomienda utilizar el
Administrador de complementos que se encuentra en el menú Complementos.
Última actualización: 12 de Junio de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb120698.htm [01/03/2001 1:22:17]
5 de Junio Cómo limpiar las cajas de texto y otros controles de un formulario
Cómo limpiar las cajas de texto y otros controles de un formulario
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
En ocasiones es necesario limpiar o inicializar todos los campos de un formulario. Si el formulario
contiene bastantes controles, esta tarea puede llegar a ser tediosa. La siguiente rutina limpia de forma
automática el contenido de cualquier campo en un formulario:
Public Sub LimpiarControles(frmForm _
As Form)
Dim ctlControl As Object
On Error Resume Next
For Each ctlControl In frmForm.Controls
ctlControl.Text = ""
ctlControl.ListIndex = -1
DoEvents
Next ctlControl
End Sub
En el formulario llame a la función de la siguiente forma:
LimpiarControles Me
Última actualización: 5 de Junio de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb050698.htm [01/03/2001 1:22:43]
29 de Mayo de 1998 Cómo especificar la longitud máxima en un ComboBox
Cómo especificar la longitud máxima en un ComboBox
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
El control ComboBox no tiene la propiedad MaxLength como una caja de texto. Sin embargo, se puede
añadir código para simular esta propiedad. Por ejemplo, pegue el siguiente código en el evento KeyPress
de un ComboBox:
Private Sub Combo1_KeyPress(KeyAscii As Integer)
Const MAXLENGTH = 10
If Len(Combo1.Text) >= MAXLENGTH And _
KeyAscii <> vbKeyBack Then
KeyAscii = 0
End Sub
Se puede cambiar la constante MAXLENGTH a cualquier valor que se desee.
Última actualización: 29 de Mayo de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb290598.htm [01/03/2001 1:22:54]
22 de Mayo de 1998 Cómo crear pequeños arrays utilizando el tipo Variant
Cómo crear pequeños arrays utilizando el tipo Variant
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Si necesita crear una lista pequeña de ítems se puede ahorrar bastante código utilizando el tipo de datos
Variant en vez de un array dimensionado. Por ejemplo, añada un botón a un formulario estándar de VB
y pegue el siguiente código en el evento Click del botón:
Private Sub Command1_Click()
Dim Lista As Variant
Lista = Array("Item1", "Item2", "Item3", "Item4")
MsgBox Lista(2)
End Sub
Última actualización: 22 de Mayo de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb220598.htm [01/03/2001 1:23:13]
15 de Mayo 1998 Cómo mostrar un error de forma detallada al llamar a una API
Cómo mostrar un error de forma detallada al llamar a una API
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
La mayor parte de las APIs de 32 bits retornan información detallada sobre el error producido en caso
de fallo. Para obtener esta información en un formato adecuado y útil, se pueden utilizar las funciones
de la API GetLastError y FormatMessage.
Añada el siguiente código en un módulo de proyecto (.BAS):
Option Explicit
Public Declare Function GetLastError _
Lib "kernel32" () As Long
Public Declare Function FormatMessage _
Lib "kernel32" Alias "FormatMessageA" _
(ByVal dwFlags As Long, _
lpSource As Any, _
ByVal dwMessageId As Long, _
ByVal dwLanguageId As Long, _
ByVal lpBuffer As String, _
ByVal nSize As Long, _
Arguments As Long) As Long
Public Const FORMAT_MESSAGE_FROM_SYSTEM = &H1000
Public Function InformacionError() As String
Dim sError As String * 500
Dim lErrNum As Long
Dim lErrMsg As Long
lErrNum = GetLastError
lErrMsg = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, _
ByVal 0&, lErrNum, 0, sError, Len(sError), 0)
LastSystemError = Trim(sError)
End Function
Para comprobar si se produjo algún error al llamar a alguna API utilice el siguiente código:
Private Sub Command1_Click()
MsgBox InformacionError
End Sub
Última actualización: 15 de Mayo de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb150598.htm [01/03/2001 1:23:29]
8 de Mayo Cómo comprobar la existencia de un fichero determinado
Cómo comprobar la existencia de un fichero determinado
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
En ocasiones es necesario saber si un fichero existe antes de utilizarlo y evitar futuros problemas. La
siguiente función muestra cómo verificar la existencia de un fichero:
Public Sub VerificarFichero(_
sNombreFichero As String)
On Error Resume Next
Open sNombreFichero For Input As #1
If Err Then
MsgBox ("El fichero " &_
sNombreFichero & " no existe.")
Exit Sub
End If
Close #1
End Sub
Private Sub Command1_Click()
VerificarFichero "prueba.txt"
End Sub
Última actualización: 8 de Mayo de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb080598.htm [01/03/2001 1:23:47]
1 de Mayo de 1998 Cómo mostrar colores degradados en un formulario de VB
Cómo mostrar colores degradados en un formulario de VB
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
¿Se ha preguntado alguna vez cómo se consigue el efecto de color producido en la pantalla del
SETUP.EXE?. Este efecto se denomina degradado o "dithering" y puede ser fácilmente incorporado en
sus formularios utilizando la siguiente rutina:
Sub Degradado(vForm As Form)
Dim intContador As Integer
vForm.DrawStyle = vbInsideSolid
vForm.DrawMode = vbCopyPen
vForm.ScaleMode = vbPixels
vForm.DrawWidth = 2
vForm.ScaleHeight = 256
For intContador = 0 To 255
vForm.Line (0, intContador)-(Screen.Width, _
intContador - 1), RGB(0, 0, 255 - intContador), B
Next intContador
End Sub
Puede llamar a esta función desde el evento Paint del formulario. La rutina muestra un color azul
degradado aunque usted puede modificar el color en la función RGB.
Si muestra un MsgBox sobre el formulario al que ha aplicado el degradado y mueve la ventana de este
MsgBox antes de cerrarla, puede observar efectos extraños en el repintado del formulario. En este caso,
se recomienda simular el cuadro de mensaje con un formulario, en cuyo caso el movimiento de la
ventana no ocasiona ningún efecto colateral.
Última actualización: 15 de Marzo de 2000
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb010598.htm [01/03/2001 1:24:03]
24 de Abril Cómo implementar la función "Deshacer" en una caja de texto
Cómo implementar la función "Deshacer" en una caja de texto
Aplicable a partir de Microsoft Visual Basic 4.0
Cuando se modifica el contenido de una caja de texto, el sistema operativo Windows mantiene un buffer
con los datos añadidos o borrados. Se puede utilizar la función de la API SendMessage para recuperar
el texto modificado.
El mensaje EM_UNDO permite recuperar el texto modificado en una caja de texto. El mensaje
EM_EMPTYUNDOBUFFER vacía el buffer de "Deshacer". El mensaje EM_CANUNDO devuelve
True si hay texto en el buffer de "Deshacer".
A continuación, se muestra un ejemplo:
■ Cree un nuevo proyecto en Visual Basic. Form1 es creado por defecto.
■
Añada el siguiente código a la sección "Declaraciones" de Form1:
Private Declare Function SendMessage Lib _
"User" (ByVal hWnd As Integer, ByVal wMsg _
As Integer, ByVal wParam As Integer, _
lParam As Long) As Long
■
Const WM_USER = &H400
Const EM_CANUNDO = WM_USER + 22
Const EM_EMPTYUNDOBUFFER = _
WM_USER + 29
Const EM_UNDO = WM_USER + 23
Añada una caja de texto a Form1. Text1 es creado por defecto. Establezca su propiedad
MultiLine a True.
■
Añada un botón a Form1. Command1 es creado por defecto. Establezca su propiedad Caption a
"Undo".
■
Añada el siguiente código al evento Click de Command1:
■
■
Private Sub Command1_Click()
Dim OK As Long
OK = SendMessage(Text1.hWnd, _
EM_UNDO, 0, 0&)
OK = SendMessage(Text1.hWnd, _
EM_EMPTYUNDOBUFFER, 0, 0&)
End Sub
Añada un segundo botón a Form1. Command2 es creado por defecto. Establezca su propiedad
Caption a "Redo".
Añada el siguiente código al evento Click de Command2:
Private Sub Command2_Click()
Dim OK As Long
OK = SendMessage(Text1.hWnd, _
EM_CANUNDO, 0, 0&)
If OK = 0 Then
MsgBox "No puedo deshacer los cambios", _
16, "Error"
End If
OK = SendMessage(Text1.hWnd, _
http://www.microsoft.com/spain/support/trucos/vbasic/vb240498.htm (1 de 3) [01/03/2001 1:24:29]
24 de Abril Cómo implementar la función "Deshacer" en una caja de texto
EM_UNDO, 0, 0&)
End Sub
Última actualización: 24 de Abril de 1.998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
Cuando se modifica el contenido de una caja de texto, el sistema operativo Windows mantiene
un buffer con los datos añadidos o borrados. Se puede utilizar la función de la API
SendMessage para recuperar el texto modificado.
El mensaje EM_UNDO permite recuperar el texto modificado en una caja de texto. El mensaje
EM_EMPTYUNDOBUFFER vacía el buffer de "Deshacer". El mensaje EM_CANUNDO
devuelve True si hay texto en el buffer de "Deshacer".
A continuación, se muestra un ejemplo:
■ Cree un nuevo proyecto en Visual Basic. Form1 es creado por defecto.
■ Añada el siguiente código a la sección "Declaraciones" de Form1:
Private Declare Function SendMessage Lib _
"User" (ByVal hWnd As Integer, ByVal wMsg _
As Integer, ByVal wParam As Integer, _
lParam As Long) As Long
■
■
■
■
■
Const WM_USER = &H400
Const EM_CANUNDO = WM_USER + 22
Const EM_EMPTYUNDOBUFFER = _
WM_USER + 29
Const EM_UNDO = WM_USER + 23
Añada una caja de texto a Form1. Text1 es creado por defecto. Establezca su propiedad
MultiLine a True.
Añada un botón a Form1. Command1 es creado por defecto. Establezca su propiedad
Caption a "Undo".
Añada el siguiente código al evento Click de Command1:
Private Sub Command1_Click()
Dim OK As Long
OK = SendMessage(Text1.hWnd, _
EM_UNDO, 0, 0&)
OK = SendMessage(Text1.hWnd, _
EM_EMPTYUNDOBUFFER, 0, 0&)
End Sub
Añada un segundo botón a Form1. Command2 es creado por defecto. Establezca su
propiedad Caption a "Redo".
Añada el siguiente código al evento Click de Command2:
Private Sub Command2_Click()
Dim OK As Long
OK = SendMessage(Text1.hWnd, _
http://www.microsoft.com/spain/support/trucos/vbasic/vb240498.htm (2 de 3) [01/03/2001 1:24:29]
24 de Abril Cómo implementar la función "Deshacer" en una caja de texto
EM_CANUNDO, 0, 0&)
If OK = 0 Then
MsgBox "No puedo deshacer los cambios", _
16, "Error"
End If
OK = SendMessage(Text1.hWnd, _
EM_UNDO, 0, 0&)
End Sub
Se ve mejor con
Haga clic aquí.
Última actualización: 24 de Abril de 1.998
© 1997 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb240498.htm (3 de 3) [01/03/2001 1:24:29]
17 de Abril Cómo obtener el nombre del equipo.
Cómo obtener el nombre del equipo
Aplicable a partir de Microsoft Visual Basic 4.0
La función de la API GetComputerName permite recuperar el nombre que hemos asignado al equipo en
la configuración de la red en el panel de control. A continuación, se muestra un ejemplo:
■ Cree un nuevo proyecto en Visual Basic. Por defecto, se crea el formulario Form1.
■
■
Añada un botón tipo Command al Form1. Por defecto, el botón tiene el nombre Command1.
Añada el siguiente código al evento Click del Command1:
Private Sub Command1_Click()
Dim sEquipo As String * 255
GetComputerName sEquipo, 255
MsgBox sEquipo
End Sub
■
Añada el siguiente código en la sección Declaraciones del Form1:
Private Declare Function GetComputerName _
Lib "kernel32" Alias "GetComputerNameA" _
(ByVal lpBuffer As String, nSize As _
Long) As Long
Última actualización: 17 de Abril de 1.998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb170498.htm [01/03/2001 1:24:52]
10 de Abril Cómo determinar qué fuentes están instaladas en el sistema.
Cómo determinar qué fuentes están instaladas en el sistema
Aplicable a partir de Microsoft Visual Basic 4.0
La colección Fonts de los objetos Screen y Printer proporcionan una lista de todas las fuentes instaladas
en el sistema operativo. El siguiente ejemplo muestra cómo recuperar las fuentes de pantalla e
impresora instaladas:
● Cree un nuevo proyecto en Visual Basic. Por defecto, se crea el formulario Form1.
●
●
●
Añada un control Listbox al Form1. Por defecto, la lista tiene el nombre List1.
Añada un botón tipo Command al Form1. Por defecto, el botón tiene el nombre Command1.
Añada un segundo botón tipo Command al Form1. Por defecto, el botón tiene el nombre
Command2.
●
Añada el siguiente código al evento Click de Command1.
●
Private Sub Command1_Click()
List1.Clear
Dim X As Integer
For X = 0 To Printer.FontCount - 1
List1.AddItem Printer.Fonts(X)
Next X
End Sub
Añada el siguiente código al evento Click de Command2.
Private Sub Command2_Click()
List1.Clear
Dim X As Integer
For X = 0 To Screen.FontCount - 1
List1.AddItem Screen.Fonts(X)
Next X
End Sub
Última actualización: 10 de Abril de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb100498.htm [01/03/2001 1:25:09]
3 de Abril Cómo obtener el nombre corto (MS-DOS) a partir del nombre largo de un fichero
Cómo obtener el nombre corto (MS-DOS) a partir del nombre largo de un
fichero.
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
La API de 32 bits GetShortPathName obtiene el nombre corto de un fichero (formato 8.3) a partir de su
nombre largo. Haga la prueba con el siguiente ejemplo:
● Cree un nuevo proyecto en Visual Basic. Por defecto, se crea el formulario Form1.
●
●
Añada un botón tipo Command al Form1. Por defecto, el botón tiene el nombre Command1.
Añada el siguiente código al evento Click del Command1:
Private Sub Command1_Click()
Dim sNombreCorto As String * 255
GetShortPathName "C:\Archivos de _
programa\Accesorios\Wordpad.exe",_
sNombreCorto, 255
MsgBox sNombreCorto
End Sub
●
Añada el siguiente código en la sección Declaraciones del Form1:
Private Declare Function GetShortPathName Lib _
"kernel32" Alias "GetShortPathNameA" (ByVal _
lpszLongPath As String, ByVal lpszShortPath As _
String, ByVal cchBuffer As Long) As _
Long
Última actualización: 3 de Abril de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb030498.htm [01/03/2001 1:25:20]
27 de Marzo Cómo saber qué DLLs están cargadas en memoria y otra información útil del sistema.
Cómo saber qué DLLs están cargadas en memoria y otra información útil del
sistema
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Existe una aplicación muy útil denominada MSINFO32 que permite obtener información del sistema.
Con esta utilidad se puede saber:
● qué módulos o DLLs están cargadas en memoria.
qué aplicaciones se están ejecutando.
● qué versiones de DLLs tenemos en el sistema.
● cuánta memoria queda disponible, tipo de procesador, espacio libre en el disco, etc.
● qué drivers de impresora, audio y vídeo hay instalados.
● etc.
MSINFO32 puede ser accedida en Visual Basic 4 y 5 a través del menú "Ayuda | Acerca de Microsoft
Visual Basic". En el diálogo que aparece hay un botón llamado "Información del sistema" que ejecuta
la utilidad.
●
Última actualización: 27 de Marzo 1.998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb270398.htm [01/03/2001 1:25:35]
20 de Marzo Dónde encontrar los ficheros CABINET que son necesarios cuando se distribuye una aplicación en Internet
Dónde encontrar los ficheros CABINET que son necesarios cuando se
distribuye una aplicación en Internet
Aplicable a Microsoft Visual Basic 5.0
Cuando se distribuye una aplicación en Internet como un Visual Basic Document, es necesario que los
componentes utilizados estén empaquetados en ficheros CAB para que puedan ser descargados al
cliente. Cuando se hace la distribución con el Asistente para Instalar Aplicaciones tenemos la opción de
descargar los componentes desde el web de Microsoft o desde el servidor web que se le indique. Si se
elige esta última opción es necesario tener instalado en el servidor los ficheros CAB de los componentes.
Estos ficheros pueden ser obtenidos del directorio \TOOLS\CABINETS del CD-ROM de la instalación
de Visual Basic 5.0.
Última actualización: 20 de Marzo de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb200398.htm [01/03/2001 1:26:01]
13 de Marzo CÓMO INCLUIR DOS CAMPOS EN UN CONTROL DBCOMBO
Cómo incluir dos campos en un control DBCOMBO
Aplicable a Microsoft Visual Basic 4.0
El control dbcombo de Visual Basic permite visualizar campos independientes de la tabla especificada
en un control de datos. Hay una forma sencilla de incluir el contenido de dos campos en este control.
Para ello basta con indicar en la propiedad RecordSource del control de datos la sentencia SQL
apropiada. Por ejemplo:
RecordSource = "select au_id & "" "" & author as "& "enlazado from authors"
selecciona y concatena los campos au_id y author de la tabla Authors.
El control dbcombo podrá asociarse posteriormente al campo enlazado.
En un proyecto Visual Basic, para hacer esto deberían añadirse los controles dbcombo y data control en
un formulario e indicar en sus propiedades:
Data1
DatabaseName = "C:\vb4\Biblio.mdb"
RecordSource = "select au_id & "" "" & author as " & "enlazado from authors"
DBCombo1
ListField = "enlazado"
BoundColumn= "enlazado"
Última actualización: 13 de Marzo de 1.998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb130398.htm [01/03/2001 1:26:22]
6 de Marzo Cómo añadir bloques de comentarios en el código de forma sencilla en Microsoft Visual Basic 5.0
Cómo añadir bloques de comentarios en el código de forma sencilla en
Microsoft Visual Basic 5.0
Aplicable a Microsoft Visual Basic 5.0
Cuando se desarrolla y depura una aplicación, en muchas ocasiones surge la necesidad de comentar
fragmentos o bloques de código. Esta labor era tediosa en versiones anteriores de Visual Basic, ya que
había que añadir al principio de cada línea el carácter '.
En Visual Basic 5.0, los bloques de comentarios se pueden crear de la siguiente forma:
1. Cerciórese de que aparece la barra de herramientas de edición en el entorno de desarrollo,
seleccionando la opción del menú Ver\Barra de Herramientas\Edición.
2. Seleccione el bloque de código que desea comentar.
3. Haga click en el botón "Bloque con comentarios" (9º botón de la barra de herramientas de
edición).
4. Para quitar los comentarios y reestablecer el código pulse el botón "Bloque sin comentarios" (10º
botón de la barra de herramientas de edición).
Última actualización: 6 de Marzo de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb060398.htm [01/03/2001 1:26:50]
27 de Febrero Cómo realizar una consulta por PASSTHROUGH en RDO
Cómo realizar una consulta por PASSTHROUGH en RDO
La técnica del "passthrough" permite enviar una consulta SQL a una base de datos sin necesidad de
pasar por el administrador de ODBC. La ventaja principal de utilizar "passthrough" es obtener un
mejor rendimiento ya que la consulta es procesada por menos componentes. Además, en ciertas
ocasiones es necesario utilizar esta técnica cuando se utilizan sentencias SQL que no son estándar y son
propietarias de una base de datos concreta.
El último parámetro de la instrucción "OpenResulset" permite pasar una consulta por "passthrough"
especificando la constante "rdExecDirect".
El siguiente ejemplo muestra cómo ejecutar una consulta por "passthrough":
Dim cn as New rdoConnection
Dim rst as rdoResultset
cn.Connect="uid=sa;pwd=;server=SERVIDOR;_
driver=" & "{SQLServer};database=pubs;_
DSN=' ';"
cn.EstablishConnection rdDriverNoPrompt
Set rst=cn.OpenResultset("SELECT * FROM_
authors", rdOpenKeyset,rdConcurReadOnly,_
rdExecDirect)
Última actualización: 27 de Febrero 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/vbasic/vb270298.htm [01/03/2001 1:27:04]
20 de Febrero Cómo depurar Microsoft Visual Basic Documents (VBDS)
Cómo depurar Microsoft Visual Basic Documents (VBDS)
Aplicable a Microsoft Visual Basic 5.0
La depuración de un VBD sigue unos procedimientos ligeramente diferentes a la depuración de un
aplicación normal. Para depurar un VBD siga los siguientes pasos (se supone que tiene instalado Visual
Basic 5 en el directorio C:\VB5 y el proyecto se llama PRUEBA.VBP):
1. Ejecute el VBD en el entorno de desarrollo, cargando el proyecto del VBD y pulsando F5. Al
realizar este paso, Visual Basic le crea automáticamente un fichero llamado PRUEBA.VBD en el
directorio donde tenga instalado Visual Basic 5 (en este caso C:\VB5).
2. Ponga un punto de ruptura en alguna línea de código del VBD.
3. En Internet Explorer ejecute el VBD tecleando la siguiente dirección: C:\VB5\PRUEBA.VBD
4. Cuando la ejecución del VBD llegue a la línea donde se estableció el punto de ruptura, el entorno
de desarrollo de Visual Basic se situará en primer plano, permitiendo una depuración paso a
paso.
Última actualización: 20 de Febrero de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb200298.htm [01/03/2001 1:27:29]
13 de Febrero Cómo simular el comportamiento de la barra de herramientas de Microsoft office 97
Cómo simular el comportamiento de la barra de herramientas de Microsoft
office 97
Aplicable a Microsoft Visual Basic 5.0
En Microsoft Visual Basic no existe ningún control que implemente la funcionalidad de la barra de
herramientas de Microsoft Office 97 ó Microsoft Internet Explorer.
Sin embargo, Microsoft ha desarrollado dos controles ActiveX que permiten a los usuarios de Visual
Basic dar un aspecto a sus aplicaciones similar a las barras de herramientas de Office 97 ó Internet
Explorer.
Estos controles pueden ser obtenidos conectándose al "Owner's Area" de Visual Basic en el Web de
Microsoft. Los usuarios de Visual Basic pueden tener acceso al "Owner's Area" registrándose en:
http://www.eu.microsoft.com/vbasic
Los controles en cuestión son los siguientes:
●
Visual Basic Soft Button Sample: Imita el comportamiento de la barra de herramientas de
Microsoft Office 97.
●
Visual Basic CoolBar Control: Permite crear barras de herramientas similares a las de Microsoft
Internet Explorer.
Última actualización: 13 de Febrero de 1.998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb130298.htm [01/03/2001 1:27:43]
6 de Febrero Cómo especificar la posición de un formulario sin necesidad de programar en VB 5.0
Cómo especificar la posición de un formulario sin necesidad de programar en
Microsoft Visual Basic 5.0
Aplicable a Microsoft Visual Basic 5.0
En versiones anteriores de Visual Basic, para centrar un formulario en el escritorio era necesario
obtener las características físicas de la pantalla y calcular las coordenadas.
En Visual Basic 5.0 existe la posibilidad de centrar un formulario en pantalla sin necesidad de
programación. Para ello, vaya al menú "Ver" y seleccione la opción "Ventana Posición del formulario".
Haga clic con el botón derecho en la ventana de "Posición del formulario" y seleccione "Posición
inicial". En el menú que aparece a continuación haga clic en "Centro de la pantalla".
Cuando ejecute la aplicación, comprobará que el formulario está centrado en pantalla sin escribir una
sola línea de código.
Última actualización: 6 de Febrero 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb060298.htm [01/03/2001 1:27:59]
30 de Enero Cómo desarrollar DLLs en C que puedan ser utilizadas por Visual Basic
Cómo desarrollar DLLs en C que puedan ser utilizadas por Visual Basic
Aplicable a de Microsoft Visual Basic 5.0 Enterprise
El desarrollo de DLLs que puedan ser llamadas desde Visual Basic deben seguir una estructura
determinada. Las DLLs para Visual Basic tienen una convención de llamada, paso de parámetros, etc.
especiales.
La documentación junto con ejemplos de estas especificaciones las puede encontrar en el directorio
\TOOLS\DOCS\VB5DLL.DOC del CD-ROM de instalación de Visual Basic 5.0.
Última actualización: 30 de Enero de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb300198.htm [01/03/2001 1:28:10]
23 de Enero Cómo introducir valores en una celda dentro de un control DBGRID desde Visual Basic
Cómo introducir valores en una celda dentro de un control DBGRID
Aplicable a Microsoft Visual Basic 4.0
Aparentemente, la forma correcta y más simple de introducir valores en una celda de un dbgrid ligado a
un control de datos (data control), es utilizando la propiedad Value. En cambio, si en un formulario
insertamos un código como el siguiente:
Private Sub Command2_Click()
DBGrid1.Columns(2).Value = 438
End Sub
se lanzará el error 438 en tiempo de ejecución: "el objeto no acepta esta propiedad o método".
Realmente la forma correcta de introducir valores en una celda de un dbgrid es a través del control de
datos asociado con el dbgrid. De esta forma el código:
Private Sub Command1_Click()
Data1.Recordset.Edit
Data1.Recordset.Fields(1)=438
Data1.Recordset.Update
End Sub
cumple la misma labor y no da lugar a ningún mensaje de error.
NOTA: El True DBGrid versión Standard, considerado como actualización al dbgrid incluido en Visual
Basic 4.0, permite utilizar la propiedad Value para introducir valores en una celda. Este control actualizado
puede conseguirse en la BBS de Microsoft España (tfno: 91- 8035977). Los nombres de los ficheros
correspondientes son: tdbgsx16.exe (version en 16 bits del OCX) y tdbgsx32.exe (version en 32 bits del
OCX).
Última actualización: 23 de Enro de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb230198.htm [01/03/2001 1:28:22]
16 de Enero Dónde encontrar una herramienta que permita crear bas...datos existentes, asistente de consultas, etc. desde Visual Basic
Dónde encontrar una herramienta que permita crear bases de datos, editar el
diseño de bases de datos existentes, asistente de consultas, etc.
Aplicable a Microsoft Visual Basic 5.0 Enterprise
Microsoft Visual Basic 5.0 se acompaña con una utilidad llamada "Microsoft Visual Database Tools".
Esta herramienta no se instala en el proceso de instalación estándar de Visual Basic 5.0.
El setup de Visual Database Tools se encuentra en el directorio \TOOLS\DATATOOL. Una vez que está
instalado este producto, en Visual Basic 5.0 elija el menú "Complementos", haga clic en
"Administrador de complementos..." y seleccione "Microsoft DataTools".
Para ejecutar las DataTools haga clic en "Visual Database Tools" del menú "Complementos".
Última actualización: 16 de Enero 1.998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb160198.htm [01/03/2001 1:28:42]
9 de Enero Solución a los parpadeos que se producen al descargar un formulario que contiene un control DBgrid desde Visual Basic
Solución a los parpadeos que se producen al descargar un formulario que
contiene un control DBgrid
Aplicable a Microsoft Visual Basic 4.0
En determinadas circunstancias, al descargar un formulario que contiene un dbgrid, el formulario que
lo mostró puede quedar parpadeante, siendo imposible que el usuario vuelva a tomar el control de la
aplicación.
¿Qué circunstancias son estas?
Las condiciones bajo las que se produce este hecho son:
● Un Form1 muestra de forma modal un Form2 (Form2.Show 1)
●
●
Form2 muestra a su vez un tercer formulario Form3 también de forma modal (Form3.Show 1)
Form3 contiene un dbgrid
Bajo estas circunstancias, al descargar el Form3, por ejemplo desde un botón con el código:
Private Sub Command1_Click()
Unload Me
End Sub
el foco, que debería volver a Form2, queda indeterminado. El resultado es que el formulario Form2
parpadea continuamente, siendo imposible volver a tomar el control en dicho formulario, y por tanto en
la aplicación.
¿Cómo impedir este comportamiento?
Simplemente añadiendo una línea Me.Enabled = False en el código del botón que descarga Form3, con
lo que el código en este botón quedaría:
Private Sub Command1_Click()
Me.Enabled = False
Unload Me
End Sub
Última actualización: 9 de Enero de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb090198.htm [01/03/2001 1:29:00]
19 de Diciembre Cómo implementar en Visual Basic un control similar al Microsoft Calendar de Office desde Visual Basic
Cómo implementar en Visual Basic un control similar al Microsoft Calendar
Aplicable a Microsoft Visual Basic 5.0
En Visual Basic no existe ningún control que implemente la funcionalidad de un calendario. Microsoft
Office dispone de un control llamado Microsoft Calendar que aunque puede ser utilizado desde
Microsoft Visual Basic, legalmente su distribución obliga a tener instalado Microsoft Office en cada
puesto cliente. Esta incoveniencia puede ser solventada utilizando un control de ejemplo que se incluye
en el CD-ROM de instalación de Visual Basic 5.0.
El ejemplo del control calendario se encuentra en el directorio \TOOLS\UNSUPPORT\CALENDAR.
Última actualización: 19 de Diciembre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb191297.htm [01/03/2001 1:29:14]
Tratamiento de DBCOMBO y el registro actual
Aplicable a Microsoft Visual Basic 4.0
Podría pensarse que si en un formulario disponemos de un control de datos (data control) y un control
dbcombo asociado a él para visualizar los datos de una columna de una tabla, la selección de un
elemento en el dbcombo supone que automáticamente el registro actual en el control de datos (es decir,
en el cursor) es aquél cuyo valor coincide con el seleccionado en el control dbcombo.
Este no es en realidad el comportamiento de este control, en cambio con una única línea de código
podemos conseguir dicha funcionalidad. La siguiente línea coloca como registro actual en el cursor, el
coincidente con el valor actualmente seleccionado en el dbcombo:
Data1.Recordset.Bookmark = DBCombo1.SelectedItem
Última actualización: 12 de Diciembre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb121297.htm [01/03/2001 1:29:26]
5 de Diciembre Cómo utilizar en Visual Basic 5.0 controles que se incluían en la versión 4.0 y que Visual Basic 5.0 ya no instala
Cómo utilizar en Visual Basic 5.0 controles que se incluían en la versión 4.0 y
que Visual Basic 5.0 ya no instala
Aplicable a Microsoft Visual Basic 5.0 Enterprise
Los siguientes controles que se suministraban con Visual Basic 4.0 ya no son instalados por Visual Basic
5.0:
● AniBtn32.OCX
●
●
●
●
●
●
●
●
Gauge32.OCX
Graph32.OCX
Grid32.OCX
KeySta32.OCX
MSOutl32.OCX
MSRDC32.OCX
Spin32.OCX
ThreeD32.OCX
Estos controles han sido reemplazados por otros o por controles intrínsecos de Microsoft Visual Basic
mejorados que proporcionan la misma funcionalidad. Aunque los controles antiguos no están
soportados por Microsoft, para mantener compatibilidad con versiones anteriores se ha decidido incluir
en el directorio \TOOLS\CONTROLS del CD-ROM de la instalación de Microsoft Visual Basic, los
controles de Visual Basic 4.0.
Para instalar estos controles siga los pasos que se comentan en el fichero README.TXT del directorio
indicado anteriormente.
Última actualización: 5 de Diciembre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb051297.htm [01/03/2001 1:30:03]
28 de Noviembre Tratamiento de SSPANEL y la barra de progreso desde Visual Basic
Tratamiento de SSPANEL y la barra de progreso desde Visual Basic
Aplicable a Microsoft Visual Basic 4.0
Para implementar una barra de progreso en Visual Basic 4.0 se puede utilizar el control OCX Gauge o
el control ProgressBar de Windows 95. En el entorno de 16 bits los controles de Windows 95 no están
disponibles, por lo que no es utilizable el control ProgressBar, y el control Gauge a veces produce
parpadeos no deseados.
Un pequeño truco para implementar una barra de progreso, que además muestra la evolución en %, es
utilizar el control SSPanel, componente del threed16.ocx y threed32.ocx para 16 y 32 bits
respectivamente. Basta con utilizar las propiedades FloodType y FloodPercent. En tiempo de diseño se
coloca la propiedad FloodType con el valor 1 - Left to Right. La propiedad FloodPercent (sólo utilizable
en ejecución) puede utilizarse en un código como el siguiente añadido al clic de un botón:
Dim i As Integer
For i = 1 To 100
SSPanel1.FloodPercent = i
DoEvents
Next
De esta forma conseguimos rellenar el SSPanel desde el valor 0 al 100.
Última actualización: 28 de Noviembre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb281197.htm [01/03/2001 1:30:31]
24 de Octubre Cómo obtener una lista de los procesos en memoria en Windows 95
Cómo obtener una lista de los procesos en memoria en Windows 95
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
En un aplicación de Visual Basic de 32 bits se puede obtener la lista de los procesos que se están
ejecutando en un momento determinado en Windows 95. Para ello, es necesario utilizar una serie de
funciones del KERNEL32 llamadas ProcessFirst y ProcessNext.
Para ver un ejemplo cree un nuevo projecto y en un formulario añada un listbox (List1) y un command
button (Command1). Introduzca el siguiente código en un modulo .BAS:
Option Explicit
Public Const TH32CS_SNAPPROCESS As _
Long = 2&
Public Const MAX_PATH As Integer = 260
Public Type PROCESSENTRY32
dwSize As Long
cntUsage As Long
th32ProcessID As Long
th32DefaultHeapID As Long
th32ModuleID As Long
cntThreads As Long
th32ParentProcessID As Long
pcPriClassBase As Long
dwFlags As Long
szExeFile As String * MAX_PATH
End Type
Public Declare Function _
CreateToolhelpSnapshot Lib "Kernel32" _
Alias "CreateToolhelp32Snapshot" (ByVal _
lFlags As Long, ByVal lProcessID As _
Long) As Long
Public Declare Function ProcessFirst Lib _
"Kernel32" Alias "Process32First" (ByVal _
hSnapShot As Long, uProcess As _
PROCESSENTRY32) As Long
Public Declare Function ProcessNext _
Lib "Kernel32" Alias "Process32Next" _
(ByVal hSnapShot As Long, uProcess As _
PROCESSENTRY32) As Long
Public Declare Sub CloseHandle Lib _
"Kernel32" (ByVal hPass As Long)
Añada el siguiente código en el formulario:
Private Sub Command1_Click()
Dim hSnapShot As Long
Dim uProceso As PROCESSENTRY32
Dim r As Long
hSnapShot = CreateToolhelpSnapshot _
(TH32CS_SNAPPROCESS, 0&)
http://www.microsoft.com/spain/support/trucos/Vbasic/vb241097.htm (1 de 4) [01/03/2001 1:30:43]
24 de Octubre Cómo obtener una lista de los procesos en memoria en Windows 95
If hSnapShot = 0 Then Exit Sub
uProceso.dwSize = Len(uProceso)
r = ProcessFirst(hSnapShot, uProceso)
Do While r
List1.AddItem uProceso.szExeFile
r = ProcessNext(hSnapShot, uProceso)
Loop
Call CloseHandle(hSnapShot)
End Sub
Última actualización: 24 de Octubre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
En un aplicación de Visual Basic de 32 bits se puede obtener la lista de los procesos que se
están ejecutando en un momento determinado en Windows 95. Para ello, es necesario
utilizar una serie de funciones del KERNEL32 llamadas ProcessFirst y ProcessNext.
Para ver un ejemplo cree un nuevo projecto y en un formulario añada un listbox (List1) y
un command button (Command1). Introduzca el siguiente código en un modulo .BAS:
Option Explicit
Public Const TH32CS_SNAPPROCESS As _
Long = 2&
Public Const MAX_PATH As Integer = 260
Public Type PROCESSENTRY32
dwSize As Long
cntUsage As Long
th32ProcessID As Long
th32DefaultHeapID As Long
th32ModuleID As Long
cntThreads As Long
th32ParentProcessID As Long
pcPriClassBase As Long
dwFlags As Long
szExeFile As String * MAX_PATH
End Type
Public Declare Function _
CreateToolhelpSnapshot Lib "Kernel32" _
Alias "CreateToolhelp32Snapshot" (ByVal _
lFlags As Long, ByVal lProcessID As _
Long) As Long
http://www.microsoft.com/spain/support/trucos/Vbasic/vb241097.htm (2 de 4) [01/03/2001 1:30:43]
24 de Octubre Cómo obtener una lista de los procesos en memoria en Windows 95
Public Declare Function ProcessFirst Lib _
"Kernel32" Alias "Process32First" (ByVal _
hSnapShot As Long, uProcess As _
PROCESSENTRY32) As Long
Public Declare Function ProcessNext _
Lib "Kernel32" Alias "Process32Next" _
(ByVal hSnapShot As Long, uProcess As _
PROCESSENTRY32) As Long
Public Declare Sub CloseHandle Lib _
"Kernel32" (ByVal hPass As Long)
Añada el siguiente código en el formulario:
❍
Private Sub Command1_Click()
Dim hSnapShot As Long
Dim uProceso As PROCESSENTRY32
Dim r As Long
hSnapShot = CreateToolhelpSnapshot _
(TH32CS_SNAPPROCESS, 0&)
If hSnapShot = 0 Then Exit Sub
uProceso.dwSize = Len(uProceso)
r = ProcessFirst(hSnapShot, uProceso)
Do While r
List1.AddItem uProceso.szExeFile
r = ProcessNext(hSnapShot, uProceso)
■
Loop
Call CloseHandle(hSnapShot)
End Sub
Se ve mejor con
Haga clic aquí.
Última actualización: 24 de Octubre de 1.997
http://www.microsoft.com/spain/support/trucos/Vbasic/vb241097.htm (3 de 4) [01/03/2001 1:30:43]
24 de Octubre Cómo obtener una lista de los procesos en memoria en Windows 95
© 1997 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb241097.htm (4 de 4) [01/03/2001 1:30:43]
17 de Octubre Cómo reproducir un CD de audio
Cómo reproducir un CD de audio
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Desde Visual Basic se puede reproducir un CD de audio mediante el uso de MCI, como se muestra en el
siguiente ejemplo para VB 16 bits:
'Introduzca en un formulario un MMControl _
(Multimedia Control)
Declare Function mciSendString& Lib _
"MMSYSTEM" (ByVal lpstrCommand$, _
ByVal lpstrReturnStr As Any, ByVal _
wReturnLen%, ByVal hCallBack%)
Sub cmdPlay_Click ()
Dim Resultado As Long
Dim PistaActual As Integer
'Apertura del dispositivo
Resultado = mciSendString( _
"open cdaudio alias cd wait", _
0&, 0, 0)
'Establecer formato de tiempo en pistas
Resultado = mciSendString("set cd time _
format tmsf", 0&, 0, 0)
'Comenzar desde el principio
Resultado = mciSendString("play cd", 0&, 0, 0)
'O reproducir por ejemplo la pista 4
PistaActual = 4
resultado = mciSendString("play cd from" & _
Str (PistaActual) , 0&, 0, 0)
End Sub
Sub cmdStop_Click ()
Dim lRet As Long
'Parar reproducción
lRet = mciSendString("stop cd wait", 0&, 0, 0)
DoEvents 'Procesar evento
'Cerrar dispositivo
lRet = mciSendString("close cd", 0&, 0, 0)
End Sub
Última actualización: 17 de Octubre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb171097.htm [01/03/2001 1:31:02]
10 de Octubre Cómo saber si un ejecutable es de Windows o MS-DOS
Cómo saber si un ejecutable es de Windows o MS-DOS
Aplicable a todas las versiones
Para saber si un ejecutable es de MS-DOS o Windows, se debe examinar el byte número 25 del fichero
EXE. Si contiene el valor 40h es un ejecutable de Windows:
Function WinExe (ByVal Exe As String) As Integer
Dim fh As Integer
Dim t As String * 1
fh = FreeFile
Open Exe For Binary As #fh
Get fh, 25, t
Close #fh
WinExe = (Asc(t) = &H40&)
End Function
Última actualización: 10 de Octubre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb101097.htm [01/03/2001 1:31:14]
3 Octubre Visualización de vídeos AVI con MCI
Visualización de vídeos AVI con MCI
Aplicable a las versiones 3.0 y 4.0/16 bits
Desde las aplicaciones de Visual Basic se pueden visualizar vídeos AVI haciendo uso del MCI
(Multimedia Control Interface). Sólo es necesario enviar un par de órdenes MCI como en el siguiente
ejemplo para VB 16 bits:
Private Declare Function mciSendString _
Lib "mmsystem" (ByVal strCommand As _
String, ByVal strReturn As String, ByVal _
iReturnLength As Integer, ByVal hCallback _
As Integer)
Sub ReproducirAVI()
Dim Resultado as Long
Resultado = mciSendString("Open _
MiAvi.avi type AVIVideo Alias _
Video", "",0,0)
Resultado = mciSendString("Play Video _
FullScreen","",0,0)
Resultado = mciSendString("Close _
Video","",0,0)
End Sub
Última actualización: 3 de Octubre de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb031097.htm [01/03/2001 1:31:39]
26 de Septiembre Cómo aumentar el rendimiento del control ListView
Cómo aumentar el rendimiento del control ListView
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
El ListView es un control perteneciente a los "Custom Controls" de Windows 95 que puede ser usado en
aplicaciones de 32-bit. Aunque es un control muy útil, las inserciones de nuevos elementos es lenta y
pueden apreciarse problemas de rendimiento.
Un solución a este problema es desactivar los repintados del ListView mientras se introducen nuevos
elementos. Esto puede ser realizado enviando el mensaje WM_SETREDRAW al control. una vez que
hayan sido añadidos todos los elementos, se puede enviar otro mensaje WM_SETREDRAW para
permitir los repintados.
A continuación se muestra un ejemplo de código:
Private Declare Function SendMessage _
Lib "user32" Alias "SendMessageA"_
(ByVal hwnd As Long, ByVal wMsg As _
Long, ByVal wParam As Long, lParam As _
Long) As Long
Sub AñadirItems()
Dim itm As ListItem
Dim i As Long
'desactivar los repintados del listview
Call SendMessage(ListView1.hwnd, _
WM_SETREDRAW, 0, 0)
ListView1.ListItems.Clear
For i = 1 To 100
Set itm = ListView1.ListItems.Add(, , _
"Elemento" & CStr(i))
itm.SubItems(1) = "sub1." & CStr(i)
itm.SubItems(2) = "sub2." & CStr(i)
Next
'Habilitar los repintados
Call SendMessage(ListView1.hwnd, _
WM_SETREDRAW, 1, 0)
End Sub
Última actualización: 26 de Septiembre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb260997.htm [01/03/2001 1:32:00]
19 de Septiembre Captura de errores del DBGrid en tiempo de ejecución
Captura de errores del DBGrid en tiempo de ejecución
Aplicable a Microsoft Visual Basic 4.0
El control DBGrid ha sido diseñado para mostrar mensajes de error, no sólo cuando ocurre un error,
sino también bajo circunstancias "normales", tales como cuando el parámetro Cancel es establecido a
True en los eventos BeforeDelete o BeforeUpdate.
Se pueden capturar estos errores y mostrar nuestros propios mensajes (o ninguno) escribiendo código
en el evento no documentado DBGrid_Error:
Private Sub DBGrid_Error(ByVal DataError As _
Integer, Response As Integer)
' La acción fue cancelada...
If DataError = 16389 Then
' Mostrar un mensaje de error
' o no hacer nada
Response = vbDataErrContinue
End If
End Sub
Última actualización: 19 de Septiembre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb190997.htm [01/03/2001 1:32:13]
12 de Septiembre Acceso a bases de datos seguras
Acceso a bases de datos seguras
Aplicable a Microsoft Visual Basic 4.0
La documentación de VB4 es confusa a la hora de explicar cómo abrir bases de datos seguras de Access.
La apertura de este tipo de bases de datos es distinta dependiendo de si la aplicación es de 16-bit ó
32-bit.
Para programas de 16-bit, se debe crear un fichero NOMBREAPLICACION.INI con las siguientes
secciones:
[Data]
Database=C:\Directorio\Nombrebasedato.MDB
[Options]
SystemDB=C:\Directorio\SYSTEM.MDA
Para abrir la base de datos hay que utilizar el siguiente código:
Dim
Dim
Dim
Dim
sNombreUsuario As String
sContraseña As String
bd As Database
ws As Workspace
sNombreUsuario = "Nombre de usuario"
sContraseña = "Contraseña"
' Creación de workspace seguro
With DBEngine
.IniPath = _
"C:\directorio\nombreaplicacion.INI"
.DefaultUser = sNombreUsuario
.DefaultPassword = sContraseña
End With
Set ws = DBEngine.CreateWorkspace( _
"MiWorkspace", sNombreUsuario, sContraseña)
Set bd = ws.OpenDatabase _
("D:\directorio\nombrebasedato.MDB"...)
Los programas de 32-bit no requieren un fichero .INI, ni hacer uso de las propiedades DefaultUser y
DefaultPassword. Sólo es necesario establecer la propiedad SystemDB del objeto DBEngine indicando
cuál es la base de datos de sistema:
Dim
Dim
Dim
Dim
sNombreUsuario As String
sContraseña As String
bd As Database
ws As Workspace
sNombreUsuario = "Nombre de usuario"
sContraseña = "Contraseña"
' Creación de workspace seguro
DBEngine.SystemDB = _
"C:\DIRECTORIO\SYSTEM.MDW"
Set ws = _
DBEngine.CreateWorkspace _
("MiWorkspace", _
http://www.microsoft.com/spain/support/trucos/Vbasic/vb120997.htm (1 de 2) [01/03/2001 1:32:30]
12 de Septiembre Acceso a bases de datos seguras
sNombreUsuario, sContraseña)
Set bd = ws.OpenDatabase _
("C:\directorio\nombrebasedato.MDB"...)
Última actualización: 12 de Septiembre de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb120997.htm (2 de 2) [01/03/2001 1:32:30]
5 Septiembre Cómo establecer márgenes cuando se imprime con el RichTextBox
Cómo establecer márgenes cuando se imprime con el RichTextBox
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Si se utiliza el método SelPrint para imprimir el contenido de un control RichTextBox, se puede
observar que se genera un margen a cada lado de la página de una pulgada.
El control RichTextBox no ofrece ninguna posibilidad para cambiar el margen, pero afortunadamente
se puede llevar a cabo esta funcionalidad utilizando la API de programación.
Se puede hacer una llamada a la función SendMessage para enviar mensajes del tipo
EM_SETTARGETDEVICE y EM_FORMATRANGE al RichTextBox. Para ver un ejemplo de cómo
utilizar estos mensajes en una aplicación VB, es recomendable la lectura del siguiente artículo de la base
de conocimiento de Microsoft:
Q146022: How to Set Up the RichTextBox Control for WYSIWYG Printing
Última actualización: 5 de Septiembre
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb050997.htm [01/03/2001 1:33:12]
1 Agosto ¿Por qué se produce un error al establecer la propiedad MatchEntry del DBCombo?
¿Por qué se produce un error al establecer la propiedad MatchEntry del
DBCombo?
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
Cuando se intenta establecer la propiedad MatchEntry de un control DBCombo a "1 - Extended
Matching" (en tiempo de diseño o ejecución), VB puede mostrar el mensaje de error "Propiedad de solo
lectura".
El problema ocurre porque "Extended Matching" puede ser sólo usado con DBCombos cuya propiedad
Style es "2 - Dropdown List". Cambie el estilo de forma adecuada para que este error desaparezca.
Última actualización: 1 de Agosto de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb010897.htm [01/03/2001 1:33:24]
25 de Julio Cómo usar CompactDatabase con un base de datos con contraseña
Cómo usar CompactDatabase con un base de datos con contraseña
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
La documentación de la función CompactDatabase indica que acepta cuatro parámetros:
DBEngine.CompactDatabase base_datos_ant, _
base_datos_nva [, inf_local [, opciones]]
Si se intenta compactar una base de datos protegida con contraseña obtendremos un error. Parece
evidente que es necesario otro parámetro donde indicar la contraseña.
Si observamos el método CompactDatabase del objeto DBEngine en el "Examinador de Objetos", se
puede comprobar que acepta cinco parámetros y no cuatro como indica la documentación:
DBEngine.CompactDatabase SrcName, _
DstName, DstConnect, Options, _
SrcConnect
Estableciendo el último parámetro a ";pwd=contraseña", se puede compactar una base de datos
protegida.
Última actualización: 25 de Julio de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb250797.htm [01/03/2001 1:33:51]
18 de Julio Cómo cancelar un AddNew/Edit sin abandonar el registro
Cómo cancelar un AddNew/Edit sin abandonar el registro actual
Aplicable a todas las versiones
La documentación de VB establece que si no se está usando un control de datos (datacontrol) y se
emplea alguno de los métodos Move o Find, o se cierra el recordset habiendo algún Edit o AddNew
pendiente, entonces no ocurrirá ningún error pero los cambios se perderán.
Así, un método simple para cancelar una edición es cambiar de registro. Sin embargo, es posible
cancelar una edición sin abandonar el registro actual:
' En VB4...
Dim rs As Recordset
' Comienzo de un Edit
rs.Edit
...
' Cancelación
rs.Move 0
' En VB3...
Dim ds As Dynaset
Dim sBkMk As String
' Grabar bookmark del registro actual
sBkMk = ds.Bookmark
' Comienzo de un Edit
ds.Edit
' Cancelación
ds.Bookmark = sBkMk
Última actualización: 18 de Julio de 1.998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb180797.htm [01/03/2001 1:34:00]
11 de Julio Cómo enviar un fichero de Windows 95 a la papelera
Cómo enviar un fichero de Windows 95 a la papelera
Aplicable a las versiones 4.0/32 bits y 5.0
Las aplicaciones de 32-bit pueden llamar a la función SHFileOperation de la API de Windows para
enviar un fichero a la papelera de reciclaje de Windows95. El siguiente ejemplo muestra cómo utilizar
esta función y la instrucción ParamArray de VB:
Option Explicit
Private Type SHFILEOPSTRUCT
hWnd As Long
wFunc As Long
pFrom As String
pTo As String
fFlags As Integer
fAborted As Boolean
hNameMaps As Long
sProgress As String
End Type
Private Const FO_DELETE = &H3
Private Const FOF_ALLOWUNDO = &H40
Private Declare Function SHFileOperation _
Lib "shell32.dll" Alias _
"SHFileOperationA" _
(lpFileOp As SHFILEOPSTRUCT) As Long
Public Function BorrarFichero(ParamArray _
vntNombreFichero() As Variant) As Long
Dim I As Integer
Dim sNombreFicheros As String
Dim SHOpFichero As SHFILEOPSTRUCT
For I = LBound(vntNombreFichero) To _
UBound(vntNombreFichero)
sNombreFicheros = sNombreFicheros & _
vntNombreFichero(I) & vbNullChar
Next
sNombreFicheros = sNombreFicheros & vbNullChar
With SHOpFichero
.wFunc = FO_DELETE
.pFrom = sNombreFicheros
.fFlags = FOF_ALLOWUNDO
End With
BorrarFichero = _
SHFileOperation(SHOpFichero)
End Function
El argumento ParamArray permite pasar cualquier número de ficheros a la función:
' Borrado de un único fichero
http://www.microsoft.com/spain/support/trucos/Vbasic/vb110797.htm (1 de 2) [01/03/2001 1:34:10]
11 de Julio Cómo enviar un fichero de Windows 95 a la papelera
Resultado = BorrarFichero("BORRA.ME")
' Borrado de varios ficheros
Resultado = BorrarFichero("BORRA.ME", _
PRUEBA1.DOC", "PRUEBA2.TXT")
Última actualización: 11 de Julio de 1998
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb110797.htm (2 de 2) [01/03/2001 1:34:10]
4 Julio Cómo cambiar el tamaño de la caja de herramientas
Cómo cambiar el tamaño de la caja de herramientas
Aplicable hasta Microsoft Visual Basic 4.0 16 bits
En Visual Basic no existe la posibilidad de cambiar de tamaño la caja de herramientas ya que la ventana
no tiene borde.
Para solucionar este problema, existe un pequeño truco que consiste en situar la barra de herramientas
en la zona inferior o izquierda de la pantalla, de tal forma que sólo sean visibles dos o tres filas de
controles:
Al cerrar Visual Basic y volver abrirlo, automáticamente la barra de herramientas habrá cambiado de
tamaño y mostrará un aspecto similar al siguiente:
Última actualización: 4 de Julio de 1.997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb040797.htm [01/03/2001 1:34:36]
27 de Junio Preguntando al usuario por un directorio en Windows 95
Preguntando al usuario por un directorio en Windows 95
Los diálogos predeterminados de Windows95 (common dialogs) son adecuados para seleccionar
ficheros, pero ¿qué ocurre si se quiere seleccionar un directorio?. Lo que se debe hacer en este caso es
utilizar la función SHBrowseForFolder de la API de Windows de 32 bits:
Option Explicit
Private Type BrowseInfo
hWndOwner As Long
pIDLRoot As Long
pszDisplayName As Long
lpszTitle As Long
ulFlags As Long
lpfnCallback As Long
lParam As Long
Image As Long
End Type
Private Const BIF_RETURNONLYFSDIRS = 1
Private Const MAX_PATH = 260
Private Declare Sub CoTaskMemFree Lib _
"ole32.dll" (ByVal hMem As Long)
Private Declare Function _
lstrcat Lib "kernel32"_
Alias "lstrcatA" _
(ByVal lpString1 As String, _
ByVal lpString2 As String) As Long
Private Declare Function SHBrowseForFolder _
Lib "shell32" (lpbi As _
BrowseInfo) As Long
Private Declare Function _
SHGetPathFromIDList _
Lib "shell32" _
(ByVal pidList As Long, _
ByVal lpBuffer As String) As Long
Public Function _
ObtenerDirectorio(hWndPadre As _
Long, sTitulo As String) As String
Dim
Dim
Dim
Dim
Dim
iNull As Integer
lpIDLista As Long
lResultado As Long
sDirectorio As String
udtBI As BrowseInfo
With udtBI
.hWndOwner = hWndPadre
.lpszTitle = lstrcat(sTitulo, "")
http://www.microsoft.com/spain/support/trucos/Vbasic/vb270697.htm (1 de 2) [01/03/2001 1:34:49]
27 de Junio Preguntando al usuario por un directorio en Windows 95
.ulFlags = BIF_RETURNONLYFSDIRS
End With
lpIDLista = SHBrowseForFolder(udtBI)
If lpIDLista Then
sDirectorio = String$(MAX_PATH, 0)
lResultado = SHGetPathFromIDList _
(lpIDLista,Directorio)
Call CoTaskMemFree(lpIDLista)
iNull = InStr(sDirectorio, vbNullChar)
If iNull Then
sDirectorio = Left$(sDirectorio, iNull - 1)
End If
End If
ObtenerDirectorio = sDirectorio
End Function
Última actualización: 27 de Junio de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb270697.htm (2 de 2) [01/03/2001 1:34:49]
20 de Junio Cómo crear accesos directos -shortcuts- en Windows 95 desde Visual Basic
Cómo crear accesos directos -shortcuts- en Windows 95 desde Visual Basic
Aplicable a partir de Microsoft Visual Basic 4.0 32 bits
La librería STKIT432.DLL que Visual Basic 4.0 instala en el directorio SYSTEM de WINDOWS,
incluye la siguiente función para crear accesos directos en el menú inicio de Windows 95.
Declare Function fCreateShellLink Lib "STKIT432.DLL" _
(ByVal lpstrFolderName As String, _
ByVal lpstrLinkName As String, _
ByVal lpstrLinkPath As String, _
ByVal lpstrLinkArgs As String) As Long
Esta función se puede utilizar para crear un acceso directo en cualquier lugar del disco.
El primer parámetro de la función (lpstrFolderName) es relativo a la carpeta Programas del Menú de
Inicio. Esto quiere decir que si se pasa un cadena nula como primer parámetro, el acceso directo será
creado en la propia carpeta de Programas. De igual manera, se puede navegar desde la carpeta de
Programas a cualquier directorio del disco duro. Por ejemplo, el siguiente código creará un acceso
directo en el escritorio del usuario:
Resultado = fCreateShellLink _
("..\..\Escritorio", "Bloc de_
notas", "c:\windows\notepad.exe", "")
Última actualización: 20 de Junio de 1997
© 1998 Microsoft Corporation. Todos los Derechos Reservados. Aviso Legal
http://www.microsoft.com/spain/support/trucos/Vbasic/vb200697.htm [01/03/2001 1:35:01]
Descargar

TRUCOS DE MICROSOFT VISUAL BASIC