Accéder aux fichiers d'un dossier en VBA Access

Pour partager cette vidéo sur les réseaux sociaux ou sur un site, voici son url :


Sujets que vous pourriez aussi aimer :


Accès aux fichiers externes en VBA Access

Dans cette formation, nous allons apprendre à accéder aux fichiers contenus dans un dossier, en Visual Basic Access. L'objectif est de charger la liste des fichiers sur un formulaire Access. Cette liste doit être le contenu du dossier désigné par l'utilisateur par le biais d'un bouton. Lorsque l'utilisateur clique sur l'un des fichiers depuis le formulaire, son contenu doit s'afficher au centre de l'écran, lorsque la récupération est possible. Dans le cas contraire, un bouton doit permettre de l'ouvrir avec l'application Windows appropriée.

Formulaire pour parcourir les fichiers


La capture ci-dessus propose un extrait du formulaire à partir duquel nous allons débuter. Les contrôles sont déjà placés, nommés et personnalisés. En revanche, ils sont vides de code. Tout est à développer. Nous allons récupérer deux sources. L'une contient des fichiers dans un dossier à parcourir. L'autre est la base de données qui propose ce formulaire.

• Télécharger la base de données acces-aux-fichiers-vba.accdb en cliquant sur son lien,
• Puis, l'ouvrir dans Access et cliquer sur le bouton Activer le contenu si le message apparaît,
• Télécharger le fichier contenu.rar en cliquant sur son lien,
• Le décompresser dans le dossier de l'application,

Vous obtenez un dossier composé de fichiers images et textes notamment.

• Cliquer avec le bouton droit de la souris sur le formulaire acces_fichiers depuis le volet gauche,
• Dans le menu contextuel, choisir Mode création,
• Si elle n'est pas visible, cliquer sur le bouton Feuille de propriétés dans le ruban Création,

La feuille de propriétés permet de personnaliser les contrôles présents sur le formulaire. Mais elle permet aussi de définir des actions sur des événements attachés à ces objets. Ces actions peuvent être exécutées par des macros, à concevoir avec l'éditeur de macros, ou encore par du code VBA, à développer dans la procédure événementielle.

Mais avant cela, nous devons réaliser un dernier paramétrage sur la zone de liste afin qu'elle puisse accepter du contenu émanant du code VBA. Par défaut, une zone de liste attend en effet un contenu issu d'une table ou d'une requête.

• Sélectionner la zone de liste nommée liste_fichiers et située sur la partie droite du formulaire,
• Dans l'onglet Données de sa feuille de propriétés, régler sa propriété Origine source sur Liste valeurs,

Parcourir les fichiers d'un dossier
L'objectif étant premièrement de charger le contenu d'un dossier, nous devons récupérer le dossier désigné par l'utilisateur à l'aide du bouton Parcourir, prévu à cet effet. Le code en question devra se déclencher au clic sur le bouton.

• Sélectionner le bouton Parcourir en bas à gauche du formulaire,
• Activer l'onglet Evénement de sa feuille de propriétés,
• Cliquer sur le bouton associé à son événement Au clic,
• Dans la fenêtre qui suit, choisir Générateur de code et valider par Ok,

Nous basculons aussitôt dans l'éditeur de code Visual Basic, entre les bornes de la procédure événementielle : Sub parcourir_Click(). Tout code écrit entre ces bornes se déclenchera au clic (Click) de l'utilisateur sur le bouton parcourir.

L'objectif est de permettre à l'utilisateur de désigner un dossier par le biais d'une boîte de dialogue standard Windows. En VBA Access, les objets qui permettent de les manipuler sont différents de ceux que nous avions utilisés dans la formation VBA Excel pour importer des données. Pour y accéder par le code, nous devons d'abord ajouter une référence à la bibliothèque d'objets Microsof tOffice. Pour ce faire :

• Cliquer sur le menu Outils en haut de la fenêtre,
• Dans la liste, choisir Références,
• Dans la boîte de dialogue qui suit, trouver et cocher Microsoft Office 16.0 Object Library,
• Puis, valider par Ok pour ajouter la référence au projet,

