Interactions VBA entre les objets Access

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


Sujets que vous pourriez aussi aimer :


Interactions entre les objets Access par VBA

L'objectif de ce deuxième volet VBA Access et de poursuivre l'apprentissage du développement, pour les bases de données. A l'instar de la formation pour débuter la programmation en VBA Excel, nous allons nous appuyer sur les macros Access pour apprendre plus facilement, les objets de programmation. Une macro Access peut être convertie en code VBA. Nous consulterons ce code pour l'étudier et tenter de le personnaliser. Ainsi nous réaliserons des interactions entre les différents objets de base de données.

La base de données Access
Il s'agit de débuter avec des données déjà saisies dans une table conçue avec des champs correctement typés.

• Télécharger la base de données interactions-vba-access.accdb en cliquant sur son lien,
• L'ouvrir dans Access et cliquer sur le bouton Activer le contenu si le message se déclenche,
• Depuis le volet des objets Access, double cliquer sur le formulaire articles,

Comme vous le constatez, il s'agit d'une toute petite base de données, constituée d'un formulaire bâti sur une table, référençant des articles avec une désignation et un prix notamment. Ce formulaire est constitué de boutons qui doivent permettre de réaliser des opérations précises avec les tables, requêtes et états, en fonction de l'enregistrement en cours de consultation sur le formulaire. A ce stade ces boutons ne sont pas fonctionnels. Nous devons les développer en Visual Basic.


Afficher les données d'une table en VBA
Le premier bouton de ce formulaire propose de réaliser une action simple. Il s'agit d'afficher l'intégralité du contenu de la table articles qui a servi à construire ce formulaire. Le défi est de réaliser cette interaction par code. Comme nous l'avons vu dans la formation précédente pour débuter en VBA Access, ce code doit se déclencher au clic sur le bouton. En d'autres termes, il doit être saisi entre les bornes de la procédure événementielle qui intercepte cet ordre. Mais comme nous débutons en programmation VBA Access, nous ne connaissons pas encore les objets et les méthodes qui permettent de piloter ces éléments Access. C'est pourquoi nous proposons d'apprendre ces commandes en créant des macros dont nous consulterons le code retranscrit.

• Cliquer sur la flèche du bouton Affichage, en haut à gauche du ruban Accueil,
• Dans la liste, choisir Mode Création,

Dans un premier temps, il s'agit donc de construire une macro commandant l'affichage de la table articles. Comme nous l'avions appris dans la formation sur les macros Access, une macro permet de réaliser un enchaînement d'actions spécifiques pour automatiser les tâches ou réaliser des traitements particuliers. Savoir les créer ne requiert aucune connaissance en VBA Access.

• Cliquer sur l'onglet Créer en haut de la fenêtre Access pour afficher son ruban,
• Dans la section Macros et code, cliquer sur le bouton Macro,

Un nouvel onglet pour la conception de la macro apparaît au centre de l'écran. Une liste déroulante permet de définir une action à exécuter, qu'il s'agira de paramétrer. Autant d'actions que souhaitées peuvent être empilées les unes sous les autres. La macro se chargera de les déclencher dans la chronologie proposée.

• Cliquer sur la flèche de la liste déroulante pour afficher les actions proposées,
• Par ordre alphabétique dans la liste, choisir l'action OuvrirTable,

Une nouvelle ligne apparaît dans la fenêtre de conception de la macro avec des champs à renseigner. Fort logiquement, il faut spécifier le nom de la table à ouvrir.

• Cliquer sur la flèche du champ Nom de la table et choisir articles dans la liste,
• Cliquer sur la flèche du champ Mode Données et choisir Lecture seule dans la liste,
• Réaliser le raccourci clavier CTRL + S pour sauvegarder cette macro,
• Dans la boîte de dialogue qui suit, saisir le nom OuvrirTable et valider par Ok,
• Fermer la fenêtre de conception de la macro en cliquant sur la croix de son onglet,

La macro apparaît dans le volet de gauche des objets Access, dans la section Macros. Si vous double-cliquez dessus, elle réalise sa tâche et commande l'affichage de la table articles en lecture seule, comme nous l'avons demandé. Ainsi les données peuvent être consultées sans être modifiées. Nous souhaitons être en mesure de réaliser la même action, par le code VBA à écrire dans la procédure événementielle du clic sur le premier bouton Table.

