Précédent Index Suivant
8 Programmation événementielle
8.1 Introduction

Dans les années 80, les micro ordinateurs ont obtenu les capacités nécessaires pour supporter des interfaces graphiques. La complexité des applications utilisant des interfaces graphiques est importante car il faut gérer un nombre important d'actions de bas niveau (par exemple, les fenêtres sur l'écran). Il fallait donc décharger le concepteur d'applications de toutes ces difficultés et la nécessité de posséder des outils de développement pour des applications basées sur ces interfaces graphiques s'est donc imposée. La programmation événementielle et les langages de programmation associés sont donc apparus à cette époque. Dans les années 90, avec le développement des réseaux et des environnements client serveur, les micro ordinateurs ont enfin pu être reliés à l'informatique centrale. Il fallait également qu'il soit possible d'interroger l'informatique centrale à partir des postes clients et naturellement les langages ont du intégrer une couche logicielle permettant, par exemple, d'interroger une base de données distante quelle que soit sa nature.

Les outils de développement tels que Windev, Delphi, Power Objects, Visual Basic permettent de développer des applications graphiques et possèdent les outils logiciels nécessaires à l'interrogation de bases de données dans un environnement client serveur. Dans les applications basées sur des interfaces graphiques, les interactions avec l'utilisateur sont fortes, le programme doit réagir aux actions de l'utilisateur. La programmation événementielle permet de concevoir ce type d'application pilotée par l'utilisateur plutôt que par le code. La programmation événementielle fait appel à la notion d'objet (combinaison de programmes et de données qui peut être traitée comme une entité). Ces applications dépendent fortement de l'interface graphique utilisée pour le système d'exploitation cible, le système d'exploitation prenant en charge les mécanismes de bas niveau. Visual Basic est un produit de développement pour postes clients de type PC et est donc adapté aux interfaces graphiques de type Windows (3.1 et 95 pour les versions actuelles).

Visual Basic est donc un langage de programmation événementielle qui permet de réaliser des applications pour Windows. Il est particulièrement adapté pour assurer la liaison et les communications entre les logiciels sous Windows. Il permet d'interroger des bases de données éventuellement distantes. Il permet aussi de développer rapidement une ébauche d'un projet logiciel et est donc assimilé à un outil de maquettage et de prototypage. Les intérêts majeurs de Visual Basic sont sa facilité de programmation et l'intégration des techniques et concepts propres à Windows (DDE, OLE, DLL). Les inconvénients sont la lenteur du code produit et les difficultés du langage Basic sous-jacent (structures de données, typage, ...).

8.2 Programmation événementielle
Les composants d'une application événementielle interagissent entre eux et avec l'environnement. Ils communiquent en réponse à des événements. Ces événements peuvent correspondre à une action de l'utilisateur : un click sur un bouton de commande, une écriture dans une zone de texte, un choix dans une case d'option ou une case à cocher, le déplacement d'un objet, ... Ils peuvent aussi être déclenchés par le système : chargement d'une feuille, un top déclenché par l'horloge, ...

Les événements sont captés par le système d'exploitation, sont mis en file d'attente ce qui signifie que les événements sont séquentialisés. Ils sont ensuite pris en charge par la boucle de gestion des événements. La boucle de gestion des événements prend le premier événement à traiter dans la file et le traite. Le traitement consiste en l'exécution des procédures événement associées à celui-ci s'il en existe. C'est le programmeur qui doit prévoir la procédure à exécuter en réponse à un événement donné. Par exemple, le déclenchement de l'événement click sur un bouton quitter doit terminer l'exécution, le choix d'un élément dans un menu doit déclencher certaines opérations, un top d'horloge doit modifier le contenu d'une zone d'image.

Après analyse et élaboration d'un cahier des charges, le rôle du programmeur est de concevoir l'interface (sa forme et son contenu) tout en respectant les contraintes du cahier des charges. Il doit ensuite écrire le code des procédures événement liées aux différents composants de cette interface.