Le numéro de la librairie dépend de votre version de Microsoft Office, 16 dans notre cas.


Désormais nous avons besoin de variables pour piloter la boîte de dialogue et manipuler les fichiers et dossiers. L'objectif à l'issue est de parcourir le dossier sélectionné par l'utilisateur pour récupérer chaque nom de fichier qu'il contient, et les afficher dans la zone de liste liste_fichiers. Nous avions appris à déclarer et typer les variables en VBA Excel.

• Entre les bornes de la procédure, déclarer les variables suivantes :

Dim boite_dialogue As Office.FileDialog
Dim nom_dossier As String: Dim fichier As Object
Dim dossier, chaque_fichier

Nous déclarons la variable boite_dialogue comme un objet FileDialog issu de la librairie Office que nous venons d'ajouter en référence. C'est elle qui nous permettra de définir quel type de boîte de dialogue standard nous proposerons à l'utilisateur. Les variables suivantes serviront à manipuler les fichiers et dossiers. Certaines n'ont pas de type, elles sont donc considérées comme des Variant. Cela signifie que leur type sera défini au même moment qu'elles seront affectées, pour désigner un dossier ou parcourir les fichiers.

La variable boite_dialogue est définie comme une variable objet. Comme nous l'avons appris, le mot clé Set doit dont être utilisé pour l'initialiser et l'affecter. Une boîte de dialogue peut servir à ouvrir un fichier, à enregistrer un travail ou encore à désigner un dossier, ce que nous souhaitons. La méthode FileDialog de l'objet Application attend ce paramètre.

• A la suite du code, ajouter les affectations suivantes :

Set boite_dialogue = Application.FileDialog(msoFileDialogFolderPicker)
boite_dialogue.Title = "Sélectionner un dossier pour récupérer son contenu"

Lorsque vous ouvrez la parenthèse de la méthode FileDialog, IntelliSense se déclenche et propose les constantes qui permettent de déterminer la nature de cette dernière. La constante msoFileDialogFolderPicker permet d'initialiser une boîte de dialogue pour définir un dossier. Puis la propriété Title de l'objet FileDialog permet de personnaliser le titre de la boîte de dialogue.

L'aide en ligne nous apprend que la méthode Show permet d'afficher cette boîte de dialogue. Elle nous apprend de même que si cette méthode renvoie la valeur -1, cela signifie que l'utilisateur à bien choisi un dossier et n'a pas cliqué sur le bouton Annuler. En conséquence, la suite du traitement ne doit se poursuivre que si l'utilisateur choisit un dossier. Nous allons donc vérifier un critère grâce à l'instruction If que nous avions apprise en VBA Excel pour gérer les conditions.

• A la suite du code, créer les bornes de la condition comme suit :

If boite_dialogue.Show = -1 Then

End If

Avant de parcourir les fichiers du dossier, nous devons récupérer le chemin d'accès au dossier désigné par l'utilisateur. C'est la propriété SelectedItems de l'objet FileDialog qui retourne cette information.

• Dans l'instruction If, ajouter les deux lignes de code suivantes :

nom_dossier = boite_dialogue.SelectedItems(1)
chemin.Value = nom_dossier

Nous n'avons pas autorisé la multisélection de dossiers au travers de cette boîte de dialogue. Donc, dans la collection retournée, le chemin d'accès du dossier se situe forcément en première position. C'est la raison pour laquelle nous passons le paramètre 1 à la propriété pour le désigner. Nous en profitions pour inscrire le chemin complet du dossier dans la zone de texte située en haut du formulaire (chemin.Value = nom_dossier).

• Enregistrer les modifications (CTRL + S) puis basculer sur le formulaire (ALT + F11),
• Exécuter ce dernier (F5) et cliquer sur le bouton Parcourir,
• Choisir un dossier et cliquer sur Ok,