• Cliquer avec le bouton droit de la souris sur la macro OuvrirTable depuis le volet des objets Access,
• Dans le menu contextuel, choisir Mode création,
• Dans la section Outils du ruban Création de la macro, cliquer sur le bouton Convertir les macros en Visual Basic,
• Dans la boîte de dialogue qui suit, décocher la case Ajouter une gestion des erreurs aux fonctions générées,
• Puis, cliquer sur le bouton Convertir,

Nous sommes redirigés dans l'éditeur de code VBA Access. La macro convertie apparaît dans l'explorateur de projet, dans un dossier nommé Modules.

• Double cliquer sur le module de la macro depuis l'explorateur de projet,

Le code converti s'affiche au centre de l'écran.

Function ouvrirTable()
DoCmd.OpenTable 'articles', acViewNormal, acReadOnly
End Function

Access a créé une fonction (Function) bien qu'aucune valeur ne soit retournée. Le nom de cette fonction est celui de la macro (OuvrirTable). Une fonction se boucle par l'instruction End Function. Et vous remarquez, qu'une seule ligne de code suffit à commander l'affichage de la table articles en lecture seule. VBA Access exploite l'objet DoCmd qui est la contraction de DoCommand (Exécuter une tâche). Il appelle la méthode OpenTable de cet objet pour ouvrir une table de la base de données. Le seul argument obligatoire de cette méthode est le nom de la table 'articles', en premier paramètre. Ensuite lui sont passés deux paramètres facultatifs. Tout d'abord acViewNormal est une constante qui permet de définir le type d'affichage à l'ouverture. Puis vient le paramètre pour définir le mode d'ouverture. La constante acReadOnly règle ce mode sur Lecture seule pour empêcher la modification de données. Une fois encore, la touche F1 sur l'objet DoCmd sélectionné, redirige vers l'aide en ligne qui indique notamment, quelles valeurs peuvent être utilisées pour renseigner les arguments des méthodes associées. Nous en savons donc suffisamment pour rendre fonctionnel le bouton Table du formulaire.

• Fermer l'éditeur de code VBA Access,
• Afficher le formulaire articles en mode Création,

Il s'agit d'associer le code précédent à l'événement du clic sur le bouton. Pour paramétrer ce gestionnaire d'événements, il est essentiel d'afficher la feuille de Propriétés.

• Si elle n'est pas visible, cliquer sur le bouton Feuille de propriétés dans le ruban Création,
• Sur le formulaire, cliquer sur le bouton Table pour le sélectionner,
• Dans la feuille de propriétés, cliquer sur l'onglet Evénement,
• Cliquer sur le petit bouton à l'extrémité droite de l'événement Au clic,
• Dans la boîte de dialogue qui suit, sélectionner Générateur de code et cliquer sur Ok,

Nous basculons de nouveau dans l'éditeur de code, entre les bornes de la procédure table_Click. Cela signifieque le code saisi entre ces bornes se déclenchera au clic sur le bouton Table. C'est ce que nous avons appris dans la formation précédente pour débuter en VBA Access.

• Entre les bornes de la procédure événementielle, saisir la ligne suivante :

DoCmd.OpenTable 'articles', acViewNormal, acReadOnly



Comme vous l'avez constaté, lorsque vous tapez une virgule pour renseigner les arguments de la méthode OpenTable, Intellisense se déclenche pour vous proposer les valeurs appropriées.

• Enregistrer ce code (CTRL + S),
• Fermer l'éditeur VBA Access,
• Afficher le formulaire en mode conception,
• Enfoncer la touche F5 pour l'exécuter,
• Cliquer sur le bouton Table,

L'événement du clic sur le bouton est intercepté. Le code que nous avons saisi se déclenche. Et la table articles s'affiche en effet en mode lecture seule. En nous inspirant de la macro, nous avons réussi à déclencher la même action, par le code VBA Access. Ce procédé nous a permis d'apprendre l'existence de l'objet DoCmd pour exécuter des actions par le biais de l'une de ses méthodes, OpenTable.