8.3 Éléments de Visual Basic
La connaissance d'un langage tel que Visual Basic nécessite un investissement important pour acquérir une bonne maîtrise de toutes ses possibilités. Nous ne donnons ici que les caractéristiques essentielles. La connaissance d'un objet particulier, de ses propriétés, de ses méthodes ne peut être acquise que par l'expérience. Les exercices associés à ce cours ont pour but de vous faire connaître certains des principaux objets de Visual Basic.

8.3.1 les objets Visual Basic

Un objet est combinaison de programmes et de données qui peut être traitée comme une entité. Il est possible d'utiliser des objets fournis par Visual Basic, de contrôler des objets provenant d'autres applications (essentiellement d'applications comme Word, Excel, ...), et même de créer ses propres objets.

Des exemples de différents types d'objets utilisables en Visual Basic sont : les contrôles d'une feuille (boutons de commandes, cadres, zones de texte, ...), une feuille contenue dans un projet est un objet, les bases de données sont des objets qui contiennent d'autres objets, les graphiques sont des objets. Dans Visual Basic, chaque objet est défini par une classe. On peut, comme exemple, considérer la classe CommandButton des boutons de commande. Lorsque vous créez un bouton de commande, vous créez une occurrence de la classe, cette occurrence de la classe constitue l'objet auquel vous faites référence dans votre application. La classe définit l'ensemble des données et traitements communs à tous les objets de la classe. Tous les objets sont créés sous la forme de copies identiques de leur classe. Les objets contiennent à la fois données et traitements particuliers à l'objet, plus les événements auxquels l'objet est sensible. Les données de l'objet sont les propriétés, c'est-à-dire des attributs qui personnalisent l'objet (nom, titre, taille, visible, ...). Les traitements sont les méthodes qui sont des fonctions ou procédures adaptées à l'objet (setfocus pour attribuer le focus à un objet, refresh pour mettre à jour un contrôle de données, ...). Les événements sont des actions auxquelles l'objet est sensible (le click, le glisser poser, l'appui sur une touche, ...).

8.3.2 Conception
Un projet (ou application Visual Basic) est un ensemble de feuilles et de modules. Une fenêtre et le code qui lui est associé sont regroupés dans une feuille. Une feuille contient le dessin de la fenêtre, les objets qu'elle contient et le code des procédures événement pour la gérer. Les modules contiennent la déclaration des fonctions, des objets, des procédures, des constantes, des variables globales à l'application.

Après analyse, conception du cahier des charges, le développement suivra le plan suivant :


création de l'interface
créer les feuilles et les nommer, pour chaque feuille créer les objets et les nommer. Pour les noms, il est fortement conseillé de respecter les conventions usuellement respectées en Visual Basic. Les noms ont toujours pour préfixe trois lettres rappelant la nature de l'objet : frm pour feuille, chk pour case à cocher, cmd pour bouton de commande, dat pour contrôle de données, fra pour cadre, lbl pour étiquette, mnu pour menu, opt pour bouton d'option, pic pour zone d'image, txt pour zone de texte, tmr pour minuterie. Définir les propriétés initiales des objets.
écriture du code
écrire les modules qui contiennent les déclarations et procédures globales à l'application. Écrire les procédures événement associées aux objets de l'application. Il faut pour cela avoir prévu tous les événements auxquels l'application doit réagir et la réaction à apporter à ces événements par l'application. Il est rappelé ici que ces événements peuvent provenir d'une action de l'utilisateur de l'application ou peuvent être déclenchés par le système.
8.4 Accès aux bases de données
Le contrôle de données (contrôle Data) permet d'accéder à des informations provenant d'une base de données et même à certains types de fichiers. Il est en effet possible d'accéder à des bases de données telles que Access, Foxpro, ..., à des bases de données distantes avec ODBC, à des fichiers Excel, à des fichiers ASCII structurés. Le contrôle de données peut effectuer les tâches suivantes :

Les contrôles dépendants standard qui peuvent être utilisés avec le contrôle de données sont : les étiquettes, les zones de texte, les images et zones d'images, les cases à cocher, les zones de liste et les contrôles OLE. Il existe également des contrôles personnalisés :

8.5 Exercices

8.5.1 Un exemple jouet introductif
Nous allons créer une application pour dire bonjour et quitter. Cette application contient une feuille, deux boutons de commande et une étiquette.

Lancez le logiciel Visual Basic. Vous voyez apparaître un menu principal, une feuille, une fenêtre de propriétés, une fenêtre de projet et une fenêtre de contrôles. Regardez la fenêtre de propriétés. Celle-ci contient les propriétés de la feuille avec leur valeur. Modifiez la valeur de la propriété Caption. Vous avez modifié le titre de la feuille. Modifiez à l'aide de la souris la taille de la feuille et sa position et regardez les modifications intervenues dans la fenêtre de propriétés.

Sélectionnez dans la fenêtre de contrôles le bouton CommandButton. Placez-en deux exemplaires sur la feuille : il suffit de dessiner un rectangle à l'aide de la souris sur la feuille, ce rectangle définit la taille et la position de l'objet dans la feuille. Vous devez voir apparaître deux boutons sur lesquels sont inscrits Command1 et Command2. Sélectionnez un des deux boutons : il suffit de cliquer sur le bouton, huit points s'affichent aux quatre sommets et aux quatre centres des segments du rectangle ce qui confirme que cet objet est actif (il a le <<focus>>). Regardez la fenêtre de propriétés, vous avez les propriétés de ce bouton. Modifiez sa propriété Caption en Hello, modifiez sa propriété Name en le nommant cmdbonjour. Ce nom sera l'identifiant de cet objet dans l'application. Procédez de même pour le second bouton en l'intitulant Fin et en le nommant cmdfin.

Créez une étiquette à l'aide du bouton Label de la fenêtre de contrôles, changez sa propriété Caption en vide (chaîne vide) et nommez-là lblmessage.

Les objets de l'application ont été définis, il nous reste à écrire le code de l'application. On souhaite qu'à l'exécution de notre application, un click de l'utilisateur sur le bouton intitulé Hello déclenche l'affichage d'une formule de politesse dans l'étiquette et qu'un click sur le bouton intitulé Fin stoppe l'application. Il faut donc écrire le code correspondant à ces deux événements. Une première question est de savoir comment on peut afficher un message dans l'étiquette. C'est la valeur de la propriété Caption de l'étiquette lblmessage qui précise l'affichage dans l'étiquette. Cette valeur pourra être modifiée par l'exécution de l'instruction suivante :

lblmessage.caption=''mes sincères salutations''

La syntaxe est donc de la forme : le nom de l'objet (d'où l'importance de nommer les objets d'une application) suivi d'un point suivi de la propriété de l'objet. Il nous reste à préciser que cette instruction doit être exécutée lorsque l'utilisateur clique sur le bouton Hello. Pour cela, cliquez deux fois sur le bouton correspondant. Vous voyez apparaître une fenêtre qui contient une procédure (son entête, un ensemble vide d'instructions, sa fin). Ajoutez l'instruction définie ci-dessus dans le corps de la procédure. Vous devez obtenir :

    Private Sub cmdbonjour_Click ()

     lblmessage.caption=''mes sincères salutations''

    End Sub