L'exécution du code prend fin et vous êtes de retour sur le formulaire. Vous notez la présence du chemin complet du dossier que vous avez désigné.

Il s'agit désormais de parcourir tous les fichiers de ce dossier pour les inscrire dans la zone de liste, sur la gauche du formulaire. Pour ce faire, nous devons créer un objet ActiveX, grâce à la fonction VBA CreateObject pour manipuler les fichiers et dossiers.

• En conséquence, ajouter les deux lignes de code suivantes, toujours dans le If :

Set fichier = CreateObject("scripting.filesystemobject")
Set dossier = fichier.getfolder(nom_dossier)

Le mot clé Set permet d'initialiser cette variable sur l'objet retourné par la fonction CreateObject, à laquelle nous passons le paramètre scripting.filesystemobject, pour la gestion des fichiers et dossiers. Dès lors, la méthode getfolder de l'objet ainsi créé, avec en paramètre le chemin du dossier précédemment mémorisé, permet d'initialiser et de faire pointer la variable dossier, sur le répertoire désigné depuis la boîte de dialogue.

Il ne reste plus qu'à parcourir le contenu de ce dossier à la recherche des fichiers qu'il contient. Pour parcourir chaque élément d'un groupe, nous devons utiliser une boucle For Each que nous avions apprise en VBA Excel. Littéralement nous devons exprimer le raisonnement suivant : Pour chaque fichier contenu dans le dossier.

• Ajouter les bornes de la boucle For Each sur les fichiers, comme suit :

For Each chaque_fichier In dossier.Files

Next chaque_fichier

Après l'expression For Each, suit la variable utilisée pour parcourir tous les éléments du groupe, chaque_fichier ici. Elle doit être du même type que le groupe parcouru, les fichiers du dossier (dossier.Files). Ce typage se réalise en temps réel puisque la variable était déclarée comme un variant. Une boucle For Each se borne par le mot clé Next suivi du nom de la variable utilisée pour boucler (Next chaque_fichier). Elle permet d'optimiser les traitements en réalisant un nombre d'actions défini par le nombre d'éléments dans le groupe, le nombre de fichiers dans le dossier. Tant que le dernier fichier du dossier n'est pas atteint, elle poursuit. Donc, à chaque passage dans la boucle, nous devons récupérer le nom du fichier pointé et l'inscrire dans la zone de liste.

• Entre les bornes de la boucle For Each, ajouter le code pour récupérer le nom du fichier :

liste_fichiers.AddItem chaque_fichier.Name

AddItem est la méthode du contrôle zone de liste (liste_fichiers) qui permet d'empiler des éléments dans la liste. Il suffit de lui passer en paramètre le texte de l'élément à ajouter. C'est ce que nous faisons avec la propriété Name de la variable chaque fichier, qui retourne son nom. Il ne reste plus qu'à tester.

• Enregistrer les modifications (CTRL + S) puis basculer sur le formulaire (ALT + F11),
• Exécuter ce dernier (F5) et cliquer sur le bouton Parcourir,
• Choisir le dossier Contenu téléchargé précédemment et cliquer sur Ok,

Comme l'illustre la capture ci-dessous, tous les noms de fichiers du dossier sont récupérés et empilés, par ordre alphabétique dans la zone de liste du formulaire Access. La prochaine étape consiste désormais à afficher le contenu du fichier au centre du formulaire lorsque c'est possible (Texte ou Image). Dans le cas contraire, le code VBA doit proposer d'ouvrir le fichier avec l'application appropriée sous Windows.


Importer le contenu des fichiers en VBA Access
Le formulaire, sur sa partie centrale, est composé de deux contrôles qui se chevauchent. Le contrôle image nommé img se superpose au contrôle zone de texte, nommé contenu. Le premier sert à afficher le contenu des fichiers de type image, tandis que le second sert à afficher le contenu des fichiers de type texte. Donc au clic sur le nom de fichier depuis la zone de liste sur la droite, le contrôle approprié doit être chargé et l'autre doit être masqué pour ne pas cacher le contenu chargé. Cela signifie que nous devons commencer par créer la procédure événementielle qui déclenchera le code VBA, au clic sur la zone de liste du formulaire Access.

