Mensajes recientes

Páginas: 1 2 3 [4] 5 6 ... 10
31
General / Citas
« Último mensaje por xavi en Mayo 07, 2020, 01:08:33 am »
"Siempre codifica como si el tipo que termina manteniendo tu código sea un psicópata violento que sabe dónde vives " .
"Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live."
- Martin Golding

"Tienen computadoras y pueden tener otras armas de destrucción masiva"
"They have computers, and they may have other weapons of mass destruction."

- Janet Reno

"Nunca atribuya a la malicia lo que se explica adecuadamente por la estupidez."
"Never attribute to malice that which is adequately explained by stupidity."

- Hanlon's Razor


"La tecnología está dominada por dos tipos de personas: los que entienden lo que no gestionan y los que gestionan lo que no entienden "
"Technology is dominated by two types of people: those who understand what they do not manage, and those who manage what they do not understand."

- Putt's Law


" No hay errores significativos en nuestro software lanzado que un número significativo de usuarios quiera solucionar " .
"There are no significant bugs in our released software that any significant number of users want fixed."

- Bill Gates


" Si el automóvil hubiera seguido el mismo desarrollo que la computadora, un Rolls-Royce costaría hoy $ 100, obtendría un millón de millas por galón y explotaría una vez al año matando a todos los que están dentro "
"If the automobile had followed the same development as the computer, a Rolls-Royce would today cost $100, get a million miles per gallon, and explode once a year killing everyone inside."

- Robert Cringely

32
Formularios / Propiedades etiqueta asociada a un control
« Último mensaje por xavi en Mayo 05, 2020, 03:36:22 pm »
Palabras clave: etiqueta, label, asociada, vinculada, control
Autor: xavi y Duane Hookom
Extraído de: experiencia propia y un ejemplo de UtterAccess muy antiguo

Objetivo:
Obtener propiedades de la etiqueta asociada a un control, por ejemplo, un cuadro de texto sabiendo el nombre del cuadro de texto.

La nueva versión 2019 incorpora una propiedad llamada "Nombre de etiqueta" que permite asociar una etiqueta existente a un control. Antes, como dice este artículo era necesario cortar la etiqueta, clicar el control y pegar la etiqueta. De esa forma se asociaban ambos controles.

El "problema" es acceder a la propiedad desde VBA.

Si investigamos nos encontramos que su nombre es LabelName. Pero resulta que, desde código, no aparece  ???

La forma de acceder es "indirecta": Me!nombrecontrol.Properties("LabelName")


Ahora bien... ¿y como acceder en versiones anteriores?
Esto lo he sacado de un ejemplo muy antiguo, del 2007, de UtterAccess. Pero el código es más antiguo aún: 1998. Autor: de Duane Hooko


Pues accediendo a la colección Controles del control. Si la cuenta de controles del control es superior a 0, el ítem 0 de la colección es la etiqueta. Referenciando ese control podemos acceder a sus propiedades.

Código: [Seleccionar]
' Asignamos el control
Set ctrl = Screen.ActiveControl
' Desactivamos momentáneamente el control de errores por si alguna propiedad fallara
On Error Resume Next
' Si el contador de controles del control es superior a 0
If ctrl.Controls.Count > 0 Then
  ' Tomamos el ítem 0 de la colección y accedemos a sus propiedades
  Debug.Print "Nombre: " & ctrl.Controls(0).Name
  Debug.Print "Caption: " & ctrl.Controls(0).Caption
End If
' Reactivamos el control de errores
On Error GoTo ErrorHandler
33
Consejos, técnicas, artículos / ¿Referenciar o no referenciar? Esa es la cuestión
« Último mensaje por xavi en Mayo 04, 2020, 10:12:43 am »
Palabras clave: librerías, bibliotecas, referencias, Object
Autor: xavi
Extraído de: experiencia propia

27/07/2022 ¡Actualizado!
Ver la nueva versión

Si bien se han publicado diferentes ejemplos sobre la forma de gestionar las referencias de nuestras aplicaciones, yo nunca he con seguido que funcionen. Para mi es complicado entender que, si un código no se ejecuta por referencias, el propio código *que no puede ejecutarse* lo pueda corregir. Así que presento la solución que yo he aplicado.