Afficher le détail de l'enregistrement du formulaire
Le code que nous avons développé précédemment, présente surtout l'intérêt d'avoir découvert les objets de programmation nous permettant de réaliser des commandes précises. Mais afficher l'intégralité des données d'une table ne procure pas grand intérêt. Nous souhaitons pouvoir afficher, dans une table, le détail de l'enregistrement en cours depuis le formulaire. Mais il n'est pas possible de filtrer les données, directement depuis la table. En revanche, nous pouvons réaliser une requête qui attend la clé primaire de l'enregistrement du formulaire pour s'exécuter. Ainsi, elle ne livrera que le détail souhaité. Et nous n'aurons plus qu'à commander l'affichage de ce résultat, grâce à l'objet DoCmd, au clic sur le bouton Requête. Une requête est une table filtrée. Cette astuce nous avait d'ailleurs été apprise par la formation Access pour établir un lien entre un formulaire et une requête.

• Sélectionner la table articles depuis le volet des objets Access,
• Cliquer sur l'onglet Créer en haut de la fenêtre Access pour activer son ruban,
• Dans la section Requêtes du ruban, cliquer sur le bouton Création de requête,
• Dans la fenêtre qui suit, sélectionner la table articles et cliquer sur Ajouter puis Fermer,
• Sélectionner tous les champs de la table et les glisser en dessous dans la grille de requête,
• Cliquer avec le bouton droit de la souris dans la zone Critères du champ Article,
• Dans le menu contextuel, choisir Créer,
• Dans le générateur d'expression qui suit, déployer l'affichage des formulaires dans la liste de gauche, jusqu'à faire apparaître le formulaire articles,
• Cliquer alors sur l'élément de ce formulaire articles pour faire apparaître tous ses champs dans la liste du milieu,
• Dans la liste du milieu, double-cliquer sur le champ Article pour générer l'expression de correspondance,
• Enfin, cliquer sur Ok pour valider,

Le générateur construit ainsi l'expression [Formulaires]![articles]![Article] dans la zone de critères du champ Article, qui est la clé primaire de la table. Cette requête doit donc seulement afficher le détail pour l'enregistrement en cours depuis le formulaire. Cet enregistrement est référencé par la valeur de la clé primaire en cours de lecture. Il s'agit donc d'un paramètre dynamique. Cette requête ne peut pas être exploitée seule. Nous devons commander son exécution par le code VBA, au clic sur le bouton du formulaire qui renseignera alors sur la valeur de la clé primaire en cours.

• Enregistrer la requête (CTRL + S) sous le nom : articles_detail,
• Fermer la requête en cliquant sur la croix de son onglet,
• Afficher le formulaire articles en mode création,
• Cliquer sur le bouton Requête pour le sélectionner,
• Cliquer sur le bouton de son événement Au clic depuis sa feuille de propriétés,
• Choisir Générateur de code et valider,
• Entre les bornes de la procédure événementielle req_Click(), saisir la ligne suivante :

DoCmd.OpenQuery 'articles_detail', acViewNormal, acReadOnly

Nous nous inspirons de ce que nous avons appris précédemment grâce à la macro. L'objet DoCmd propose une méthode OpenQuery pour exécuter une requête. Cette méthode requiert exactement les mêmes arguments que la méthode OpenTable. Donc nous lui passons tout d'abord le nom de la requête que nous venons de créer puis le mode d'affichage et de lecture des données.

• Enregistrer ce code (CTRL + S) puis fermer l'éditeur,
• Sur le formulaire en mode création, enfoncer la touche F5 pour l'exécuter,
• Changer d'enregistrement grâce aux boutons de navigation en bas du formulaire,
• Cliquer sur le bouton Requête,

Comme l'illustre la capture ci-dessous, nous affichons en mode feuille de données, le détail de l'enregistrement en cours depuis le formulaire. En fait, le code VBA se déclenche sur l'événement du clic sur le bouton Requête. Il appelle simplement la requête articles_detail, sans critère. Le critère est généré à la volée, en fonction du code Article consulté depuis le formulaire, grâce à l'expression que nous avons générée dansla zone de critères de la requête. Ce processus a d'autant plus d'intérêt si l'on considère que le formulaire n'affiche que les informations essentielles de la table. Un clic sur le bouton afficherait alors tout le détail des champs non prévus dans le formulaire.

• Dérouler le bouton Affichage du ruban Accueil,
• Dans la liste, choisir Mode création pour stopper l'exécution du formulaire,