• Afficher le formulaire en mode création,
• Sélectionner la zone de liste sur la droite du formulaire,
• Activer l'onglet Evénément de sa feuille de propriétés,
• Cliquer sur le bouton de son événement Au clic,
• Dans la boîte de dialogue qui suit, choisir Générateur de code et valider,

Nous sommes de retour dans l'éditeur de code Visual Basic Access mais cette fois, entre les bornes de la procédure liste_fichiers_Click. Comme toujours, nous allons commencer par déclarer les variables. Nous avons besoin de variables objets pour pointer sur le fichier. Il nous faut de même des variables pour mémoriser les attributs du fichier, comme la taille et la date de création, à afficher dans la zone de texte, dans la partie inférieure du formulaire.

• Entre les bornes de la procédure événementielle, ajouter les déclarations suivantes :

Dim nom_fichier As String: Dim taille As String: Dim extension As String
Dim date_creation As String: Dim date_modification As String
Dim objet_fichier
Dim contenu_fichier As String
Dim taille_lecture As Integer, NLibre As Integer

La variable nom_fichier comme son nom l'indique doit servir à mémoriser le chemin complet du fichier cliqué depuis la zone de liste. Les variables taille, extension, date_creation et date_modification permettront de stocker les attributs du fichier, grâce aux variables objets qui les pointent. La variable objet_fichier est la variable objet à initialiser grâce à la fonction ActiveX CreateObject, sur le fichier cliqué. Les variables contenu_fichier, taille_lecture et NLibre serviront pour l'accès en lecture aux fichiers de type texte. Il s'agit maintenant d'initialiser les variables.

• A la suite du code, ajouter les affectations suivantes :

nom_fichier = chemin.Value & "\" & liste_fichiers.Value
Set objet_fichier = CreateObject("scripting.filesystemobject")