En mis aplicaciones es muy usual que se interactue con Excel por lo que, durante el desarrollo, es mucho más cómodo tener marcada la referencia de Excel para tener a mano los comandos con el IntelliSense  y las constantes.
El problema es la disparidad de versiones que Office que conviven y que los chicos de Microsoft han resuelto bastante bien la "subida" de referencias pero en absoluto la "bajada".
Tabla de versiones
200712.0
201014.0
201315.0
201616.0


En los siguientes escenarios se marca la referencia en desarrollo y no se desmarca al enviar la aplicación al cliente.

Escenario 1
Desarrollamos en Office 2013
Cliente dispone de Office 2013 o 2016

Al enviar nuestra aplicación al cliente, aquellos PC's con Office 2013 mantendrán la versión 15.0 de la librería; los que tuvieran 2016, "subirían" a 16.0

Escenario 2
Desarrollamos en Office 2016
Cliente dispone de Office 2013 o inferiores

Al enviar la aplicación al cliente, todos los PC's mantendrán la versión 16.0 y, como ninguno de ellos la tiene instalada, obtendremos un error y no podremos ejecutar la aplicación.

Caso especial
Aplicaciones desarrolladas en versiones antiguas (97, 2000) que tienen referencias a otras aplicaciones Office de esas versiones (8.0, 9.0) no son capaces de "subir" la versión cuando se ejecutan en, por ejemplo, una versión 2010.

Así pues, podemos tener un problema entre la comodidad de programar con las referencias y la distribución de las aplicaciones.

Dado que tener todas las versiones de las librerías de Office  se antoja complicado, la solución pasa por entregar la aplicación sin las referencias de Office. Para cambiar a trabajar sin referencias es necesario cambiar nuestra táctica de declaración. Lo que hasta ahora declarábamos como Excel.Application habrá que declararlo como Object. Ello nos privará del IntelliSense y del acceso a las constantes específicas de la aplicación Office que queramos utilizar.

¿Como solucionamos eso? Expongo mi técnica.

Supongo que todos sabemos como funcionan las directivas de compilador (aquí faltaría un link) por lo que nos podemos apoyar en ellas para crear nuestra propia directiva.

En un módulo independiente definimos nuestras propias constantes a modo de directiva:

' Constante de utilización de librerías de Office
#Const UseOL_XLS = False
#Const UseOL_OLK = False


A continuación ponemos una directiva:

#If UseOL_XLS Then
  Public xlsApp As Excel.Application
#Else
  Public xlsApp As Object
#End If


Nota: desde este momento yo dejo de declarar xlsApp cada vez que lo necesito. Habitualmente solo trabajo con un fichero de Excel por que lo que puedo utilizar una variable Public. En caso de necesitar declarar en un procedimiento específico otra instancia de Excel utilizaría la misma técnica:

#If UseOL_XLS Then
  Dim xlsAppOtro As Excel.Application
#Else
  Dim xlsAppOtro As Object
#End If


Durante el desarrollo marco la referencia de Excel y cambio la constante UseOL_XLS a True para poder acceder a los métodos y constantes de Excel.

¿Y las constantes específicas de la otra aplicación?
Pues para las constantes hay que ir manteniendo una lista en la zona #Else de manera que, cuando no tengamos marcada la librería, siga funcionando.

Ejemplos de constantes:

    Public Const xlVeryHidden = 2
    Public Const xlPrintNoComments = -4142
    Public Const xlLandscape = 2
    Public Const xlAutomatic = -4105
    Public Const xlDownThenOver = 1
    Public Const xlPrintErrorsDisplayed = 0
    Public Const xlDown = -4121
    Public Const xlUp = -4162
    Public Const xlLeft = -4159
    Public Const xlRight = -4161
    Public Const xlCenter = -4108
    Public Const xlBottom = -4107
    Public Const xlToLeft = -4159
    Public Const xlToRight = -4161
    Public Const xlEdgeLeft = 7
    Public Const xlEdgeTop = 8
    Public Const xlEdgeBottom = 9
    Public Const xlEdgeRight = 10
    Public Const xlInsideVertical = 11
    Public Const xlInsideHorizontal = 12
    Public Const xlContinuous = 1
    Public Const xlColorIndexAutomatic = -4105
    Public Const xlHairline = 1
    Public Const xlMedium = -4138
    Public Const xlThick = 4
    Public Const xlThin = 2
   