Relier un état à un formulaire en VBA
Commander l'affichage d'un état en VBA Access n'est a priori pas un souci, grâce à l'objet DoCmd qui dispose de nombreuses méthodes pour réaliser ce type d'action. Nous allons donc écrire un code dans la procédure événementielle attachée au clic sur le bouton Etat du formulaire. Mais l'objectif final est de pouvoir afficher l'aperçu avant impression de l'article en cours de consultation depuis le formulaire. L'une des solutions consisterait à bâtir l'état sur la requête dynamique précédente. Ainsi l'état récupérerait la clé primaire pour afficher l'aperçu demandé. Dans le cas d'une facturation, ce procédé nous permettrait d'afficher l'aperçu avant impression de la facture Client en cours de consultation depuis le formulaire.

Mais nous allons changer de méthode ici. Nous tenterons de réaliser ce critère dynamique à la volée, par le code VBA. Commençons par l'affichage complet de l'état. Pour cela, nous devons créer un état sur la table articles.

• Sélectionner la table articles depuis le volet des objets Access,
• Cliquer sur l'onglet Créer en haut de la fenêtre Access pour activer son ruban,
• Dans la section Etats du ruban, cliquer sur le bouton Etat,

Comme la base de données ne contient qu'une seule table, Access construit instantanément et sans ambiguïté, le rapport sur la base de la table articles. Celui-ci s'affiche en mode Page dans son onglet.

• Lui appliquer des préférences de mise en forme à l'aide du bouton Thèmes du ruban Création,
• L'enregistrer (CTRL + S) sous le nom : etat_articles,
• Puis, le fermer en cliquant sur la croix de son onglet,
• Afficher le formulaire articles en mode création,
• Sélectionner le bouton Etat situé après le bouton Article Etat,
• Cliquer sur le bouton de son événement Au clic depuis sa feuille de propriétés,
• Dans la boîte de dialogue, double-cliquer sur Générateur de code,
• Dans les bornes de la procédure événementielle ainsi créée, saisir la ligne suivante :

DoCmd.OpenReport 'etat_articles', acViewPreview, , , acWindowNormal

Grâce à l'apparition d'Intelisense après avoir tapé le point qui suit l'objet DoCmd pour appeler ses propriétés et méthodes, nous trouvons sans difficulté la méthode OpenReport. C'est donc elle qui commande l'affichage de l'état dont le nom est passé en premier argument. Le deuxième argument permet de spécifier que nous souhaitons un aperçu avant impression. Puis nous ignorons les deux arguments facultatifs suivants, en saisissant deux virgules. Nous finissons par le dernier argument pour définir un mode d'ouverture normal de la fenêtre.

• Enregistrer le code (CTRL + S),
• Fermer la fenêtre VBA Access,
• Depuis le formulaire en conception, enfoncer la touche F5 pour l'exécuter,
• Cliquer sur le bouton Etat,

Comme vous le constatez, l'aperçu avant impression complet s'affiche à l'écran, grâce au code VBA déclenché sur l'événement du clic sur le bouton.

• Fermer l'aperçu en cliquant sur la croix de son onglet,
• Afficher le formulaire en mode Création,

Il s'agit maintenant de faire correspondre l'état et le formulaire, en fonction de la clé primaire en cours de consultation. Mais cette fois, nous allons demander à une macro de nous aider. Nous en prélèverons le code, pour savoir gérer des critères dynamiques en VBA, pour relier des objets Access entre eux, sur événement.

• Cliquer sur l'onglet Créer en haut de la fenêtre Access pour activer son ruban,
• Cliquer sur le bouton Macro de la section Macros et code,
• Déployer la liste déroulante dans la fenêtre de conception de la macro,
• Choisir l'action OuvrirEtat,
• Dans la zone Nom de l'état, choisir etat_articles,
• Dans la zone Affichage, définir Aperçu avant impression,

Le renseignement le plus important à définir ici est la condition WHERE. Nous avions appris à réaliser ce lien par les macros dans la formation Access pour relier un état à un formulaire. Il s'agit de faire correspondre la clé primaire du champ Article de l'état avec la clé primaire du même champ, mais pour le formulaire.

• Dans la zone Condition Where, saisir le début d'expression suivant : [Article]=,