Ajoutez l'instruction End dans le corps de la procédure événement lié au click sur le bouton Fin. Lancez l'application ainsi construite à l'aide du bouton Exécuter de la barre d'outils du menu principal. Sauvegardez votre projet. Remarquez que vous devez sauvegarder une feuille (fichier avec extension .frm) et un projet (fichier avec extension .vbp).

8.5.2 Afficher date et heure
Créez une application qui contient trois boutons de commande et une étiquette. Le premier bouton permet d'afficher la date dans l'étiquette, le second bouton l'heure, et le troisième permet de quitter. Les fonctions DATE et TIME renvoient, respectivement, la date et l'heure.

8.5.3 Boutons d'option, cases à cocher, zones de texte
Dans cette application, un utilisateur doit pouvoir disposer d'une zone de texte dans laquelle il pourra éditer du texte. Il pourra alors modifier l'affichage du texte dans cette zone de deux façons : Placez une zone de texte (bouton Textbox de la fenêtre de contrôles) sur la feuille. Initialisez son contenu à vide (propriété Text) et la nommez txtsaisie. Placez un cadre (bouton Frame de la fenêtre de contrôles), nommez-le frastyle, donnez à sa propriété Caption la valeur Style. Placez un second cadre, nommez-le frataille, donnez à sa propriété Caption la valeur Taille. Dans le cadre de style, placez une case à cocher (bouton CheckBox de la fenêtre de contrôles) et nommez-là chkgras. Dans le cadre de style, placez une seconde case à cocher et nommez-là chkitalique. Mettez les valeurs &Gras et &Italique dans les propriétés Caption de ces cases à cocher. Pour écrire les procédures événement liées à ces cases à cocher : regardez l'aide sur la propriété Value d'une case à cocher ; regardez l'aide sur la propriété Font d'une zone de texte, cette propriété est elle-même un objet qui possède des propriétés (Bold, Italic, Size, ...). Vous aurez donc à écrire des instructions de la forme :