La precaución que debemos tener a la hora de programar es la de añadir cualquier nueva constante que utilicemos.

¿Y a la hora de distribuir?
Sencillo.
- Quitar la referencia de Excel
- Cambiar la constante UseOL_XLS a False
- Compilar por si me hubiera dejado alguna constante no definida o alguna "cosa rara" en cuyo caso lo corregiría

Con esta forma de trabajar me he ahorrado tener un montón de "dobles declaraciones" y estar poniendo/quitando la adecuada:

Dim xlsApp As Excel.Application
'Dim xlsApp As Object

Truco:¿Como mantengo mi lista de #constantes?
Yo lo tengo en un módulo independiente dónde, en el encabezado, consta la versión del módulo. Cada vez que añado una constante lo registro en el log de cambios y subo el número de versión. El módulo lo exporto a una determinada carpeta. Además llevo un registro de versiones de todos los módulos en un Excel.

Cuando debo actualizar una aplicación, lo primero es revisar las versiones de los módulos por si tuviera versiones más actuales. Si el módulo de directivas de mi archivo es más moderno del de la aplicación, simplemente importo el nuevo módulo.

Espero que os sirva para "salvar" el problema de las referencias.
34
Formularios / Crear menú flotante
« Último mensaje por xavi en Mayo 02, 2020, 05:08:16 pm »
Palabras clave: formulario, menú, API
Autor: Candace Tripp
Extraído de: Utter Access (allá por 2007)

Objetivo:
Crear un menú flotante en el formulario.

Utilizamos un formulario con 3 botones (el ejemplo original utiliza 3 botones transparentes encima de 3 etiquetas pero se puede hacer con botones de fondo transparente)
En el módulo de clase del ejemplo las opciones se definen "a pedal". Se podría trabajar con una tabla que llame a funciones (a estudiar)

El código del formulario es este:

Código: [Seleccionar]
Option Compare Database
Option Explicit

Dim oMenu As cMenu

Private Sub mnuFile_Click()
    oMenu.ShowMenu "File"
End Sub

Private Sub mnuEdit_Click()
    oMenu.ShowMenu "Edit"
End Sub

Private Sub mnuHelp_Click()
    oMenu.ShowMenu "About"
End Sub

Private Sub Form_Load()
   
    Set oMenu = New cMenu
    Set oMenu.CurrentForm = Me

End Sub

Después tenemos un módulo de clase como este:

Código: [Seleccionar]
Option Compare Database
Option Explicit
'######################################################################
'
'CLASSNAME      :   cMenu
'
'PURPOSE        :   Class to emulate a drop down menu using API calls
'
'DATE CREATED   :   2/2/2005
'
'AUTHOR         :   Candace Tripp
'                   http://www.candace-tripp.com/
'
'NOTE           :   This API calls/code is a modification of Bryan Stafford's
'                   popup menu demo project written in Visual Basic 6.
'                   This demo is released into the public domain "as is" without
'                   warranty or guaranty of any kind.  In other words, use at your own risk.
'                   His comments are below
'
'MODIFICATIONS:
'   DATE        MODIFIED BY     MODIFICATION DESCRIPTION
'   ----        -----------     -----------------------------------------
'
'######################################################################

'Bryan Stafford of New Vision Software
'######################################################################
' demo project showing how to use the API menu functions to create a
' popup menu. by Bryan Stafford of New Vision Software - newvision@mvps.org
' this demo is released into the public domain "as is" without warranty or
' guaranty of any kind.  In other words, use at your own risk.