Le nom d'un champ doit toujours être stipulé entre crochets dans une expression. Ici, il s'agit du champ Article de l'état que l'on souhaite afficher. Il faut le faire correspondre avec le champ Article du formulaire en cours de consultation.

• Cliquer sur le bouton du Générateur d'expression à l'extrémité droite de la zone Condition Where,
• Dans la fenêtre qui suit, comme précédemment, déployer l'affichage des formulaires, jusqu'à trouver le formulaire articles,
• Cliquer sur ce dernier pour le sélectionner,
• Dans la liste du centre, double cliquer sur le champ Article de ce formulaire,

Le générateur termine ainsi l'expression pour réaliser l'équivalence avec le champ Article issu du formulaire : [Article]=Formulaires![articles]![Article].

• Enregistrer cette macro (CTRL + S) sous le nom lien_etat,
• Puis, cliquer sur le bouton Convertir les macros en Visual Basic depuis le ruban Création,
• Décocher la case sur la gestion d'erreurs dans la fenêtre qui suit,
• Puis, cliquer sur Convertir,
• Double cliquer sur la macro convertie lien_etat depuis l'explorateur de projet, pour afficher son code,

La ligne de code que nous obtenons est la suivante :

DoCmd.OpenReport 'etat_articles', acViewPreview, '','[Article]=[Forms]![articles]![Article]', acNormal

Nous connaissions presque tout pour l'avoir testé. Il nous manquait la partie du critère dynamique, la condition WHERE. Vous remarquez qu'il s'agit de l'expression construite par le générateur depuis la macro, mais traduite en anglais. [Forms]! désigne les formulaires qui nous permettent de pointer précisément sur le formulaire articles [articles]! à partir duquel nous désignons le champ de la clé primaire, soit [Article]. Nous saurons donc désormais concevoir nos propres conditions WHERE en VBA Access, afin de relier les objets entre eux par le code.

• Copier cette ligne de code (CTRL + C),
• Enregistrer les modifications (CTRL + S) et fermer la fenêtre Visual Basic,
• Afficher le formulaire en mode création,
• Sélectionner le bouton Article Etat,
• Cliquer sur le bouton de son événement Au clic depuis sa feuille de propriétés,
• Choisir Générateur de code et valider,
• Entre les bornes de la procédure événementielle du bouton, coller la ligne de code,
• Enregistrer les modifications et fermer l'éditeur,
• Depuis le formulaire en conception, enfoncer la touche F5 pour l'exécuter,
• Changer d'enregistrement à l'aide des flèches de navigation en bas du formulaire,
• Puis, cliquer sur le bouton Article Etat,

Comme vous le constatez, seul l'aperçu de l'article en cours de consultation depuis le formulaire, est généré. C'est la condition Where dans la méthode OpenReport de l'objet DoCmd qui permet de réaliser ce filtre à la volée.

Filtrer un formulaire en VBA Access
En cliquant sur le bouton Formulaire, nous souhaitons afficher une vue filtrée du détail de l'article en cours de consultation, sur un autre formulaire. Nous allons directement mettre en application ce que nous avons appris, pour coder une condition Where dans la méthode de l'objet DoCmd qui permet d'ouvrir un formulaire. Mais pour ce faire, nous avons besoin d'un autre formulaire :

• Sélectionner la table articles depuis le volet des objets Access,
• Cliquer sur l'onglet Créer en haut de la fenêtre pour activer son ruban,
• Cliquer sur le bouton Formulaire de la section Formulaires,

Un nouveau formulaire est instantanément bâti sur la table articles qui était présélectionnée.

• Lui appliquer des préférences de mise en forme avec le bouton Thèmes du ruban Création,
• L'enregistrer (CTRL + S) sous le nom : detail_article,
• Puis, le fermer en cliquant sur la croix de son onglet,
• Afficher le formulaire articles en mode création,
• Sélectionner le bouton Formulaire situé après le bouton Etat,
• Cliquer sur le bouton de son événement Au clic dans sa feuille de propriétés,
• Choisir Générateur de code et valider,
• Entre les bornes de la procédure événementielle du bouton, saisir la ligne de code suivante :

DoCmd.OpenForm 'detail_article', acNormal, , '[Article]=[Forms]![articles]![Article]', acFormReadOnly

