Après avoir parlé dans un billet précédent de la persistance dans un fichier ini, nous allons poursuivre sur la technique de la base de registre.

Écrire dans la base de registre apporte, contrairement au fichier ini, un semblant de sécurité. En effet il est moins aisé de retrouver une valeur parmi les milliers existantes dans la base de registre que de consulter un fichier ini. La destination n’est donc pas la même.

Quels sont les moyens à notre disposition ?

Grâce à la bibliothèque Windows Script Host que l’on retrouve dans les références sous le nom de Microsoft Scripting Runtime on peut invoquer différentes commandes de gestion de la base de registre.

Déclaration

Dim wsh As Object 
Set wsh = CreateObject("WScript.Shell") 
... instructions 
Set wsh = Nothing

La déclaration de cette bibliothèque peut se faire en early ou late binding (cf Early ou LateBinding). C’est la deuxième méthode que nous allons utiliser ici.

Le modèle est toujours le même, déclaration, instanciation, utilisation, libération.

Lecture

Pour la lecture on utilise l’instruction RegRead en précisant le chemin de la clef à lire.

Chemin = wsh.RegRead("HKEY_CURRENT_USER\Software\Microsoft\Office\" & _ 
      Val(SysCmd(acSysCmdAccessVer)) & ".0\Access\Security\" & _ 
      "Trusted Locations\mon application\Path"

En retour la fonction renvoi le contenu de la clef. Dans cet exemple on interroge la base de registre pour connaître l’emplacement approuvé pour « mon application ».

Ecriture

De la même manière on peut écrire une valeur ou créer une clef à l’aide de l’instruction RegWrite.

wsh.RegWrite "HKEY_CURRENT_USER\Software\Microsoft\Office\" & _
       Val(SysCmd(acSysCmdAccessVer)) & ".0\Access\Security\" & _ 
       "Trusted Locations\" & vNameProduit & "\Path", _ 
       "c:\application access\mon application"

Le premier paramètre est le chemin de la clef de registre et le second la valeur à écrire.

Si la clef (le chemin) n’existe pas, elle est créée.

Conclusion

Comme nous l’avons vu rien de sorcier dans l’utilisation de ces instructions. Par contre il est fortement conseillé d’avoir les bases de connaissances minimales de ce qu’est la base de registre. En effet, si la manipulation d’un fichier ini (cf Access et la persistance (1)) pour gérer de la persistance n’est pas critique, manipuler la base de registre l’est sans aucun doute. Prenez les précautions d’usage avant la manipuler.

Nous sommes conscient que la séparation des données et de l’ihm est primordiale pour une application MS Access. L’attachement automatique est depuis de nombreuses années rentré dans les mœurs, chaque développeur utilise le sien.

Si au moment de l’installation, il est obligatoire de spécifier le chemin du fichier de données, lors des mises à jour de l’application cela peut agacer l’utilisateur. Surtout si elles sont régulières. On se doit alors d’utiliser la persistance pour sauvegarder ces paramètres.

Comment créer de la persistance pour les paramètres d’une application ?

En fait il n’y a pas une, mais plusieurs méthodes pour stocker ses valeurs de configuration. La première utilise les fichiers ini. Ce sont des fichiers texte qui ont une structure particulière dont voici un exemple :

[Etiquette1] 
parametre1=Valeur 
parametre2=Valeur 

[Etiquette2] 
parametre1=Valeur

Lire et écrire dans un fichier ini

Lire et écrire dans ce type de fichier ne constitue pas une grosse difficulté puisque Windows possède ces 2 fonctions dans l’API Kernel32.

Je vous livre ici ces 2 fonctions implémentées en VBA qui permettent de gérer un fichier ini dans le répertoire de l’application.

Private Declare Function GetPrivateProfileString Lib "kernel32" _ 
                Alias "GetPrivateProfileStringA" _ 
               (ByVal lpApplicationName As String, _ 
                ByVal lpKeyName As Any, ByVal lpDefault As String, _ 
                ByVal lpReturnedString As String, _ 
                ByVal nSize As Long, _ 
                ByVal lpFileName As String) As Long 

Private Declare Function WritePrivateProfileString Lib _ 
                "kernel32" Alias "WritePrivateProfileStringA" _ 
               (ByVal lpApplicationName As String, _ 
                ByVal lpKeyName As Any, ByVal lpString As Any, _ 
                ByVal lpFileName As String) As Long 

Const vgInifile = "monapplication.ini" 

Function pIniLireParametre(vlEntete As String, _ 
         vlNomParametre As String) As String '---------------------------------------------------------------- 
' Procedure : pIniLireParametre 
' Description : renvoi un paramètre depuis un fichier ini 
' spécifié par vgIniFile 
' Parameters : vlNomParametre est le nom du paramètre à renvoyer 
' Return : le paramètre correspondant à vlNomParametre '---------------------------------------------------------------- 

On Error GoTo Errsub 

Dim vParam As String, vlLong As Long 

vParam = String(255, 0) 
vlLong = GetPrivateProfileString(vlEntete, vlNomParametre, _ 
         "", vParam, 255, CurrentProject.Path & "\" & vgInifile) 

If vlLong <> 0 Then vParam = Left$(vParam, vlLong) 

pIniLireParametre = RTrim(vParam) 
Exit Function 

Errsub: pIniLireParametre = "" 

End Function 

Function pIniEcrireParametre(vlEntete As String, _ 
         vlNomParametre As String, _ 
         vlValeurParametre As String) As Boolean '-------------------------------------------------------------- 
' Procedure : pIniEcrireParametre 
' Description : remplace le paramètre dans un fichier ini spécifié 
' Parameters : vlEntete est l'entête de la rubrique [] 
' vlNomParametre est le nom du paramètre 
' vlValeurParametre est la valeur du paramètre ' Return : N/A '-------------------------------------------------------------- ' 
On Error GoTo Errsub 
    pIniEcrireParametre = True 
    WritePrivateProfileString vlEntete, vlNomParametre, vlValeurParametre, _ 
          CurrentProject.Path & "\" & vgInifile 

Exit Function 

Errsub: 
pIniEcrireParametre = False 

End Function

Mise en œuvre de la persistance

Admettons un fichier Ini comportant plusieurs paramètres dont celui indiquant le répertoire du fichier de données.

[Donnees] 
CheminData=C:\Donnees\ApplicationData\data.accdb

La lecture se fera via l’instruction suivante :

vFichierData = pIniLireParametre("Donnees", "CheminData")

Il sera alors très simple de vérifier le chemin fourni et celui des tables attachées.

Pour écrire le paramètre on utilise cette instruction lors de la première installation :

pIniEcrireParametre "Donnees", "CheminData", _ 
         "c:\Donnees\ApplicationData\data.accdb"

Conclusion

En quelques commandes vous avez donné de la persistance à votre application et apporter un sérieux gain de confort à l’utilisateur.

Autant la sélection automatique d’un item dans une liste modifiable est facile grâce à une simple affectation, autant avec une liste classique c’est plus compliqué.

Je vous livre l’astuce consistant à mettre un peu de code dans une liste déroulante reprenant les valeurs de la liste.

Dans l’événement Après MAJ de la liste déroulante ou d’une zone de texte mettre le code VBA ci-dessous :

Dim i As Long 
Dim i_save As Long  
Me.lstMultiple.Selected(0) = True    'désélection de la liste multiple 

For i = 1 To Me.lstMultiple.ListCount - 1  'parcours la liste multiple    Me.lstMultiple.Selected(i) = False      'déselection de l'élement courant   
   If (Me.lstMultiple.ItemData(i) = CStr(Nz(Me.lstRecherche, ""))) Then   
      's'il est identique à ce que je cherche        
      i_save = i  'je repère la ligne     
   End If 
Next 
Me.lstMultiple.Selected(i_save) = True  'en sortant je sélectionne la liste

lstMultiple est la liste classique et lstRecherche est la liste modifiable ou la zone de texte ou vous sélectionnez la valeur à trouver.

L’astuce consiste à parcourir la liste à la recherche de la valeur, d’en capter l’indice de la ligne pour l’affecter à cette même liste.

Bonne utilisation !

Cette fois-ci je vous livre l’une de mes astuces que j’utilise systématiquement dans toutes mes applications : Afficher/Cacher le ruban à la demande.

La méthode est simple, une variable globale permet de fixer l’état du ruban. Un raccourci dans une macro Autokey permet de changer l’état du ruban et une fonction VBA affiche ou cache le ruban suivant l’état de la variable.

Option Compare Database 
Option Explicit 

Dim StateRibbon As Boolean 

Function DisplayRibbon() 
' Auteur : Fabrice CONSTANS (MVP) 
' Description : Affiche/cache le ruban 
' ctrl+shift+R 
Nz StateRibbon, False  
' 1er passage initialise à faux 
' (ribbon invisible) 
DoCmd.ShowToolbar "Ribbon", IIf(StateRibbon, acToolbarNo, acToolbarYes) 
StateRibbon = Not StateRibbon  ' inverse la valeur 

End Function

Le raccourci :

+^{R}  ExecuterCode DisplayRibbon()

Cacher le ruban permet de cacher également les boutons Restaurer/ Fermer ce qui donne une touche professionnelle à l’application.

Bonne utilisation !

Dans la rubrique d’assistance à la maintenance d’application voici un bout de code à coupler à une macro  AutoKeys.

Lorsque vous devez intervenir sur une vieille application ou une application volumineuse, ce code vous rendra le service de ne pas avoir à chercher le formulaire et le contrôle actif parmi les multitudes de bibliothèques et de formulaires ou états. Cerise sur le gâteau si vous ouvrez l’éditeur VBA vous serez automatiquement positionné sur son module.

Son fonctionnement est simple ; Il repère le nom retourné par Screen.Activeform et Screen. Activecontrole et essaye de trouver le code dans le VBE components.

Function msgNameBase() 
' Auteur : Fabrice CONSTANS MVP 
' Description : renvoie le nom : de l'objet, de la base pour l'objet 
' actif 
On Error GoTo Err_msgNomBase 

Dim strNomBase As String 
Dim sCurfrm As String, sExt As String 
Dim sCurControle As String 
Dim i As Integer 

sExt = "form_" ' c'est un formulaire par défaut. 
' recupère le nom du forms, si c'est un report ' il part en erreur (voir traitement des erreurs) 

sCurfrm = Screen.ActiveForm.Name 
sCurControle = Screen.ActiveControl.Name 

' si le nom n'existe pas (voir erreur) 
Curfrm = Application.VBE.VBProjects(i).VBComponents(sExt & _ sCurfrm).Name 
GoTo Exit_msgNomBase Err_msgNomBase: 

' TRAITEMENT POUR UN ETAT. 
If Err = 2475 Then 
   ' ce n'est pas un form (2476 ce n'est pas un report) 
   ' on capture le nom du report sCurfrm = Screen.ActiveReport.Name 
   ' le prefixe pour un report  
   sExt = "Report_" Resume Next 

   ' on continue 
ElseIf Err = 9 Then 
   'Erreur 
   i = i + 1 
   If i > Application.VBE.VBProjects.Count Then 
      MsgBox "Impossible de trouver " & sCurfrm & _ " dans l'application." 
      Exit Function 
   End If 

   Resume 
ElseIf Err > 0 Then 
   MsgBox "Erreur non prévue :" & Err.Number & "---" & _ Err.Description 
   Exit Function 
End If 
Exit_msgNomBase: 
MsgBox IIf(sExt = "form_", "Forms", "Report") & " : " & _ sCurfrm & vbCrLf & _ "Controle : " & sCurControle & vbCrLf & _ "Base : " & Application.VBE.VBProjects(i).Name 

End Function

L’intérêt est évidemment de pouvoir le déclencher n’importe quand dans l’IHM, c’est pour cela qu’il faut le coupler à une macro AutoKeys.

Bonne utilisation !

Lorsque vous utilisez une zone de liste sans sélection multiple, il peut arriver d’avoir besoin de désélectionner la ligne. Inutile de vous acharner sur la ligne sélectionnée avec votre souris, elle restera en surbrillance.

Je vous livre ici ma méthode pour enlever la sélection :

Dim itSel As Integer 

Private Sub Form_Open(Cancel As Integer) 
   'initialise à -1 pour ne pas perturber la première sélection 
   itSel = -1 
End Sub 

Private Sub Liste_Click() 
   'la selection est identique à la précédent 
   If Me.Liste.ListIndex = itSel Then 
      Me.Liste.ListIndex = -1 
      'on déselectionne itSel = -1 
   Else 
      'on fixe le choix pour la prochaine comparaison 
      itSel = Me.Liste.ListIndex 
   End If 
End Sub

La liste se nomme Liste. On déclare une variable globale au  formulaire, que l’on nomme itSel, elle permettra de conserver le précédent choix opéré, soit un entier positif pour une sélection et -1 pour la dé-sélection.

Sur l’ouverture du formulaire on considère que rien n’est sélectionné et on attribue la valeur -1 à itSel. Lorsqu’on clique sur la zone de liste, on vérifie si le clic correspond à la sélection en cours au moyen de la propriété ListIndex.

Cette propriété retourne un entier de 0 à x ou x est le dernier item de la liste. Lorsque qu’on attribue une valeur à ListIndex l’item correspond est sélectionné, par contre si l’on met -1 aucune ligne n’est sélectionnée.

Bonne utilisation !