' the handles to our popup menus.  we keep them at the module level so that
' we don't have to recreate the menus each time we want to display them.
'######################################################################
 
    Private m_CurrentForm As Form
    Private m_lngItemWidth As Long
    Private m_lngItemTop As Long
   
    Private m_hMenu(3) As Long
    Private m_hSubMenu(3) As Long
   
    Private Type POINTAPI
        X As Long
        Y As Long
    End Type
   
    Private Const MF_INSERT As Long = &H0&
    Private Const MF_CHANGE As Long = &H80&
    Private Const MF_APPEND As Long = &H100&
    Private Const MF_DELETE As Long = &H200&
    Private Const MF_REMOVE As Long = &H1000&
    Private Const MF_BYCOMMAND As Long = &H0&
    Private Const MF_BYPOSITION As Long = &H400&
    Private Const MF_SEPARATOR As Long = &H800&
    Private Const MF_ENABLED As Long = &H0&
    Private Const MF_GRAYED As Long = &H1&
    Private Const MF_DISABLED As Long = &H2&
    Private Const MF_UNCHECKED As Long = &H0&
    Private Const MF_CHECKED As Long = &H8&
    Private Const MF_USECHECKBITMAPS As Long = &H200&
    Private Const MF_STRING As Long = &H0&
    Private Const MF_BITMAP As Long = &H4&
    Private Const MF_OWNERDRAW As Long = &H100&
    Private Const MF_POPUP As Long = &H10&
    Private Const MF_MENUBARBREAK As Long = &H20&
    Private Const MF_MENUBREAK As Long = &H40&
    Private Const MF_UNHILITE As Long = &H0&
    Private Const MF_HILITE As Long = &H80&
    Private Const MF_SYSMENU As Long = &H2000&
    Private Const MF_HELP As Long = &H4000&
    Private Const MF_MOUSESELECT As Long = &H8000&
   
   
    Private Const TPM_RETURNCMD As Long = &H100&
   
   
    Private Const ID_BEEP As Long = &H6000&
    Private Const ID_SEPARATOR As Long = &H6001&
    Private Const ID_DISABLED As Long = &H6002&
    Private Const ID_MSGBOX As Long = &H6003&
   
    Private Const ID_ADD As Long = &H6004&
    Private Const ID_EDIT As Long = &H6005&
    Private Const ID_DELETE As Long = &H6006&
    Private Const ID_EXIT As Long = &H6007&
    Private Const ID_HELP As Long = &H6008&
   
    Private Declare Function CreatePopupMenu Lib "user32" () As Long
    Private Declare Function DestroyMenu Lib "user32" (ByVal hMenu&) As Long
    Private Declare Function AppendMenu Lib "user32" Alias "AppendMenuA" (ByVal hMenu&, ByVal wFlags&, ByVal wIDNewItem&, ByVal lpNewItem$) As Long
    Private Declare Function ClientToScreen& Lib "user32" (ByVal hwnd&, lpPoint As POINTAPI)
    Private Declare Function TrackPopupMenu Lib "user32" (ByVal hMenu&, ByVal wFlags&, ByVal X&, ByVal Y&, ByVal nReserved&, ByVal hwnd&, ByVal lpRect&) As Long
    Private Declare Function EnableMenuItem Lib "user32" (ByVal hMenu&, ByVal wIDEnableItem&, ByVal wEnable&) As Long
   
'PROPERTIES ###########################################################
Public Property Set CurrentForm(frmCurrent As Form)
    Set m_CurrentForm = frmCurrent
End Property
Public Property Get CurrentForm() As Form
On Error Resume Next
    If IsObject(m_CurrentForm) Then
        Set CurrentForm = m_CurrentForm
    End If
End Property


Public Property Let ItemTop(lngValue As Long)
    m_lngItemTop = lngValue
End Property
Public Property Get ItemTop() As Long
    ItemTop = m_lngItemTop
End Property


Public Property Let ItemWidth(lngValue As Long)
    m_lngItemWidth = lngValue
End Property
Public Property Get ItemWidth() As Long
    ItemWidth = m_lngItemWidth
End Property
'END PROPERTIES #######################################################

'METHODS ##############################################################
Public Sub ShowMenu(strMenuName As String)
    Dim intItem As Integer
    Select Case strMenuName
    Case "File"
        intItem = 0
    Case "Edit"
        intItem = 1
    Case Else '"About"
        intItem = 2
    End Select
   
    DisplayPopupMenu intItem, ItemWidth * intItem, ItemTop
End Sub
'END METHODS ##########################################################