Nous mettons en application ce que nous avons appris en langage VBA Access grâce aux macros. Nous remplaçons la méthode OpenReport par OpenForm. Elle permet d'ouvrir un formulaire et propose les mêmes arguments. Et donc, dans la clause WHERE de la méthode, nous reproduisons strictement le même critère dynamique afin d'établir la correspondance entre la clé primaire consultée et la clé primaire à afficher.

• Enregistrer les modifications et fermer l'éditeur de code,
• Exécuter le formulaire articles,
• Changer d'enregistrement grâce aux flèches de navigation en bas du formulaire,
• Cliquer sur le bouton Formulaire,

Grâce au code VBA déclenché par l'événement du clic, le nouveau formulaire apparaît. Mais il n'apparaît pas n'importe comment. Il s'affiche filtré sur l'enregistrement correspondant à celui du formulaire d'origine.

• Fermer le formulaire detail_article,
• Afficher le formulaire articles en mode création,

Relier un état à un formulaire grâce à une requête
L'objectif est toujours le même. Il s'agit d'afficher l'aperçu du détail de l'article en cours de consultation depuis le formulaire. Mais cette fois, le lien dynamique doit être créé sans code VBA. Pour cela, il suffit de bâtir un état à partir de la requête articles_detail dont le critère est déjà dynamique, puisqu'il attend la clé primaire du formulaire en cours.

• Sélectionner la requête articles_detail depuis le volet des objets Access,
• Cliquer sur l'onglet Créer en haut de la fenêtre pour afficher son ruban,
• Cliquer sur le bouton Etat de la section Etats,
• Appliquer un thème à l'état ainsi créé à partir de la requête présélectionnée,
• Enregistrer l'état sous le nom etat_detail puis le fermer,
• Sélectionner le bouton Etat par req sur le formulaire articles en mode création,
• Cliquer sur le bouton de son événement Au clic depuis sa feuille de propriétés,
• Dans la fenêtre qui suit, choisir Générateur de macro et valider,
• Déployer la liste déroulante dans la fenêtre de conception de la macro,
• Choisir l'action OuvrirEtat et définir le nom de l'état sur etat_detail,
• Enregistrer la macro (CTRL + S) puis la fermer,
• Exécuter le formulaire articles,
• Changer d'enregistrement grâce aux flèches de navigation,
• Cliquer sur le bouton Etat par req,

L'état affiche bien le détail de l'article en cours de consultation depuis le formulaire. Ce lien sur les clés primaires a été réalisé sans code VBA. C'est une requête au critère dynamique qui l'a permis. L'état étant construit dessus, reçoit les instructions en temps réel.

• Fermer l'état en cliquant sur la croix de son onglet,
• Afficher le formulaire articles en mode création,

Relier formulaire et état selon critère choisi par l'utilisateur
Une clause WHERE ne se borne pas à faire la correspondance entre deux champs de deux objets Access. Elle peut servir de critère personnalisé. Ainsi, avec les boutons de la partie inférieure du formulaire articles, nous souhaitons afficher le formulaire et l'état filtrés, au-dessus du prix sélectionné dans la liste déroulante. Et nous souhaitons réaliser ces actions avec et sans code VBA. Nous connaissons désormais toutes les ficelles pour y parvenir. Commençons par la méthode VBA.

• Sélectionner le bouton Etat en bas du formulaire,
• Cliquer sur le bouton de son événement Au clic depuis sa feuille de propriétés,
• Dans la boîte de dialogue, choisirGénérateur de code et valider,
• Entre les bornes de la procédure événementielle du bouton, saisir la ligne suivante :

DoCmd.OpenReport 'etat_articles', acViewPreview, , '[PUHT] >= [Forms]![articles]![critere]', acNormal

La méthode OpenReport de l'objet DoCmd permet comme toujours de commander l'affichage de l'état passé en premier argument. Dans la condition WHERE, nous écrivons le critère qui impose l'affichage des articles pour lesquels le prix unitaire est supérieur ou égal ([PUHT]>=) au prix choisi dans la liste déroulante du formulaire dont le nom d'objet est critere ([Forms]![articles]![critere]).

• Enregistrer les modifications et fermer la fenêtre Visual Basic,
• Exécuter le formulaire,
• Choisir la valeur 30 par exemple dans la liste déroulante,
• Puis, cliquer sur le bouton Etat,