Nous reconstruisons par concaténation le chemin complet du fichier cliqué, dans la variable nom_fichier. En effet, le premier morceau de ce chemin est contenu dans la zone d'adresse en haut du formulaire, nommée chemin. Sa propriété Value (chemin.Value) permet de récupérer son contenu. Nous ajoutons l'antislash manquant avant de concaténer avec le nom du fichier ( & "\" ). Puis nous lui ajoutons le nom du fichier récupéré par la propriété Value de la zone de liste pour désigner le contenu du texte sélectionné (& liste_fichiers.Value). Ensuite, comme nous l'avons fait dans la procédure précédente, nous initialisons la variable objet_fichier pour manipuler le fichier pointé.

Grâce à l'objet ActiveX précédemment créé pour pointer sur le fichier, nous pouvons accéder aux méthodes pour récupérer les attributs.

• Pour cela, ajouter les affectations suivantes :

extension = objet_fichier.GetExtensionName(nom_fichier)
taille = objet_fichier.GetFile(nom_fichier).Size
date_creation = objet_fichier.GetFile(nom_fichier).DateCreated
date_modification = objet_fichier.GetFile(nom_fichier).DateLastModified

La méthode GetExtension de l'objet activeX, avec en paramètre le chemin complet du fichier, permet de retourner l'extension du fichier, généralement les trois lettres derrière le point. La méthode GetFile, avec en paramètre le chemin complet du fichier, permet de pointer sur le fichier en tant qu'objet pour accéder à ses propriétés. Ainsi la propriété Size renvoie la taille du fichier en Octets, tandis que DateCreated et DateLastModified renvoient respectivement la date de création et de modification du fichier désigné par la méthode.

Ces informations étant récupérées, nous pouvons les afficher sur le formulaire, dans la zone de texte prévue à cet effet dont le nom d'objet est detail.

• Pour ce faire, ajouter la ligne de code suivante :

detail.Value = "Créé le : " & date_creation & ", modifié le : " & date_modification & Chr(13) & Chr(10) & "Taille : " & taille & " Octets"

Nous affectons la propriété Value de la zone de saisie, à la concaténation des informations récupérées et ainsi assemblées. Il convient de tester le résultat à ce stade.

• Enregistrer les modifications (CTRL + S) et basculer sur le formulaire (ALT + F11),
• Enfoncer la touche F5 pour l'exécuter,
• Cliquer sur le bouton Parcourir et désigner le répertoire Contenu précédemment téléchargé,
• Sélectionner l'un des fichiers ainsi récupérés, en cliquant sur son nom dans la zone de liste,

Les attributs du fichier sélectionné depuis la zone de liste, s'affichent en effet concaténés dans la zone de texte du formulaire. Ce processus intervient au clic sur un nom de fichier dans la zone de liste. L'événement a bien déclenché le code VBA que nous venons de développer. Mais ce n'est pas terminé.

Il s'agit maintenant d'afficher son contenu dans la partie centrale du formulaire, soit dans le contrôle zone de texte, soit dans le contrôle image, selon la nature. Trois cas sont à prévoir. Le cas du fichier de type texte, le cas du type image et le cas où le fichier n'est ni l'un ni l'autre. Pour tester ces critères nous pourrions utiliser l'instruction If. Mais comme nous l'avions appris dans la formation VBA Excel pour gérer de nombreux cas, le Select Case est plus approprié. Ceci est d'autant plus vrai que chaque cas se dérive en plusieurs conditions. Un fichier texte peut être du type CVS ou TXT par exemple. Une image peut être un JPG, BMP, PNG ou GIF entre autres. L'instruction VBA Select Case permet de regrouper ces cas sous une même condition en les listant.

• A la suite du code, construire l'ossature de l'instruction Select Case, comme suit :

Select Case UCase(extension)
Case "JPG", "GIF", "PNG", "JPEG", "BMP"

Case "TXT", "CSV"

Case Else

End Select

Le test est naturellement effectué sur l'extension du fichier pour en connaître la nature. Pour éviter toute différence de casse, lors de la comparaison, nous transformons l'extension en majuscules. C'est la fonction VBA UCase qui permet de convertir une chaîne de caractères en majuscules. Nous l'avions découverte au travers de la formation VBA Excel pour modifier la casse des cellules. Puis nous énumérons les cas grâce au mot clé Case qui permet de regrouper plusieurs contraintes, en les listant séparées par des virgules (Case "JPG", "GIF", "PNG", "JPEG", "BMP"). Le dernier cas (Case Else) permet de traiter toutes les situations qui ne satisfont pas aux deux premiers cas. En d'autres termes, le traitement des fichiers qui ne sont ni de type texte, ni de type image, sera réalisé dans cette branche.

Le cas du fichier image est très simple à traiter.

• Ajouter les trois lignes de code suivantes, dans la branche Case des images :

contenu.Visible = False
img.Visible = True
img.Picture = nom_fichier

Pour afficher l'image, nous commençons par masquer le contrôle zone de texte superposé. C'est sa propriété booléenne Visible, réglée à False qui le permet. Inversement, nous rendons visible le contrôle image qui dispose de la même propriété. Nous la réglons donc à True cette fois. Puis nous affectons la propriété Picture du contrôle image sur le chemin complet du fichier. Ainsi il se charge de l'image désignée. Nous pouvons déjà tester cette partie du code.

• Enregistrer les modifications (CTRL + S) et basculer sur le formulaire (ALT + F11),
• Enfoncer la touche F5 pour l'exécuter,
• Cliquer sur le bouton Parcourir et désigner le répertoire Contenu précédemment téléchargé,
• Sélectionner l'un des fichiers image dans la zone de liste,

L'image apparaît instantanément au centre du formulaire, au clic sur le nom de fichier. Notre petit explorateur est de plus en plus fonctionnel. Il s'agit maintenant d'être en mesure de récupérer le contenu des fichiers texte, et de les restituer au centre du formulaire, dans la zone de saisie. Dans la formation VBA Excel pour importer des données externes, nous avions appris à coder l'accès séquentiel aux fichiers. Il s'agit de récupérer le contenu en mémoire pour le traiter et le restituer. Mais cette fois c'est plus simple. Nous n'avons pas besoin de récupérer les informations ligne à ligne pour les décomposer, nous pouvons récupérer le contenu intégral. Et VBA propose des fonctions pour ce faire.

• Revenir dans l'éditeur de code Visual Basic,
• Dans la branche Case traitant les fichiers texte, ajouter les lignes de code suivantes :

contenu.Visible = True
img.Visible = False
NLibre = FreeFile

Open nom_fichier For Input As NLibre
taille_lecture = LOF(NLibre)
contenu_fichier = Input(taille_lecture, NLibre)
Close NLibre

contenu.Value = contenu_fichier

Tout d'abord et à l'inverse du cas précédent, nous rendons visible la zone de texte tandis que nous masquons le contrôle image. Ensuite, pour accéder à un fichier afin de charger son contenu en mémoire, nous avons besoin de définir un numéro d'allocation mémoire, une sorte d'adresse. La fonction VBA FreeFile permet de retourner une valeur correspondant à une allocation disponible. Nous stockons cette valeur dans l'entier NLibre que nous avions déclaré en début de code. Puis, comme nous l'avions appris en VBA Excel, nous ouvrons le fichier en mémoire grâce à l'instruction Open suivi du chemin d'accès au fichier (Open nom_fichier). Nous souhaitons lire ce fichier et non pas y écrire, c'est ce que nous indiquons avec la suite de l'instruction (For Input). En écriture, nous aurions utilisé les mots clés For Output. Cette lecture s'opère en mémoire, là où le fichier est chargé. Pour ce faire, nous indiquons l'allocation mémoire disponible (As NLibre). Nous récupérons la taille en Octets de ce fichier, grâce à la fonction VBA LOF. Pour ce faire, nous lui passons en paramètre, l'adresse mémoire où il se situe, grâce à la variable NLibre qui permet de le désigner. Puisque nous connaissons sa taille, nous pouvons récupérer tout son contenu sur l'intégralité de ses octets, grâce à la fonction Input. Cette dernière retourne le contenu du fichier selon un nombre d'octets fourni en premier paramètre. Nous lui passons taille_lecture, donc elle retourne l'intégralité du fichier. Et pour savoir quel est le fichier à traiter, nous lui passons en deuxième paramètre, le numéro d'allocation mémoire NLibre qui le désigne. Nous stockons ce texte retourné dans la variable contenu_fichier. Et surtout nous n'oublions pas de fermer l'accès au fichier en vidant la mémoire grâce à l'instruction Close suivi toujours du numéro d'allocation mémoire, désignant le fichier à décharger. Enfin, nous restituons le contenu récupéré depuis la mémoire, dans la zone de texte du formulaire (contenu.Value = contenu_fichier).

• Enregistrer les modifications (CTRL + S) et basculer sur le formulaire (ALT + F11),
• Enfoncer la touche F5 pour l'exécuter,
• Cliquer sur le bouton Parcourir et désigner le répertoire Contenu précédemment téléchargé,
• Sélectionner l'un des fichiers texte dans la zone de liste,

Le contenu du fichier texte est instantanément chargé dans la zone de saisie du formulaire, au clic sur son nom depuis la zone de liste. Il s'agit de fichiers texte avec des balises HTML. Ces descriptifs sont à l'origine dédiés pour des pages Web. Nous pourrions traiter ce contenu et le purger de ces balises, avec du code VBA. Mais ce n'est pas l'objectif ici. Si vous cliquez sur une image, le texte disparaît bien au profit de la photo et inversement.

Il reste à traiter le dernier cas. Celui des fichiers que l'on choisit d'ouvrir dans leur application car leur contenu ne peut pas être restitué dans le formulaire Access.

• Dans le Case Else, ajouter le code suivant :

contenu.Visible = True
img.Visible = False
contenu.Value = "Contenu non disponible !" & Chr(13) & Chr(10) & Chr(13) & Chr(10) & "Cliquez sur le bouton Ouvrir pour l'exécuter dans son application"

Nous choisissons d'informer l'utilisateur que le contenu du fichier sélectionné peut être atteint en cliquant sur le bouton Ouvrir. Donc nous rendons visible la zone de texte avant d'affecter son contenu par le biais de sa propriété Value. La fonction Chr que nous avons découverte dans la formation VBA Access pour se connecter aux données, permet de simuler des actions clavier, comme des retours à la ligne ici.

Si vous exécutez le formulaire et sélectionnez un fichier d'un autre type, vous constatez l'apparition du message que nous venons de coder, au centre du formulaire. Il ne reste donc plus qu'à ajouter quelques lignes au clic sur le bouton Ouvrir pour permettre l'action décrite.

• Afficher le formulaire en mode création,
• Sélectionner le bouton Ouvrir,
• Activer l'onglet Evénement de sa feuille de propriétés,
• Cliquer sur le bouton de son événement Au clic,
• Dans la fenêtre qui suit, cliquer sur Générateur de code et valider,
• Dans la procédure événementielle ouvrir_Click() ainsi générée, ajouter le code suivant :

Dim nom_fichier As String: Dim MonApplication As Object

nom_fichier = chemin.Value & "\" & liste_fichiers.Value
Set MonApplication = CreateObject("Shell.Application")
MonApplication.Open (nom_fichier)

La variable nom_fichier permet de récupérer le chemin d'accès complet, comme précédemment. La variable MonApplication est déclarée comme un objet car c'est encore une fois par le biais de la fonction ActiveX CreateObject, que nous pourrons lancer l'exécution d'un fichier dans son programme associé. Cette fois, nous lui passons le paramètre "Shell.Application". Comme son nom l'indique, la variable objet permet désormais de piloter les applications. Dès lors sa méthode Open avec le chemin du fichier en argument, ouvre ce dernier dans son application.


Si vous exécutez le formulaire et que vous testez le bouton Ouvrir, vous notez que l'application adéquate se déclenche pour ouvrir le fichier désigné.

Il ne reste plus qu'à coder le dernier bouton pour fermer le formulaire. Nous avions appris à exploiter l'objet VBA DoCmd qui permet de déclencher des actions, plus précisément des commandes. Et ce sont les macros Access qui nous avaient permis de comprendre leur implémentation. Nous allons reproduire ce cheminement pour trouver le code permettant de fermer un objet tel qu'un formulaire.

• Basculer sur l'application Access (ALT + F11),
• Cliquer sur l'onglet Créer en haut de la fenêtre pour activer son ruban,
• Cliquer sur le bouton Macro tout à fait à droite du ruban,
• Dans l'éditeur de macro, choisir l'action FermerFenêtre à l'aide de la liste déroulante,
• Dans la zone Type d'objet, définir Formulaire,
• Dans la zone Nom d'objet, choisir le formulaire acces_fichiers,
• Dans la zone Enregistrer, choisir Non,

• Enregistrer la macro (CTRL + S), sous le nom : fermer_formulaire par exemple,
• Puis cliquer sur le bouton Convertir les macros en Visual Basic en haut à gauche du ruban,
• Valider le message qui apparaît,
• Dans l'éditeur VBA, double cliquer sur le module de la macro convertie depuis l'explorateur de projet sur la gauche,
• Copier et coller son code dans la procédure événementielle fermer_Click(),

DoCmd.Close acForm, "acces_fichiers"

Désormais lorsque vous cliquez sur le bouton Fermer, vous quittez et fermez en effet le formulaire. Notre petite application est terminée. Dans un autre volet, nous apprendrons à archiver ces données externes, dans des champs de table. Ainsi nous pourrons les exploiter pour traitements.