'######################################################################
Private Sub Class_Initialize()
    ' defaults
    m_lngItemWidth = 64
    m_lngItemTop = 19
End Sub

Private Sub Class_Terminate()
On Error Resume Next

    Dim intItem1 As Integer
    Dim intItem2 As Integer
   
    For intItem1 = 0 To UBound(m_hMenu) - 1
        If m_hMenu(intItem1) Then
            Call DestroyMenu(m_hMenu(intItem1))
        End If
    Next intItem1
   
    For intItem2 = 0 To UBound(m_hSubMenu) - 1
        If m_hSubMenu(intItem2) Then
            Call DestroyMenu(m_hSubMenu(intItem2))
        End If
    Next intItem2
End Sub
'######################################################################

'######################################################################
Private Sub DisplayPopupMenu(intItem As Integer, ByVal X&, ByVal Y&)

    Dim pt As POINTAPI
    Dim lngReturn As Long
     
    ' if the menu hasn't already been created, create it....
    If m_hMenu(intItem) = 0 Then
        Select Case intItem
        Case 0 ' File
            m_hMenu(intItem) = CreatePopupMenu()
           
            ' add an item....
            Call AppendMenu(m_hMenu(intItem), MF_STRING, ID_BEEP, ByVal "Sound A ""Beep""")
           
            ' add a separator....
            Call AppendMenu(m_hMenu(intItem), MF_STRING Or MF_SEPARATOR, ID_SEPARATOR, ByVal vbNullString)
           
            ' add another item....
            Call AppendMenu(m_hMenu(intItem), MF_STRING, ID_DISABLED, ByVal "A Disabled Item")
            ' disable the last item we added....
            Call EnableMenuItem(m_hMenu(intItem), ID_DISABLED, MF_BYCOMMAND Or MF_DISABLED Or MF_GRAYED)
           
            ' add the next item....
            Call AppendMenu(m_hMenu(intItem), MF_STRING, ID_MSGBOX, ByVal "Display A MessageBox")
       
            ' add a separator....
            Call AppendMenu(m_hMenu(intItem), MF_STRING Or MF_SEPARATOR, ID_SEPARATOR, ByVal vbNullString)
       
            ' add the last item....
            Call AppendMenu(m_hMenu(intItem), MF_STRING, ID_EXIT, ByVal "Exit")
        Case 1 ' Edit
             ' first create our sub menu....
            m_hSubMenu(intItem) = CreatePopupMenu()
       
            ' add a couple of items to the sub menu....
            Call AppendMenu(m_hSubMenu(intItem), MF_STRING, ID_ADD, ByVal "Add")
            Call AppendMenu(m_hSubMenu(intItem), MF_STRING, ID_EDIT, ByVal "Edit")
            Call AppendMenu(m_hSubMenu(intItem), MF_STRING, ID_DELETE, ByVal "Delete")
           
            m_hMenu(intItem) = CreatePopupMenu()
           
            ' add the item to which we attach the sub menu....
            Call AppendMenu(m_hMenu(intItem), MF_STRING Or MF_POPUP, m_hSubMenu(intItem), ByVal "Edit")
           
        Case Else ' About
           
            m_hMenu(intItem) = CreatePopupMenu()
           
            ' add an item....
            Call AppendMenu(m_hMenu(intItem), MF_STRING, ID_HELP, ByVal "Help")
           
            ' add a separator....
            Call AppendMenu(m_hMenu(intItem), MF_STRING Or MF_SEPARATOR, ID_SEPARATOR, ByVal vbNullString)
           
            ' add the last item....
            Call AppendMenu(m_hMenu(intItem), MF_STRING, ID_MSGBOX, ByVal "About")
        End Select
       
    End If
   
   
    With pt  ' the x & y position where you want the menu displayed
        .X = X
        .Y = Y
       
        ' translate to screen coordinates
        Call ClientToScreen(CurrentForm.hwnd, pt)
       
        ' call the api function to display the menu and check the return value
        lngReturn = TrackPopupMenu(m_hMenu(intItem), TPM_RETURNCMD, .X, .Y, 0&, CurrentForm.hwnd, 0&)
       
        Call MenuAction(lngReturn)
       
    End With
   