L'état s'affiche et comme vous le constatez, il est filtré sur le critère imposé par la liste déroulante du formulaire et récupéré par le code VBA dans la condition Where de la méthode OpenReport de l'objet DoCmd.

• Fermer l'état et afficher de nouveau le formulaire en mode création,

Il ne vous reste plus qu'à dupliquer ce code pour le bouton Formulaire. Il suffit de modifier la méthode OpenReport par la méthode OpenForm.

DoCmd.OpenForm 'detail_article', acNormal, , '[PUHT] >= [Forms]![articles]![critere]'

Nous devons réaliser les mêmes actions, avec les boutons restants, mais sans code VBA. L'astuce que nous connaissons, consiste à créer préalablement une requête, avec un critère dynamique sur le champ du prix. Ce critère doit attendre la contrainte passée par le formulaire, par le biais de la liste déroulante. Il restera à bâtir un formulaire et un état sur cette requête, puis à les appeler au clic sur chaque bouton respectif.

• Cliquer sur l'onglet Créer, en haut de la fenêtre, pour activer son ruban,
• Cliquer sur le bouton Création de requête,
• Dans la boîte de dialogue qui suit, choisir la table articles,
• Cliquer sur le bouton Ajouter puis sur le bouton Fermer,
• Ajouter tous les champs de la table dans la grille de requête,
• Cliquer avec le bouton droit de la souris dans la zone Critères du champ PUHT,
• Dans le menu contextuel, choisir Créer,
• Dans la zone d'expression du générateur qui apparaît, taper l'opérateur : >=,
• Déployer l'affichage des formulaires de la liste de gauche jusqu'à voir le formulaire articles,
• Le sélectionner et double-cliquer sur son champ critere dans la liste centrale,
• Valider cette expression en cliquant sur Ok,

L'expression : >=[Formulaires]![articles]![critere], s'inscrit dans la zone de critères du champ PUHT de la requête. Le champ critere du formulaire n'est autre que la liste déroulante qui permet de choisir un prix. La requête n'affichera donc que les articles dont le prix est supérieur ou égal au seuil indiqué par cette liste, depuis le formulaire. Il en sera donc de même pour le formulaire et l'état bâtis sur cette requête.

• Enregistrer cette requête sous le nom articles_prix,
• Puis, la fermer en cliquant sur la croix de son onglet,
• Sélectionner cette requête articles_prix, depuis le volet des objets Access,
• Cliquer sur le bouton Formulaire du ruban Créer,
• Appliquer un thème au formulaire dynamique ainsi généré,
• L'enregistrer sous le nom articles_prix puis le fermer,
• Sélectionner de nouveau la requête articles_prix depuis le volet des objets Access,
• Cliquer sur le bouton Etat du ruban Créer,
• Appliquer un thème à l'état dynamique ainsi généré,
• L'enregistrer sous le nom articles_prix puis le fermer,

Il ne reste plus qu'à commander l'affichage de ces deux objets au clic sur les boutons du formulaire.

• Sélectionner le bouton Etat par req en bas du formulaire,
• Cliquer sur le bouton de son événement Au clic depuis sa feuille de propriétés,
• Dans la boîte de dialogue qui suit, choisir Générateur de macro et valider,
• Dans la fenêtre de conception de la macro, choisir l'action OuvrirEtat,
• Dans la zone Nom de l'état, choisir articles_prix,
• Enregistrer la macro (CTRL + S) et la fermer,
• Sélectionner le dernier bouton Formulaire par req,
• Cliquer sur le bouton de son événement Au clic depuis sa feuille de propriétés,
• Choisir Générateur de macro et valider,
• Dans la fenêtre de conception de la macro, choisir l'action OuvrirFormulaire,
• Dans la zone Nom de formulaire, désigner articles_prix,
• Enregistrer la macro et la fermer,
• De retour sur le formulaire, enfoncer la touche F5 pour l'exécuter,
• Choisir un prix seuil dans la liste déroulante, par exemple 50,
• Cliquer sur le bouton Etat par req,

L'aperçu se crée et ne propose que les articles dont le prix est supérieur à la contrainte définie dynamiquement depuis la liste déroulante du formulaire.

• Fermer l'état puis cliquer sur le bouton Formulaire par req,

Le formulaire apparaît lui aussi, filtré sur les enregistrements répondant au critère dynamique.