txtsaisie.Font.Bold=true

Vous aurez également à utiliser la structure de contrôle IF ... THEN ... ELSE ... END IF pour exprimer que : si la case à cocher correspondant au gras est cochée alors le texte est en gras sinon il ne l'est pas, même chose pour l'italique. Écrivez les procédures événement, placez un bouton Fin et écrivez la procédure associée, testez votre application, enregistrez votre projet.

Terminez la conception de l'application en créant trois boutons d'option dans le cadre de taille et en écrivant les procédures événement associées (pensez à regarder l'aide sur la propriété Value d'un bouton d'option). Remarque : un seul des boutons peut être activé car les trois boutons sont regroupés dans un même cadre. Testez votre application, enregistrez votre projet.

8.5.4 Zones d'image, minuterie

Placez trois zones d'image sur la feuille (bouton PictureBox de la fenêtre de contrôles), nommez-les picvert, picorange et picrouge, modifiez les propriétés picture en chargeant les icônes suivants : trff10a.ico, trff10b.ico,trff10c.ico , donnez la valeur true à la propriété Visible de la zone d'image picvert et la valeur false pour les autres. Placez une minuterie (bouton Timer de la fenêtre de contrôles), nommez-le tmrdelai. Regardez ses propriétés et l'aide sur ces propriétés.

Écrivez le code pour que l'on voit le feu passer du vert à l'orange, de l'orange au rouge, du rouge au vert toutes les deux secondes. Placez un bouton Fin et un bouton Je Passe, une étiquette. Quand on clique sur le bouton Je Passe, l'étiquette doit afficher un message Autorisé, Attention, Interdit selon la couleur du feu. Le message doit disparaître quand le feu change de couleur. Testez et sauvegardez. Modifiez l'application pour que l'affichage reste et se fasse selon la couleur du feu.

8.5.5 Jeu du nombre mystérieux

Ce jeu consiste à trouver un nombre, généré aléatoirement par l'ordinateur, en un nombre minimum d'essais. À chaque proposition de l'utilisateur, un message trop petit, gagné, ou trop grand est envoyé à l'utilisateur.

Consultez l'aide sur l'instruction Randomize et sur la fonction rnd(). Dans la procédure événement Load associée au chargement de la feuille, vous ferez un appel à l'instruction Randomize. Vous définirez deux constantes de type entier, borneinf et bornesup, dans la partie Général. Vous pouvez fixer ces constantes égales, respectivement, à 1 et 500.

Première version
L'application contient : un bouton Nouveau Jeu, un bouton Essai, un bouton Quitter, un cadre qui contient une zone de texte pour la saisie. Lorsqu'on appuie sur le bouton Nouveau Jeu, le nombre mystérieux est calculé, le cadre de saisie des propositions de l'utilisateur apparaît, le bouton Nouveau Jeu disparaît. L'utilisateur saisit un nombre dans la zone de texte, on n'effectue pas de contrôle de saisie. L'utilisateur clique sur le bouton Essai, en réponse, un message lui est envoyé en fonction de sa proposition et de la valeur du nombre mystérieux (la fonction val() renvoie la valeur numérique d'un texte). On utilisera, pour afficher les messages, la fonction msgbox. Quand l'utilisateur a trouvé, on le félicite et le bouton Nouveau Jeu réapparaît.

Deuxième version
Il est pénible de devoir cliquer sur la zone de texte pour commencer la saisie d'une proposition. L'utilisation de la méthode setfocus permet de résoudre ce problème.

Il serait également intéressant de permettre à l'utilisateur d'appuyer sur la touche Entrée pour soumettre une proposition plutôt que de l'obliger à appuyer sur le bouton Essai. Après avoir consulté l'aide sur les propriétés cancel et default des boutons de commande, effectuez cette amélioration.

Améliorations possibles

Compter le nombre de coups. Limiter le nombre de coups. Ajouter un délai en temps pour trouver la solution. Le délai peut être réglé à l'aide d'une barre de défilement. Effectuer des contrôles de saisie (seuls les caractères chiffres sont acceptés dans une saisie de proposition) à l'aide de l'événement keypress.

8.5.6 Accès aux bases de données

Dans tous les exercices, nous utilisons la base Bibliothèque. Le schéma relationnel est donnée dans la figure ??

8.5.7 exercice d'introduction

Nommez la feuille et donnez lui un titre. Posez un contrôle Data sur la feuille. Nommez-le datbiblio. Modifiez la propriété Caption pour faire apparaître << Consultation >>. Affectez à la propriété Databasename le nom de la base. Cette base est une base Access qui est choisi par défaut. Pour une base autre, il faudrait modifier la propriété Connect en conséquence. Posez un bouton de commande de nom cmdafficher et de titre << Afficher >>. Posez une étiquette de nom lbltitre et de titre vide. Modifiez la propriété Datasource en sélectionnant le contrôle de données datbiblio. Le contrôle étiquette est alors dit dépendant du contrôle de données. Il reste à programmer l'événement click sur le bouton afficher. La procédure événement va consister en la définition de la requête à exécuter pour que le contrôle de données puisse extraire les informations. Cette procédure est la suivante :

Private Sub cmdafficher_click()
   ' Extraire les données à l'aide d'une requête SQL
   ' La propriété RecordSource est ccette requête
   datbiblio.RecordSource = "Select titre from oeuvres"
   ' Dire au contrôle de données d'extraire les données
   datbiblio.refresh
   ' Lier l'étiquette avec le champ titre extrait
   lbltitre.Datafield = "Titre"
Vérifiez le bon fonctionnement de l'application.

8.5.8 contrôle de données et contrôles dépendants

En vous inspirant de l'exercice précédent, créez une application qui permet d'afficher la côte du livre, son titre, emprunté ou non pour chaque livre de la bibliothèque. Pour l'affichage de la côte et du titre, vous utiliserez au choix étiquette ou zone de texte, pour l'affichage de emprunté ou non, vous utiliserez une case à cocher.

8.5.9 recherche de livres par critères

recherche par thème

Vous ajoutez une zone de texte qui va permettre de saisir un nom de thème. Lors de l'appui sur le bouton de commande << Afficher >>, on fait apparaître la côte du livre, son titre, emprunté ou non pour chaque livre de la bibliothèque correspondant au thème saisi.

menus

Utilisez le générateur de menus pour créer un menu permettant à l'utilisateur de choisir entre les recherches suivantes : par thème, par mot du titre, par auteur, par éditeur, disponibles. Écrire les programmes pour ces recherches. Votre application doit gérer le fonctionnement global en affichant ou pas (à l'aide de la propriété Visible). Notez que les cadres permettent de regrouper plusieurs contrôles, on peut donc modifier l'affichage de tous ces contrôles en affichant ou pas le cadre les contenant.

contrôle personnalisé DBGrid

Posez un contrôle de données et le lier à la base Bibliothèque. Posez un bouton << Afficher >> et nommez-le. Posez un contrôle de données grille (DBGrid), nommez le dbgbiblio, modifiez la propriété DataSource pour lier le contrôle grille au contrôle de données. Posez une zone de texte et la nommez. L'utilisateur doit pouvoir saisir une requête SQL dans la zone de texte, lorsqu'il appuie sur le bouton << Afficher >>, le résultat de la requête s'affiche dans la grille. pour cela, le contrôle de grille étant dépendant du contrôle de données, il suffit de mettre à jour la propriété RecordSource du contrôle de données et d'exécuter la méthode Refresh.

Précédent Index Suivant