End Sub


Private Sub MenuAction(lngReturn As Long)
On Error Resume Next

    Select Case lngReturn
        Case ID_BEEP
            Beep
       
        Case ID_MSGBOX
            MsgBox "Form with Menu created by Candace Tripp" & vbCrLf & "http://www.candace-tripp.com/", vbInformation
       
        Case ID_ADD
            MsgBox "You chose ""Add"".", vbExclamation
       
        Case ID_EDIT
            MsgBox "You chose ""Edit"".", vbExclamation
       
        Case ID_DELETE
            MsgBox "You chose ""Delete"".", vbExclamation
       
        Case ID_HELP
            SendKeys "{F1}"
           
        Case ID_EXIT
            DoCmd.Close acForm, CurrentForm.Name, acSavePrompt
               
        End Select

End Sub
'######################################################################





35
Formularios / Recuperar última posición en formulario
« Último mensaje por xavi en Mayo 02, 2020, 04:43:32 pm »
Palabras clave: guardar, almacenar, recordar, última, posición, registro
Autor: ¿?
Extraído de: Utter Access (allá por 2007)

Objetivo:
La idea es almacenar la última posición del usuario al entrar en un formulario. Sirve para tipo Lista o tipo Ficha. Requiere de varias acciones.

1. Tener una tabla de posiciones (puede ser local ya que es del propio usuario)
2. Las tablas deben tener un campo ID único.
3. En el formulario, asignar una función a todos los controles del registro para el evento "Al recibir enfoque". Esa función almacena en memoria el registro y el campo enfocado.
4. En el evento Close, se almacena:
  - Formulario
  - Id del registro
  - Último campo enfocado
  - Usuario (redundante si es local)
  - Momento
  El almacenado de los datos puede ser acumulativo (nuevo registro por lo que Momento es relevante) o sustitutivo (editar el registro para combinación de formulario-usuario por lo que Momento es irrelevante)

En el momento de abrir el formulario, abrir un recordset o utilizar un Dlookup para recuperar el ID de la combinación formulario-usuario (si es acumulativo, incluir Momento en la "ecuación")
Mediante Bookmarks, posicionar el registro. Algo así:


Código: [Seleccionar]
Private Sub GoToLastSavedPosition()
    Dim strSQL           As String
    Dim rstFormPositions As DAO.Recordset
   
    strSQL = " SELECT Last(tblFormPositions.LastRecordID) AS LastOfLastRecordID," & _
                    " Last(tblFormPositions.LastActiveControl) AS LastOfLastActiveControl," & _
                    " Max(tblFormPositions.LastTimeSaved) AS MaxOfLastTimeSaved" & _
             " FROM tblFormPositions" & _
             " GROUP BY tblFormPositions.FormName," & _
                      " tblFormPositions.LastUser" & _
             " HAVING tblFormPositions.FormName = " & Chr$(34) & Me.Name & Chr$(34) & _
             " AND tblFormPositions.LastUser = " & Chr$(34) & CurrentUser() & Chr$(34)

    Set rstFormPositions = CurrentDb.OpenRecordset(strSQL, dbOpenDynaset)
   
    With rstFormPositions
        If .RecordCount <> 0 Then
            If !LastOfLastRecordID <> 0 And Not IsNull(!LastOfLastActiveControl) Then
                Me.RecordsetClone.FindFirst "[ID] = " & !LastOfLastRecordID
                Me.Bookmark = Me.RecordsetClone.Bookmark
                Me(!LastOfLastActiveControl).SetFocus
            End If
        End If
        .Close
    End With
   
    Set rstFormPositions = Nothing
   
End Sub
El ejemplo original lanza ese código en el Form_Timer del formulario (Intervalo = 1) con este códig:

Código: [Seleccionar]
Private Sub Form_Timer()
    Static blnFormOpen As Boolean
   
    If Not blnFormOpen Then
        blnFormOpen = True
        Me.TimerInterval = 0
       
        GoToLastSavedPosition
    End If
   
End Sub
36
Consejos, técnicas, artículos / Localizar error. Número de línea
« Último mensaje por xavi en Abril 28, 2020, 01:38:10 pm »
Palabras clave: control errores, línea
Autor: xavi
Extraído de: experiencia

Objetivo:
Localizar la línea del error exacta.

En nuestras aplicaciones a veces es necesario no solo controlar el error y devolver la respuesta adecuada. En algunos casos podemos recibir el "feedback" de un cliente con un error pero no es posible saber cual de las líneas de código ha sido la que ha generado el error.

En desarrollo, dentro de mi control de errores, ya está preparado para que, en caso de error, el código de pare (Stop) y a continuación vaya a la línea del error (Resume). El problema es en el cliente dónde no interesa mostrar ciertas cosas. En ese caso estaría bien poder recuperar la línea del error y que el cliente nos la comunicara.

¿Y cómo se obtiene la línea de error?
Pues ("back to the past") ¡numerando las líneas! y recuperando el número de línea con la propiedad Erl.
Algunos no lo habréis visto nunca y otros no numeran una línea desde que dejaron GWBasic.

¿Y cómo numero las lineas? Porque mi aplicación tiene miles de líneas...
La mejor forma si no quieres dejarte las uñas en el teclado es utilizar una herramienta externa: MZ-Tools

Esa herramienta permite poner y quitar números de línea de forma muy sencilla. El alcance de esa utilidad es el que nosotros queramos: desde un procedimiento hasta un grupo de proyectos.

¿Y cuando hago eso?
Pues yo lo haría justo antes de entregar la aplicación al cliente.

¿Es cómodo trabajar con números de línea puestos?
La verdad es que es un engorro porque cualquier nueva línea deberá tener su número. Lo mejor es quitar todos los números de línea del proyecto cuando se tenga que editar el código, modificar y volver a poner números de línea. Dado que los números de línea sólo sirven para la propiedad Erl, no debería representar un problema (a diferencia del pasado dónde los GoTo se hacían por número de línea).

¿Cómo utilizo Erl?
Muy sencillo. Dentro del control de errores, la propiedad Erl devuelve el número de línea. Si no hay números de línea, devuelve 0.

MsgBox "Error en línea: " & Erl & vbNewLIne & Err.Number & " - " & Err.Description

Dicho todo esto, yo nunca he numerado líneas  8)
37
WSH / Nombre del PC
« Último mensaje por xavi en Abril 28, 2020, 01:13:19 pm »
Palabras clave: nombre, ordenador, PC
Autor: ¿?
Extraído de: ¿?

Objetivo:
Obtener el nombre del PC dónde se ejecuta el código.

Alternativa a Environ("ComputerName")

Código: [Seleccionar]
Function DamePC() As String
  Set ObjetoRed = CreateObject("WScript.Network")
  DamePC = ObjetoRed.ComputerName
  Set ObjetoRed = Nothing
End Function

38
Varias / Sin tildes
« Último mensaje por xavi en Abril 23, 2020, 12:58:52 am »
Palabras clave: tildes, acentos, limpiar
Autor: Xavi
Extraído de: Experiencia propia

Intentando generalizar una función que me permita convertir cualquier texto con acentos a otro sin acentos y añadiendo la capacidad de poder incluir niveles de restricción de caracteres especiales, ha salido esta función.

Debe copiarse en un módulo independiente.

A la hora de utilizarse se debe pasar la cadena a convertir.
Opcionalmente se indica el nivel de restricción de los especiales. Por defecto es Libre lo que devolverá todos los caracteres especiales y únicamente sustituirá los caracteres acentuados.
Si se utiliza el nivel de restricción 1 (restringido), debe indicarse la cadena de caracteres prohibidos. Si no se indica el sistema propone una colección.
Si se utiliza el nivel de restricción 3 (Estricto) la cadena de respuesta solo permitirá letras mayúsculas, letras minúsculas, números y espacios.

La función puede ampliar los caracteres acentuados. Solo es necesario añadir los caracteres adecuados a las cadenas strConAcentos y strSinAcentos.


Código: [Seleccionar]
Public Enum eUtl_TildesRestriccion
    Libre = 0
    Restringido = 1
    Estricto = 2
End Enum

Function SinTildesEvo(strText As String, Optional intSinEspeciales As eUtl_TildesRestriccion = 0, Optional strEspeciales As String = ".,:;()-&%!?¡¿ºª*çÇ@_·)$") As String
   
    On Error GoTo ErrorHandler

    Dim strConAcentos   As String
    Dim strSinAcentos   As String
    Dim c               As Integer
    Dim strChar         As String
    Dim intPos          As Integer
    Dim strLimpia1      As String
    Dim strLimpia2      As String
   
    strConAcentos = "áàäâéèëêíìïîóòöôúùüûÁÀÄÂÉÈËÊÍÌÏÎÓÒÖÔÚÙÜÛ"
    strSinAcentos = "aaaaeeeeiiiioooouuuuAAAAEEEEIIIIOOOOUUUU"
   
    ' Recorremos el texto pasado como argumento
    For c = 1 To Len(strText)
        ' Obtenemos el carácter a evaluar
        strChar = Mid(strText, c, 1)
        ' Miramos si existe en la cadena de caracteres acentuados
        intPos = InStr(1, strConAcentos, strChar, vbBinaryCompare)
        If intPos > 0 Then
            ' Al existir sustituimos
            strLimpia1 = strLimpia1 & Mid(strSinAcentos, intPos, 1)
        Else
            ' Al no existir lo aceptamos
            strLimpia1 = strLimpia1 & strChar
        End If
    Next
   
    ' Evaluamos si se quitan los especiales
    Select Case intSinEspeciales
        Case eUtl_TildesRestriccion.Libre  ' Sin restricción: no se obvia ningún caracter especial
            ' Igualamos cadenas
            strLimpia2 = strLimpia1
        Case eUtl_TildesRestriccion.Restringido  ' Restrictivo:solo los de la lista
            ' Recorremos la cadena
            For c = 1 To Len(strLimpia1)
                ' Obtenemos el caracter a evaluar
                strChar = Mid(strLimpia1, c, 1)
                ' Miramos si existe en la cadena de caracteres especiales
                intPos = InStr(1, strEspeciales, strChar, vbBinaryCompare)
                If intPos = 0 Then
                    ' Al no existir podemos  añadir el caracter
                    strLimpia2 = strLimpia2 & strChar
                End If
            Next
        Case eUtl_TildesRestriccion.Estricto  ' Ultrarestrictivo: ningun caractrer que no sea letra, numero o espacio
            For c = 1 To Len(strLimpia1)
                strChar = Mid(strLimpia1, c, 1)
                Select Case Asc(strChar)
                    Case 48 To 57, 65 To 90, 97 To 122, 32
                        strLimpia2 = strLimpia2 & strChar
                End Select
            Next
    End Select
   
    SinTildesEvo = strLimpia2


ExitProcedure:
    On Error GoTo 0
    Exit Function
ErrorHandler:
    Select Case Err.Number
        Case 0
        Case Else
            MsgBox "Error " & Err.Number & " - " & Err.Description
            Resume ExitProcedure
    End Select
End Function

39
Consejos, técnicas, artículos / Sintaxis para subformularios
« Último mensaje por xavi en Abril 21, 2020, 07:21:07 pm »
Documento posteado varias veces por diferentes personas pero que parece ser que el autor original es Keri Hardwick


Sintaxis para subformularios
40
FSO / Saber si un directorio existe
« Último mensaje por xavi en Abril 21, 2020, 04:08:17 pm »
Palabras clave: FSO, averiguar, saber, directorio, folder, carpeta
Autor: Xavi
Extraído de: Centro de desarrollo de Office

Objetivo
Averiguar si un directorio existe mediante FSO. Es la alternativa a Dir(strFolder, vbDirectory)

Código: [Seleccionar]
Public Function ExistsFolder(strFolder As String) As Boolean
    Dim fso As Object
   
    Set fso = CreateObject("Scripting.FileSystemObject")
   
    On Error Resume Next
    If fso.FolderExists(strFolder) = False Then
        ExistsFolder = False
    Else
        ExistsFolder = True
    End If
   
    If Err <> 0 Then
        ExistsFolder = False
    End If
   
    Set fso = Nothing
       
End Function

Páginas: 1 2 3 [4] 5 6 ... 10