http://www.free-livres.com/
Microsoft®
Visual Basic 2010
Codes sources sur
www.pearson.fr
Michel Martin
customer 27921 at Fri Mar 11 19:22:06 +0100 2011 Propriété de Albiri Sigue
LE P R O G RAM M E U R
Visual Basic 2010 Michel Martin
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Pearson Education France a apporté le plus grand soin à la réalisation de ce livre afin de vous fournir une information complète et fiable. Cependant, Pearson Education France n’assume de responsabilités, ni pour son utilisation, ni pour les contrefaçons de brevets ou atteintes aux droits de tierces personnes qui pourraient résulter de cette utilisation. Les exemples ou les programmes présents dans cet ouvrage sont fournis pour illustrer les descriptions théoriques. Ils ne sont en aucun cas destinés à une utilisation commerciale ou professionnelle. Pearson Education France ne pourra en aucun cas être tenu pour responsable des préjudices ou dommages de quelque nature que ce soit pouvant résulter de l’utilisation de ces exemples ou programmes. Tous les noms de produits ou marques cités dans ce livre sont des marques déposées par leurs propriétaires respectifs.
Publié par Pearson Education France 47 bis, rue des Vinaigriers 75010 PARIS Tél. : 01 72 74 90 00 www.pearson.fr Mise en pages : TyPAO Collaboration éditoriale : Hervé Guyader ISBN : 978-2-7440-4160-0 Copyright © 2010 Pearson Education France Tous droits réservés
Aucune représentation ou reproduction, même partielle, autre que celles prévues à l’article L. 122-5 2˚ et 3˚ a) du code de la propriété intellectuelle ne peut être faite sans l’autorisation expresse de Pearson Education France ou, le cas échéant, sans le respect des modalités prévues à l’article L. 122-10 dudit code.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Sommaire
Introduction........................................................ XIII
13. Traitements multitâches/multicœurs.......... 315 14. Manipulation du Registre de Windows...... 337
I – Faisons connaissance avec Visual Basic 2010
15. Fonctions API............................................... 353 1
16. Implémenter un système d’aide.................. 361
1. Avant de commencer.................................... 3
17. Personnaliser Windows 7............................ 383
2. Le langage et l’environnement.................... 23
18. Visual Basic et Microsoft Office.................. 403
3. Nouveautés et concepts utiles du langage et de l’environnement.................................. 39
19. Programmation WPF.................................. 413
II – Programmation Windows
151
4. Boîtes de dialogue communes..................... 153
III – Programmation Internet
457
20. Composeur téléphonique............................. 459 21. Clients HTTP et FTP................................... 471
5. Un peu plus loin........................................... 169
22. Applications web.......................................... 483
6. Implémenter des menus.............................. 185
23. Annuaire de sites web.................................. 511
7. Barres d’outils et barres d’état................... 201
24. Favoris web................................................... 551
8. Manipulation d’objets graphiques............. 213
25. Services web.................................................. 587
9. Fichiers et dossiers....................................... 241
26. Silverlight...................................................... 607
10. Jouer des sons WAV..................................... 259
27. LINQ............................................................. 643
11. Manipuler des données tabulaires.............. 269
Annexe. Routines utiles..................................... 705
12. Bases de données.......................................... 287
Index.................................................................... 725
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Table des matières
Introduction........................................................ XIII
Commentaires.......................................... 25 Opérateurs............................................... 26
I – Faisons connaissance avec Visual Basic 2010
1
Tests.......................................................... 26 Boucles..................................................... 28
1. Avant de commencer...................................... 3
Conversion de données............................ 28
Configuration requise pour utiliser Visual Basic 2010........................................... 4
Chaînes de caractères.............................. 29
Les différentes éditions de Visual Basic 2010. 4 Installation de Visual Studio 2010.................. 6 Premier contact avec Visual Basic 2010......... 10 Les "solutions" Visual Basic.................... 11 Écriture d’un programme en Visual Basic......................................... 12 Modification des propriétés des objets.... 14 Écriture du code....................................... 14 Test et débogage....................................... 15
Dates et heures......................................... 29 Collections d’objets................................. 29 L’environnement Visual Studio 2010.............. 31 Définition d’un nouveau projet................ 32 Le système de menus................................ 33 Les barres d’outils................................... 34 Les fenêtres filles...................................... 35 3. Nouveautés et concepts utiles du langage et de l’environnement........................................ 39
2. Le langage et l’environnement...................... 23
Innovations de l’environnement de développement........................................... 41
Le langage Visual Basic.................................. 24
Intégration de WPF dans l’IDE............... 41
Variables.................................................. 24
Projets fondés sur des modèles................ 42
Tableaux................................................... 25
Gestion des projets récents...................... 43
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
VI
Visual Basic 2010
Multitargetting......................................... 44
Méthodes d’extension............................... 68
Zoom dans le code................................... 45
Génériques............................................... 69
Intellisense............................................... 45
Types Valeur Nullable.............................. 71
Naviguer vers........................................... 45
Opérateur IIf............................................ 72
Surbrillance des références...................... 46
Support étendu du code XML................... 72
Recherche des références......................... 47
Délégués non stricts................................. 73
Générer à partir de l’utilisation.............. 48
Expressions Lambda................................ 75
Gestionnaire d’extensions........................ 49
Méthodes partielles.................................. 76
Data Binding avec un glisser-déposer dans WPF................................................. 49
Le langage LINQ...................................... 76
Débogage Intellitrace.............................. 50 Publication en un clic.............................. 50 Tests unitaires.......................................... 52 Migrer un projet existant vers le Framework .NET 4.0.................... 55
Techniques évoluées de Visual Studio 2005/2008 toujours d’actualité dans Visual Studio 2010................ 77 Alignement des contrôles......................... 77 Menus....................................................... 77 Barres d’outils......................................... 80
Innovations du langage Visual Basic 2010..... 57
Info-bulles................................................ 81
Continuation de ligne implicite................ 57
Zone de texte avec marque de saisie........ 82
Implémentation automatique des propriétés........................................... 58
Fenêtre des tâches.................................... 83 Navigateur web........................................ 83
Initialiseurs de collections....................... 58
Refactoring............................................... 83
Syntaxe simplifiée pour déclarer des tableaux............................................. 60
Extraits..................................................... 84
Expressions Lambda multilignes et sous-routine.......................................... 61
L’espace de nom My................................ 89
Covariance et contravariance génériques................................................ 62
Assistant Mise à niveau............................ 149
Prise en charge d’équivalence de type.... 63 Prise en charge dynamique...................... 63
Documenter le code en XML................... 88
Assistant Publication............................... 148
II – Programmation Windows
151
Programmation parallèle......................... 64
4. Boîtes de dialogue communes....................... 153
Concepts avancés issus des versions précédentes de Visual Basic............................ 64
La boîte de dialogue Ouvrir............................ 154
Inférence de type...................................... 64
La boîte de dialogue Couleur.......................... 158
Initialiseurs d’objets................................ 66
Exemple.................................................... 158
Types anonymes....................................... 67
Réalisation............................................... 159
La boîte de dialogue Enregistrer sous............. 157
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Table des matières
VII
La boîte de dialogue Police de caractères....... 160
Définition des procédures de traitement.. 224
Exemple.................................................... 161
Exécution de l’application....................... 227
Réalisation............................................... 161
Affichage d’une horloge à aiguilles................ 228
La boîte de dialogue Imprimer........................ 163
Avant de commencer................................ 229
Exemple.................................................... 164
Mise en place visuelle de l’application.... 229
Réalisation............................................... 165
Définition des procédures de traitement.. 230
La boîte de dialogue Rechercher un dossier... 166
Exécution de l’application....................... 233
Exemple.................................................... 166
La capture d’écran programmée..................... 234
Réalisation............................................... 167 5. Un peu plus loin.............................................. 169 Une application MDI...................................... 169 Création d’un formulaire parent.............. 170 Création d’un modèle de fenêtre enfant... 171
Définition de l’application....................... 234 9. Fichiers et dossiers......................................... 241 Fichiers à accès séquentiel.............................. 242 Fichiers à accès direct..................................... 246 Manipulation de dossiers et de fichiers........... 254
Polices de caractères....................................... 173
10. Jouer des sons WAV..................................... 259
Le Presse-papiers............................................ 179
Mise en place de l’application........................ 259
Accès traditionnel au presse-papiers....... 180
Alimentation du contrôle TreeView................. 261
Accès au presse-papiers via .NET 4.0...... 182
Utilisation du contrôle TreeView..................... 266 Exécution du fichier audio.............................. 266
6. Implémenter des menus................................. 185 Système de menus traditionnel....................... 185 Menu contextuel.............................................. 194
11. Manipuler des données tabulaires.............. 269 Minitableur...................................................... 269 Minigrapheur.................................................. 277
7. Barres d’outils et barres d’état..................... 201 Le contrôle ImageList..................................... 202 Mise en place de la barre d’outils................... 203 Mise en place de la barre d‘état...................... 205 Écriture du code.............................................. 206 Plus loin avec les contrôles ToolStrip............. 211
12. Bases de données.......................................... 287 Accès à une base de données locale................ 287 Accès à une base de données distante............. 294 Définition du service web......................... 294 Utilisation du service web ...................... 298
8. Manipulation d’objets graphiques............... 213
Utilisation plus complète du service web . ....................................... 302
Le système d’affichage graphique GDI+........ 214
Accès à une base de données via LINQ.......... 312
Mise en place d’un économiseur d’écran....... 223
13. Traitements multitâches/multicœurs.......... 315
Mise en place visuelle de l’application.... 223
Exécution d’un calcul en tâche de fond.......... 316
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
VIII
Visual Basic 2010
Exécution d’une application externe............... 322 Parallélisation des boucles.............................. 324
Troisième étape : conception du fichier d’aide .CHM................................................... 371
Utilisation de plusieurs cœurs à l’aide de tâches............................................. 333
Définition du sommaire............................ 377
14. Manipulation du Registre de Windows...... 337
Quatrième étape : interfaçage du fichier d’aide avec un projet Visual Basic ................. 380
L’Éditeur du Registre...................................... 338
Définition de l’index................................. 379
Modification du Registre.......................... 339
17. Personnaliser Windows 7............................ 383
Déplacements dans le Registre................ 340
Informations de la base de données................ 384
Recherches dans le Registre..................... 341
Exécution de programmes........................ 384
Structure du Registre ..................................... 342
Amélioration du fonctionnement de Windows.............................................. 385
HKEY_CLASSES_ROOT......................... 342 HKEY_LOCAL_MACHINE..................... 342 HKEY_CURRENT_CONFIG................... 343
Paramétrage de Windows......................... 388 Réalisation...................................................... 390
HKEY_USERS......................................... 343
18. Visual Basic et Microsoft Office.................. 403
HKEY_CURRENT_USER........................ 343
Prise de contrôle de Microsoft Word.............. 403
Importations et exportations dans le Registre............................................... 343
Mise en place visuelle.............................. 404
Visualiser un fichier REG......................... 345 Exécuter un fichier REG.......................... 345 Créer un fichier REG............................... 345 Exemple de fichier REG........................... 346 Visual Basic et le Registre.............................. 346
Définition des procédures de traitement.. 405 Exécution de l’application....................... 407 Prise de contrôle de Microsoft Excel.............. 408 Mise en place visuelle.............................. 408 Définition des procédures de traitement.. 409 Exécution de l’application....................... 411
Ajout, visualisation et suppression d’une clé................................................... 348
19. Programmation WPF.................................. 413
Accès au Registre par une requête LINQ. 352
Une première application WPF....................... 413
15. Fonctions API............................................... 353 Principales API............................................... 353 Utilisation des API natives et traditionnelles.. 357 16. Implémenter un système d’aide.................. 361 Première étape : collecte des informations utilisées par le système d’aide........................ 363 Deuxième étape : conception des pages HTML des rubriques...................... 363
Les contrôles WPF par défaut......................... 419 Manipuler des éléments multimédias............. 421 Graphiques 2D................................................ 423 Géométries 2D................................................ 424 Segments de droites.................................. 424 Polygones................................................. 425 Arcs elliptiques......................................... 426 Courbes de Bézier.................................... 427
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Table des matières
IX
Ellipses..................................................... 429
Gestion du ComboBox Nom.................... 465
Rectangles................................................ 430
Gestion du bouton de commande............. 466
Géométries combinées............................. 431 Le pinceau................................................ 433 Géométries 3D................................................ 437 Étape 1 – Définition d’un objet Viewport3D............................. 437
21. Clients HTTP et FTP................................... 471 Un client HTTP élémentaire........................... 471 Avant de commencer................................ 472 Mise en place de l’application................. 472
Étape 2 – Définition d’une caméra.......... 438
Définition des procédures de traitement.. 474
Étape 3 – Définition de l’éclairage.......... 438
Exécution de l’application....................... 475
Étape 4 – Implémentation d’un objet....... 439
Un client FTP élémentaire.............................. 476
Le code XAML complet............................ 439
Mise en place de l’application................. 477
Transformations 2D........................................ 441
Définition des procédures de traitement.. 478
Rotation.................................................... 441
Exécution de l’application....................... 480
Modification de l’échelle......................... 442 Inclinaison............................................... 443 Translation............................................... 443 Transformations 3D........................................ 444 Rotation.................................................... 446 Modification d’échelle............................. 447
22. Applications web.......................................... 483 Une première application web........................ 484 Une application web en un seul contrôle........ 488 Valider les données......................................... 493 Envoyer des e-mails avec une application web........................................ 504
Translation............................................... 447 Animations...................................................... 448
23. Annuaire de sites web.................................. 511
Animation de couleurs............................. 448
Mise en place de l’application........................ 512
Animer un objet avec ses propriétés........ 451
Définition des procédures de traitement......... 514
Animer un objet avec une transformation................................... 453
Conversion des fichiers HTML en données ... 529
Pour aller plus loin.......................................... 455
Utilisation du service web ............................. 537
III – Programmation Internet
457
20. Composeur téléphonique............................. 459 Avant de commencer....................................... 460 Mise en place visuelle de l’application........... 460 Définition des procédures de traitement......... 461 Gestion du menu Port............................... 464
Définition du service web............................... 533
24. Favoris web................................................... 551 Mise en place du projet................................... 551 Définition des procédures de traitement......... 554 Définition et implémentation du fichier d’aide.............................................. 578 Première étape : collecte des informations utilisées par le système d’aide................. 579
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
X
Visual Basic 2010
Deuxième étape : conception des pages HTML des rubriques............... 579
Interaction avec le code behind............... 639
Troisième étape : utilisation de l’application HTML Help Workshop... 582
Pour aller plus loin.......................................... 642
Quatrième étape : interfaçage du fichier d’aide .CHM avec le projet...................... 586
Animer la couleur du canevas................. 641
27. LINQ............................................................. 643 LINQ to Objects.............................................. 643
25. Services web.................................................. 587
Liste des processus en cours d’exécution............................................... 643
Conception du service..................................... 588
Accès au Registre..................................... 645
Utilisation du service...................................... 593
Liste des documents récents..................... 647
Utilisation d’un service web existant.............. 598
Liste des fichiers créés ces quinze derniers jours......................... 648
Accès traditionnel au service web........... 600 Accès au service web via My.WebServices................................ 603
LINQ to XML................................................. 649 Axe XML.................................................. 650 LINQ to XML et LINQ to Objects............ 651
26. Silverlight...................................................... 607 Une première application................................ 608
Sauvegarder dans un fichier XML............ 657 Lire un fichier XML.................................. 658
Les fichiers générés par Visual Studio..... 610
Accès aux attributs des marqueurs XML. 660
Les contrôles Silverlight................................. 617
Utiliser un index pour accéder aux éléments d’une collection.................. 662
Mise en page............................................ 617 Contrôles d’affichage............................... 622 Contrôles de commande........................... 631 Transformation d’objets.................................. 632
Extraire des éléments XML d’un XElement.......................................... 663 Utiliser des espaces de nom..................... 664 Requêtes LINQ to XML types................... 666
Rotation.................................................... 632
LINQ to DataSet............................................. 680
Transformation d’échelle......................... 633
LINQ to SQL.................................................. 683
Translation............................................... 634 Inclinaison............................................... 634
Les étapes nécessaires à l’interrogation LINQ to SQL............................................ 684
Combiner des transformations................. 635
Requêtes LINQ to SQL types................... 689
Animation d’objets......................................... 636
Pour aller plus loin.................................. 704
Modification de la largeur d’un contrôle. 637
Annexe. Routines utiles..................................... 705
Modification de l’opacité d’un contrôle.. 638
Routine de tri.................................................. 705
Ne pas démarrer une animation au chargement de la page........................ 639
Une image en fond de fiche............................ 707 Exécuter un programme externe..................... 708
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Table des matières
XI
Connaître le chemin de l’application.............. 710
Jouer un son WAV........................................... 721
Chemin des dossiers spéciaux de Windows.... 710
Ouvrir et fermer une application..................... 721
Liste des unités de disque disponibles ........... 711
Relancer et arrêter Windows........................... 721
Exécuter les modules du Panneau de configuration........................... 714
Savoir si l’ordinateur est connecté à Internet......................................................... 722
Résolution de l’écran...................................... 715 Mettre l’écran en veille................................... 716 Déplacer la souris et suivre ses déplacements............................................. 718
Créer un e-mail............................................... 722 Afficher une page web.................................... 723 Index.................................................................... 725
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Introduction
Cet ouvrage est dédié au langage de programmation vedette de Microsoft : Visual Basic 20101. De nombreuses raisons font qu’aujourd’hui ce langage est un des plus utilisés au monde :
∑
Il est facile à apprendre, y compris pour des personnes n’ayant jamais "touché" à la programmation.
∑
Il offre une approche totalement orientée objet, ce qui simplifie le développement d’applications de grande envergure et/ou complexes.
∑
Il est suffisamment puissant pour fournir toutes les ressources nécessaires aux programmeurs avancés.
∑
Il est extensible. De nombreuses sociétés proposent des composants annexes qui limitent dans de grandes proportions le développement de code spécialisé.
∑
Il produit tout aussi facilement des applications destinées à être exécutées dans un environnement Windows (Windows Forms ou WPF) ou Internet (ASP.NET ou Silverlight).
∑
Il est totalement compatible avec Windows 7, le dernier système d’exploitation de Microsoft.
∑
Il sait parfaitement dialoguer avec les applications de bureautique les plus utilisées au monde (le traitement de texte Microsoft Word et le tableur Microsoft Excel) afin d’automatiser la création de fichiers dans ces applications.
∑
Il utilise un langage de requêtage universel très puissant appelé LINQ. Grâce à lui, le programmeur peut interroger toutes sortes de collections, qu’elles proviennent d’objets
1. Dans certains écrits ou sur certains sites web, Visual Basic 2010 est aussi appelé Visual Basic 10. Il s’agit en effet de la dixième version du langage.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
XIV
Visual Basic 2010
créés par les méthodes propres à Visual Basic, d’une base de données locale ou distante ou encore de documents XML. ∑ Enfin, il est armé pour la programmation parallèle, afin de tirer le meilleur parti des processeurs multicœurs qui occupent aujourd’hui la plupart de nos ordinateurs. Cet ouvrage est divisé en trois parties indépendantes : "Faisons connaissance avec Visual Basic 2010", "Programmation Windows" et "Programmation Internet". Chaque lecteur, en fonction de ses objectifs, peut étudier la partie qui lui convient sans être pénalisé s’il n’a pas abordé les autres sujets. Ce livre se décompose de la façon suivante : ∑ Faisons connaissance avec Visual Basic 2010 (Chapitres 1 à 3). Cette partie vous aide à débuter dans l’univers de la programmation en Visual Basic. Après avoir pris connaissance de la procédure d’installation de Visual Studio 2010, vous aurez un aperçu de ses principales nouveautés (implémentation automatique des propriétés, initialiseurs de collections, continuation de ligne implicite, expressions Lambda multilignes et sousroutine, prise en charge d’équivalence de type, prise en charge dynamique, covariance et contravariance, programmation parallèle, etc.). Nous rappellerons également un certain nombre de techniques Visual Studio 2008/Visual Basic 2008 toujours utilisables dans Visual Studio 2010/Visual Basic 2010 (multitargetting, inférence de type, types anonymes, délégués non stricts, expressions Lambda, LINQ, etc.). Vous découvrirez ensuite les instructions du langage et vous verrez comment convertir les programmes écrits dans une version antérieure de Visual Basic. ∑ Programmation Windows (Chapitres 4 à 19). La deuxième partie de l’ouvrage est la plus volumineuse. À travers de nombreux exemples, elle vous montre comment aborder la plupart des domaines de programmation Windows : utilisation des boîtes de dialogue, mise en place de menus, barres d’outils et barres d’état, manipulations graphiques, accès au système de fichiers, exploitation de données tabulaires, bases de données locales et distantes, accès au Registre de Windows, interfaçage de Word et d’Excel, etc. Tous les codes présentés dans cette partie sont réutilisables : un copier-coller est généralement suffisant pour les incorporer dans vos propres développements. Cette partie s’intéresse essentiellement aux applications Winform, basées sur GDI+, mais également aux applications WPF (Windows Presentation Foundation), basées sur un mode graphique vectoriel extrêmement performant. ∑ Programmation Internet (Chapitres 20 à 27). Cette troisième partie aborde différents aspects de la programmation Télécom, Internet et Silverlight. Après avoir appris à composer des numéros de téléphone par l’intermédiaire d’un modem RTC, vous verrez à quel point il est simple de créer un client HTTP pour naviguer sur le Web et un client FTP pour télécharger des fichiers. Vous découvrirez également comment définir et exploiter vos propres services web. Enfin, vous apprendrez à réaliser des programmes ASP.NET et Silverlight destinés à être utilisés dans un navigateur web et vous verrez comment tirer parti de la technologie LINQ.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Introduction
XV
Les sources de l’ouvrage Les éditions Pearson mettent à votre disposition l’ensemble des solutions passées en revue au fil des pages, sur le site www.pearson.fr, à la page dédiée à cet ouvrage. Ces solutions sont rassemblées dans une archive au format ZIP composée de deux dossiers principaux : Projects et WebSites. Pour faciliter l’accès aux solutions contenues dans ces dossiers, il suffit de copier ces derniers dans le dossier Documents\Visual Studio 2010\ de votre disque dur principal. Lorsque vous lancerez les commandes Ouvrir/Projet-Solution et Ouvrir/Site web dans le menu Fichier de Visual Studio, toutes les solutions de l’ouvrage seront ainsi directement accessibles. Pour utiliser ce livre, vous devez posséder une édition de Visual Studio 2010/Visual Basic 2010 (y compris la version gratuite Visual Studio/Visual Basic 2010 Édition Express). Si vous disposez d’une connexion Internet haut débit, rendez-vous à l’adresse http://www. microsoft.com/express/downloads/. Vous pourrez y télécharger gratuitement Visual Basic 2010 Express (voir Figure 0.1). Figure 0.1 La page de téléchargement de Visual Basic 2010 Express.
Notez qu’il est également possible de télécharger la version Professionnelle de Visual Studio 2010, limitée à 90 jours d’utilisation, en vous rendant sur la page http://www.microsoft.com/france/visualstudio/download?CR_CC=_100352438_&wt.srch=1&CR_ SCC=100352438 (voir Figure 0.2).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
XVI
Visual Basic 2010
Figure 0.2 La page de téléchargement de Visual Studio 2010 Professional.
Rubriques spéciales de ce livre ce Astu
Les Astuces fournissent des remarques particulières ou des raccourcis inha bituels du langage.
Info
Les Infos donnent des informations complémentaires sur le sujet étudié, sans être indispensables pour la tâche en cours.
ntion Atte
Ces avertissements portent sur des actions à risque, lorsqu’une tâche n’est pas accomplie de façon correcte.
ition Défin
Les nouveaux termes sont placés en italique et explicités dans le texte.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
I Faisons connaissance avec Visual Basic 2010 Cette partie va vous aider à débuter dans l’univers de la programmation en Visual Basic 2010. Après avoir vérifié que votre ordinateur et votre système d’exploitation sont compatibles avec l’environnement de développement Visual Studio 2010, vous découvrirez les différentes éditions du langage et vous apprendrez à les installer. Ensuite, vous ferez connaissance avec les instructions du langage, puis avec l’environnement de dévelop pement. Enfin, si vous n’êtes toujours pas convaincu des immenses possibilités de Visual Basic 2010, un chapitre passant en revue les nouveautés du langage et de l’environnement vous persuadera, j’en suis sûr.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
1 Avant de commencer Au sommaire de ce chapitre
∑ Configuration requise pour utiliser Visual Basic 2010 ∑ Les différentes versions de Visual Basic 2010 ∑ Installation de Visual Studio 2010 ∑ Premier contact avec Visual Basic 2010 Les éléments qui composent votre ordinateur (processeur, mémoire, disque dur, carte graphique) sont-ils assez puissants pour vous permettre d’utiliser Visual Basic 2010 ? Qu’en est-il de votre système d’exploitation ? Devrez-vous en changer ou faire une mise à jour ? Ce premier chapitre répond à toutes ces questions. Une fois ces problèmes matériels et logiciels réglés, vous découvrirez les différentes éditions de Visual Basic/Visual Studio et vous verrez comment les installer. Enfin, vous apprendrez les différentes notions qu’il est bon d’avoir à l’esprit pour programmer en Visual Basic 2010.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
4
Visual Basic 2010
Configuration requise pour utiliser Visual Basic 2010 Pour être en mesure d’installer et d’utiliser Visual Basic 2010, vous devez disposer d’un PC équipé comme suit :
∑ ∑
Processeur Pentium à 1 600 MHz ou plus.
– Windows XP SP3 x86 (toutes les éditions sauf Starter) ; – Windows Vista SP2 x86 et x64 (toutes les éditions sauf Starter) ; – Windows 7 x86 et x64 ; – Windows Server 2003 x86 et x64 SP2 ; – Windows Server 2003 R2 x86 et x64 ; – Windows Server 2008 SP2 x86 et x64 ; – Windows Server 2008 x64. Mémoire : 1 Go (1,5 Go si l’exécution se fait dans une machine virtuelle). Un disque dur disposant au minimum d’un espace libre de 3 Go. Un écran capable d’afficher en 1 024 × 768 points ou plus. Un lecteur de DVD-ROM, ou un outil de virtualisation de lecteur de DVD-ROM si vous utilisez une image ISO téléchargée sur Internet.
∑ ∑ ∑ ∑
Système d’exploitation :
Les différentes éditions de Visual Basic 2010 Pour répondre au mieux aux attentes des différents développeurs Visual Basic, Microsoft propose plusieurs déclinaisons de son langage vedette :
∑
Visual Basic 2010 Express Édition. Ce produit regroupe tous les outils nécessaires pour développer des applications Windows et Internet. Il est particulièrement bien adapté aux programmeurs débutants qui veulent faire leurs premiers pas avec ce langage. Vous pourrez télécharger gratuitement Visual Basic 2010 Express Édition à l’adresse http:// www.microsoft.com/express/downloads/.
∑
Visual Studio 2010 Professional. Ce produit permet au développeur de déployer des applications sur diverses plateformes dont Windows, le Web, les services Cloud, Office et SharePoint. Il prend en charge plusieurs écrans, donne accès à des concepteurs visuels pour exploiter diverses plateformes (dont Windows 7) et propose des fonctionnalités capables d’effectuer des tests complets du code.
∑
Visual Studio 2010 Premium. Cette édition inclut une panoplie d’outils qui simplifient le développement d’applications, individuellement ou en équipe. Les tests codés
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 1
Avant de commencer
5
de l’interface utilisateur permettent d’automatiser les essais d’applications web et Windows. Les outils de couverture garantissent que les tests englobent tout le code. L’analyse d’impact de test génère une liste de tests recommandés après une modification de code. Les outils de cycle de vie (développement hors ligne de schémas de bases de données, participation à des méthodologies agile, etc.) peuvent s’appliquer aux tâches de développement de bases de données. Les outils d’analyse du code vous aident à vérifier les erreurs de codage les plus courantes avant l’étape de production. Enfin, l’édition Premium permet de générer des données de test pour alimenter une base de données, afin de ne pas utiliser les données réelles.
∑
Visual Studio 2010 Ultimate. Cette édition inclut une suite d’outils de gestion du cycle de vie des applications afin de permettre à des équipes de développeurs de garantir des résultats de qualité, de la conception au déploiement. Visual Studio 2010 Ultimate cible un grand nombre de plateformes et de technologies, dont les services Cloud et le calcul en parallèle. La fonctionnalité Intellitrace permet aux testeurs d’archiver les bogues et aux développeurs de les reproduire dans l’environnement exact où ils ont été rencontrés. L’explorateur d’architectures facilite la compréhension des fonctionnalités du code existant et de leurs interdépendances. Le diagramme de couches permet de définir et de communiquer une architecture d’application logique, et de valider des artefacts de code par rapport à l’architecture requise. Vous pouvez ainsi contrôler vos efforts de développement afin d’obtenir une application conforme au projet d’origine. Visual Studio Test Professional 2010 est inclus dans Visual Studio. Il permet de capturer et de mettre à jour les tests, d’automatiser la navigation dans les tests manuels et d’accélérer le cycle de correction et d’acceptation en capturant tout le contexte de test. Enfin, cette édition est optimisée pour les processus de développement interactif actuels. Elle offre des fonctionnalités qui vous aident à rester productif et à réagir aux risques potentiels avant qu’ils ne se concrétisent. L’intégrité du projet est ainsi surveillée de façon automatique à l’aide de rapports générés automatiquement.
∑
Visual Studio 2010 Test Professional. Destinée aux équipes d’assurance qualité, cette édition inclut un ensemble d’outils qui simplifient la planification et l’exécution manuelle de tests. Elle permet aux testeurs et aux développeurs de collaborer efficacement tout au long du cycle de développement d’une application. Entre autres possibilités : alignement et suivi des objectifs d’un projet, capture automatique d’informations importantes pendant un test et inclusion de ces informations dans les rapports de bogues, archivage des bogues interactifs et détaillés dans les informations système, réutilisation de tests manuels, amélioration du processus de test (plans, suites et scénarii de tests).
Vous voulez en savoir plus sur les différences entre les éditions de l’interface de développement ? Rendez-vous sur la page http://www.microsoft.com/france/visualstudio/ products/2010-editions/ qui donne accès aux caractéristiques détaillées de chaque édition (voir Figure 1.1).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
6
Visual Basic 2010
Figure 1.1 Les liens En savoir plus donnent accès aux caractéristiques détaillées des éditions de Visual Studio 2010.
Installation de Visual Studio 2010 Insérez le DVD-ROM d’installation de Visual Studio dans le lecteur1. Au bout de quelques instants, une boîte de dialogue vous propose d’installer Visual Studio 2010. Cliquez sur Installer Microsoft Visual Studio 2010 et patientez jusqu’à l’affichage de la fenêtre principale d’installation (voir Figure 1.2). Cliquez sur Suivant, parcourrez les termes du contrat de licence, sélectionnez l’option J’ai lu les termes du contrat de licence et je les accepte, entrez la clé du produit, votre nom d’utilisateur puis cliquez sur Suivant. L’Assistant d’installation vous propose d’installer plusieurs langages et environnements de développement (voir Figure 1.3). Si vous sélectionnez l’option Complète, tous les composants nécessaires à la génération de solutions pour Windows, le Web, Azure, Office System, SharePoint et SQL Server à l’aide des langages Visual Basic, Visual C#, Visual C++ et Visual F# seront installés. Ces composants seront complétés par le kit de développement Windows SDK, Sync Framework, une bibliothèque de graphiques et des outils de tests unitaires.
1. Si vous avez téléchargé l’image ISO de Visual Studio sur MSDN, Microsoft Technet, ou un autre site du même type, il est inutile de la graver sur un DVD pour installer Visual Studio : téléchargez gratuitement l’utilitaire Daemon Tools sur www.daemon-tools.cc, installez cette application et montez l’image de Visual Studio pour installer votre nouvel environnement de développement.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 1
Avant de commencer
7
Figure 1.2 Boîte de dialogue principale d’installation de Visual Studio 2010.
Figure 1.3 Quels langages voulez-vous installer ?
Si vous ne souhaitez n’utiliser qu’une partie de ces composants, sélectionnez l’option Personnalisée, cliquez sur Suivant, cochez les cases correspondant aux langages/environnements à installer (voir Figure 1.4), désignez le dossier d’installation puis cliquez sur Installer.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
8
Visual Basic 2010
Figure 1.4 Cette boîte de dialogue vous permet de limiter l’installation aux seuls composants qui vous seront utiles.
Armez-vous de patience, le processus d’installation est très long et demande un redémarrage de l’ordinateur… Lorsque Visual Studio est entièrement installé, une dernière boîte de dialogue affiche des normes de sécurité (voir Figure 1.5). Prenez-en connaissance et cliquez sur Terminer. Pour accéder à l’application Microsoft Visual Studio, il vous suffit maintenant de lancer la commande Tous les programmes/Microsoft Visual Studio 2010/Microsoft Visual Studio 2010, dans le menu Démarrer.
Info
Si vous utilisez Windows 7 ou Vista, le lancement de Visual Studio est quelque peu simplifié : cliquez sur Démarrer, tapez visual dans zone de texte Rechercher et cliquez sur Microsoft Visual Studio 2010, dans la partie supérieure du menu Démarrer.
Au premier démarrage, vous devez indiquer le langage de programmation que vous utiliserez le plus fréquemment (voir Figure 1.6).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 1
Avant de commencer
9
Figure 1.5 L’installation est terminée.
Figure 1.6 Quel langage allez-vous utiliser le plus fréquemment ?
Sélectionnez Paramètres de développement Visual Basic dans la liste et cliquez sur Démarrer Visual Studio (voir Figure 1.7).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
10
Visual Basic 2010
Figure 1.7 La fenêtre de Visual Studio, juste après son ouverture.
Premier contact avec Visual Basic 2010 Les premiers langages informatiques étaient de type "procédural". Regroupé dans un unique listing, le code s’exécutait en séquences, de la première à la dernière instruction. Les instructions le plus fréquemment utilisées étaient regroupées dans des procédures qui pouvaient être appelées une ou plusieurs fois dans le code principal. Aujourd’hui, la plupart des langages sont "orientés objets". À l’image de tous ses contemporains, Visual Basic 2010 suit cette évolution et manipule différents "objets" fournis par Microsoft ou des d’autres sociétés. Un ou plusieurs blocs d’instructions sont attachés à chacun des objets utilisés dans une application. Lorsqu’un objet est sollicité par un clic de souris, une frappe au clavier ou un événement d’un autre type, Visual Basic recherche le bloc de code correspondant. S’il existe, il est exécuté ; dans le cas contraire, aucune action n’en découle. Une application écrite en Visual Basic est donc constituée d’un ensemble de petits programmes indépendants qui sont exécutés lorsque certains événements propres aux objets utilisés surviennent. C’est la raison pour laquelle Visual Basic 2010 est qualifié de "langage orienté objets". L’utilisation d’objets offre plusieurs avantages dignes d’intérêt, en particulier :
∑
La programmation devient facilement modulaire. La POO (programmation orientée objets) rattache en effet un ou plusieurs blocs de code à chaque objet. Ces blocs sont exécutés de façon événementielle.
∑
Le programmeur n’a pas à connaître de façon détaillée le fonctionnement des objets qu’il utilise. Il suffit qu’il ait une idée de leur fonction et sache comment les interfacer par
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 1
Avant de commencer
11
l’intermédiaire des variables et des méthodes qui leur sont propres. Dans la plupart des cas, les éléments permettant d’interfacer un objet sont largement commentés par ses auteurs. Parfois même, un ou plusieurs exemples élémentaires sont fournis avec chaque objet.
∑
Le débogage d’une application orientée objets se limite à celui du code événementiel que vous avez écrit. Les objets utilisés sont (en principe) totalement débogués et prêts à l’emploi.
Les "solutions" Visual Basic Les applications écrites en Visual Basic 2010 sont appelées "solutions". Elles peuvent consister en un ou plusieurs projets1. Chaque projet peut contenir une ou plusieurs feuilles (également appelées formulaires, ou forms en anglais). Enfin, différents fichiers identifiés par leur extension sont associés à chaque feuille. Examinons les fichiers créés pour une hypothétique solution de type "Application Windows Forms" constituée d’un projet unique et d’une feuille unique appelée Premier :
∑
Premier.sln. Ce fichier contient diverses informations relatives à la solution et au projet qui la compose. C’est ce fichier qui est ouvert lorsque vous lancez la commande Ouvrir dans le menu Fichier de Visual Studio 2010.
∑
Form1.vb. Ce fichier contient les procédures événementielles (et éventuellement non événementielles) relatives à la feuille Form1.
∑
Form1.Designer.vb. Ce fichier décrit les caractéristiques de la feuille (dimensions, titre, apparence, bordure, couleur, etc.) et des contrôles placés sur la feuille (position, dimensions et autres propriétés).
∑
Form1.resx. Ce fichier décrit les ressources utilisées par la feuille Form1. Ces ressources sont automatiquement intégrées à l’exécutable ou à la DLL de l’application lors de la compilation. Si l’une d’elles change, il suffit donc de recompiler le programme pour que la modification soit prise en compte.
∑ ∑
Premier.vbproj. Ce fichier décrit le projet et les différents fichiers qui le composent.
∑
App.config (ou Web.config). Fichier de configuration de l’application.
Premier.vbproj.user. Ce fichier contient les options propres au projet. Grâce à lui, vous retrouverez toutes les personnalisations faites sur votre projet dès son ouverture.
Tous ces fichiers sont gérés de façon transparente par Visual Studio. En tant que programmeur Visual Basic 2010, vous n’aurez de réelle interaction qu’avec le fichier .sln, lors de son ouverture dans l’environnement de développement. 1. Toutes les solutions développées dans cet ouvrage sont constituées d’un seul et unique projet.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
12
Visual Basic 2010
Écriture d’un programme en Visual Basic Les programmes que vous écrirez peuvent être courts ou longs, simples ou complexes – tout dépend des objectifs à atteindre. Par exemple, pour calculer et afficher le sinus d’un angle, une seule instruction suffit. Par contre, pour simuler le fonctionnement d’une calculatrice de poche, une bonne centaine de lignes de code sont nécessaires. Comment devez-vous programmer pour être efficace ? La plupart des programmeurs débutants sont tentés par la saisie directe de code dans l’éditeur. Cette technique donne d’assez bons résultats tant que le programme à développer est court et/ou simple. Mais vous courez à l’échec si votre programme est constitué d’un grand nombre de lignes ou repose sur des concepts que vous ne maîtrisez pas parfaitement. Mais alors, comment programmer ? Nous allons partir d’une remarque. La plupart des programmes peuvent être modélisés sous la forme d’une boîte noire (voir Figure 1.8). Figure 1.8 Modélisation élémentaire d’un programme.
Une ou plusieurs données sont fournies au programme. Le résultat à atteindre est obtenu en appliquant un ou plusieurs traitements à ces données. Par exemple, pour calculer les solutions d’une équation du second degré, l’utilisateur doit fournir les valeurs des constantes a, b et c : ax2 + bx + x = 0
Le traitement consiste à appliquer les formules que tout bon lycéen se doit de connaître… delta = b2 – 4ac
Si le déterminant delta est négatif, il n’existe aucune solution. Si le déterminant est positif, les solutions sont (–b – racine(delta)) / 2a et (–b + racine(delta)) / 2a. Si le déterminant est nul, il existe une solution unique égale à –b / 2a. Le schéma "boîte noire" est donc conforme à la Figure 1.9.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 1
Avant de commencer
13
Figure 1.9 Modélisation de la résolution d’une équation du second degré.
La plupart des programmes peuvent être divisés en trois parties : ∑ acquisition des données ; ∑ calculs ; ∑ affichage des résultats. La plupart du temps, l’acquisition des données se fait par l’intermédiaire de l’interface utilisateur, c’est-à-dire via la fenêtre d’exécution du programme. Vous devez concevoir une interface aussi simple et intuitive que possible pour ne pas dérouter l’utilisateur. Parfois l’acquisition des données peut se faire à l’intérieur d’une base de données locale ou distante. Dans ce cas, assurez-vous que vous connaissez l’emplacement, le nom, la structure et éventuellement le mot de passe de la table qui contient les données. Les calculs sont généralement déclenchés par l’utilisateur : appui sur un bouton de commande, fin de la saisie des données, etc. Placez le "déclencheur" des calculs à l’endroit le mieux approprié. Lorsque les calculs à effectuer sont complexes, veillez à les décomposer en plusieurs étapes élémentaires, simples à comprendre et à mettre en œuvre. Les résultats peuvent s’afficher dans la fenêtre d’exécution, enregistrés dans un fichier local, envoyés sur un site FTP ou dans un e-mail, etc. Assurez-vous que vous disposez de tous les renseignements nécessaires à l’affichage ou à l’enregistrement des résultats avant de commencer la saisie du programme. Vous l’aurez compris, il est important de réfléchir aux objectifs du programme, à sa présentation et à la façon dont les résultats vont être calculés avant de vous installer devant votre clavier. Apportez un soin particulier à la conception de l’interface utilisateur. N’hésitez pas à en créer plusieurs versions sur papier et à en parler à votre entourage (toute personne étrangère au projet peut en effet être de bon conseil). Si la cohérence et la simplicité de l’interface sont des paramètres très importants pour l’utilisateur final, ne négligez pas pour autant le code de votre programme. Veillez en particulier à le documenter et à hiérarchiser autant que possible les tâches complexes pour les décomposer en un enchaînement de tâches élémentaires, faciles à mettre au point et à contrôler… Quelles que soient la nature et l’envergure d’un projet Visual Basic, vous respecterez les étapes chronologiques suivantes : 1. Réflexion. Cette étape se fait généralement sur papier. Identifiez les données à traiter et les données à recueillir. Déduisez ensuite les traitements à mettre en œuvre pour obtenir les secondes à partir des premières.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
14
Visual Basic 2010
2. Création de l’interface. Mettez en place les objets (ou contrôles) nécessaires pour acquérir les données à traiter en utilisant les icônes de la Boîte à outils. 3. Modification des propriétés des objets. Utilisez la fenêtre des Propriétés pour modifier l’apparence et/ou le comportement des objets dans l’interface. 4. Écriture du code. Employez l’éditeur de code pour écrire les instructions de traitement événementiel des objets dans l’interface. 5. Test et débogage. Passez en revue tous les contextes possibles pour débusquer d’éventuelles erreurs à l’exécution. Si nécessaire, implémentez un "piège à erreurs" afin d’en faciliter l’identification (voir la section "Test et débogage" plus loin). 6. Diffusion. Écrivez un fichier texte qui indique comment utiliser votre programme. Placez ensuite votre programme et tous ses fichiers annexes sur un support facilement accessible (CD-ROM, archive compressée sur Internet, disque dur partagé sur un réseau) aux personnes concernées.
Modification des propriétés des objets Jusqu’ici, nous avons parlé des instructions et des fonctions propres au langage. Un autre point a une importance fondamentale en Visual Basic : l’accès aux propriétés des objets. Tous les objets ont un nom (qui est lui-même une propriété). Pour affecter une valeur à une propriété d’un objet donné, vous utiliserez une instruction du type : Nom.Propriété = Valeur
Supposons que vous vouliez affecter le contenu de la variable chaîne R à la propriété Text du contrôle zone de texte nommé Résultat. Vous utiliserez l’instruction ci-après : Résultat.Text = R
Supposons maintenant que vous vouliez redéfinir la hauteur de la feuille nommée Form1. Vous devez modifier la propriété Height par une instruction du type : Form1.Height = 3000
Écriture du code L’écriture du code se fait dans le volt central de l’environnement de développement, sous l’onglet FormX.vb1. Cet onglet apparaît automatiquement lorsque vous double-cliquez sur un objet déposé sur la feuille de l’interface. La procédure événementielle la plus probable est alors créée (voir Figure 1.10). 1. Ici, FormX représente le nom par défaut donné à la feuille X de la solution.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 1
Avant de commencer
15
Figure 1.10 Création de la procédure Form1_Load() après un double-clic sur la fenêtre de l’application.
Vous pouvez également accéder à l’éditeur de code à l’aide de la commande Code du menu Affichage (raccourci clavier : touche F7). Pour créer la procédure événementielle de votre choix, il suffit de sélectionner un objet dans la liste déroulante Nom de la classe, et un événement dans la liste déroulante Nom de la méthode (voir Figure 1.11). Figure 1.11 Ces deux listes déroulantes permettent de créer la procédure événementielle de votre choix.
Test et débogage Cette section étudie les différents types d’erreurs que vous pouvez rencontrer pendant la réalisation et la mise au point d’un projet. Ces erreurs peuvent être réparties dans quatre grands groupes :
∑
Les erreurs de saisie. Comme l’indique leur nom, elles interviennent lors de la saisie du code. Généralement anodines, elles ne demandent qu’un ou deux clics pour disparaître.
∑
Les erreurs de compilation. Il s’agit essentiellement d’erreurs de saisie qui n’ont pas été corrigées, par étourderie ou par paresse ! Le "boguicide" intégré à Visual Basic 2010 localise instantanément toutes ces erreurs.
∑
Les erreurs d’exécution. Elles sont causées par une instruction dont la syntaxe est correcte, mais dont les paramètres ne sont pas autorisés. La ligne mise en cause est clairement indiquée par Visual Basic pendant l’exécution.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
16
∑
Visual Basic 2010
Les comportements anormaux à l’exécution. De toutes les erreurs, ce sont les plus difficiles à identifier, surtout si le code est long et/ou complexe. Pour les dépister, vous utiliserez le débogueur intégré de Visual Basic : points d’arrêt, exécution pas à pas, fenêtre de débogage, etc. Bref, la grosse artillerie !
Les erreurs de saisie Pendant la saisie, la touche Entrée du clavier permet de passer d’une ligne de code à la suivante. Quand vous appuyez sur cette touche, le compilateur de Visual Basic analyse le code de la ligne et tente de débusquer une erreur de syntaxe. Dans l’exemple ci-après, l’instruction For n’est pas complète. Visual Basic détecte l’erreur lorsqu’on appuie sur la touche Entrée. Le problème est signalé dans la fenêtre Liste d’erreurs, généralement affichée dans la partie inférieure de l’IDE (voir Figure 1.12). Figure 1.12 Une instruction For sans To génère une erreur pendant la saisie.
Vous pouvez :
∑
Double-cliquer sur l’entrée correspondante dans la fenêtre Liste d’erreurs pour accéder à la ligne de code contenant l’erreur.
∑
Appuyer sur F1 pour avoir plus d’informations sur le type de l’erreur. Une fenêtre d’aide plus complète s’affiche.
Les erreurs de compilation Lorsque vous lancez une application en appuyant sur F5, seule la partie de code nécessaire à l’affichage de la fenêtre de départ est exécutée. Il est possible qu’une ou plusieurs lignes
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 1
Avant de commencer
17
d’une procédure annexe contiennent des erreurs de syntaxe. Ces erreurs ne sont découvertes que lorsque la portion de code correspondante est exécutée.
Les erreurs d’exécution Les instructions sont toutes correctes, et pourtant une erreur est générée lors de l’exécution. Il peut s’agir d’une utilisation incorrecte d’une fonction mathématique ou d’un passage de paramètre incorrect à une fonction Visual Basic. Dans l’exemple ci-après, une instruction Math.Sin tente de calculer le sinus d’une valeur chaîne : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load Dim a As Double = 0 Dim st As String st = 1 / a Print(st) End Sub
La valeur affectée à la variable st ne peut pas être affichée, car infinie. Le code produit une erreur d’exécution (voir Figure 1.13). Figure 1.13 La boîte de dialogue affichée suite à une erreur d’exécution.
Utilisez les informations affichées dans la boîte de dialogue pour corriger l’erreur. Si nécessaire, cliquez sur un conseil de dépannage ou sur une action pour accéder aux informations correspondantes.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
18
Visual Basic 2010
Les comportements anormaux Pour travailler sur un exemple concret, vous allez ouvrir la solution OutilsEtat.sln. Ce projet se trouve dans le dossier Projects\Debug des sources de l’ouvrage. Exécutez ce projet en choisissant la commande Démarrer le débogage du menu Déboguer (raccourci clavier : touche F5). Aucune erreur de compilation n’est détectée. L’outil Crayon étant sélectionné, tracez quelques courbes harmonieuses en maintenant le bouton gauche de la souris enfoncé. Malédiction ! Le tracé ne suit pas la souris et se comporte d’une façon plutôt étrange. Figure 1.14 L’outil Crayon ne donne pas le résultat escompté.
D’où peut bien provenir le problème ? Certainement de la procédure MouseMove, puisqu’il se produit pendant le déplacement de la souris. Examinons cette procédure : Private Sub Form1_MouseMove(ByVal sender As Object, ByVal e _ As System.Windows.Forms.MouseEventArgs) Handles _ MyBase.MouseMove If (OutilEnCours = 0) And (Tracé = True) Then G.DrawLine(pen, AncX, AncY, e.X, e.Y) AncX = e.X AncY = e.X End If End Sub
L’erreur est facilement identifiable. Elle se trouve dans l’instruction qui mémorise l’ordonnée de la souris dans la variable AncY. Il faut bien entendu écrire : AncY = e.Y
et non : AncY = e.X
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 1
Avant de commencer
19
Relancez le programme. Maintenant, l’outil Crayon fonctionne. Sélectionnez l’outil Trait et tentez de tracer quelques lignes droites. Cet outil se comporte comme l’outil Crayon. D’après vous, dans quelle procédure l’erreur se trouve-t-elle ? Réponse : dans la procédure ToolStrip1_ItemClicked(), qui sélectionne l’outil de dessin Trait lorsque l’utilisateur clique sur le deuxième bouton de la barre d’outils. Examinons cette procédure d’un peu plus près : Private Sub ToolStrip1_ItemClicked(ByVal sender As System.Object, ByVal e As System.Windows.Forms.ToolStripItemClickedEventArgs) Handles ToolStrip1.ItemClicked Select Case e.ClickedItem.Text Case "Crayon" ToolStripStatusLabel1.Text = "Outil Crayon actif" OutilEnCours = 0 Case "Trait" ToolStripStatusLabel1.Text = "Outil Trait actif" OutilEnCours = 0 Case "Rectangle" ToolStripStatusLabel1.Text = "Outil Rectangle actif" OutilEnCours = 2 Case "Ellipse" ToolStripStatusLabel1.Text = "Outil Ellipse actif" OutilEnCours = 3 End Select End Sub
L’erreur se trouve dans la deuxième instruction Case. Il faut sélectionner non pas le premier outil : OutilEnCours = 0
mais le second : OutilEnCours = 1
Lorsque la localisation de l’erreur est moins évidente, on a recours à une "division dicho tomique" de la procédure incriminée.
Info
Dans un programme, une division dichotomique consiste à définir un point d’arrêt au milieu de la procédure qui pose problème. Si l’application s’exécute jusqu’au point d’arrêt sans erreur, la suite du code est à nouveau divisée en deux et le point d’arrêt est reporté sur la seconde moitié du code, et ainsi de suite. Deux ou trois migrations du point d’arrêt suffisent en général pour localiser la source de l’erreur.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
20
Visual Basic 2010
Pour placer un point d’arrêt, il suffit de cliquer dans la marge de la ligne concernée ; une puce rouge s’affiche (voir Figure 1.15). Figure 1.15 La ligne AncX = e.X contient un point d’arrêt.
Le programme s’arrête juste avant l’instruction marquée d’un point d’arrêt. Vous pouvez poursuivre l’exécution de quatre façons différentes. Appuyez sur :
∑
F11 pour continuer en mode "pas à pas détaillé". L’instruction suivante est exécutée et le programme s’arrête.
∑
Maj+F10 pour continuer en mode "pas à pas principal". L’instruction suivante est exécutée. S’il s’agit d’un appel de procédure, toutes les instructions qui composent la procédure sont exécutées (contrairement au pas à pas détaillé) et le programme s’arrête.
∑
F9 pour continuer à vitesse normale jusqu’à l’instruction sur laquelle est placé le point d’insertion.
∑
F5 pour poursuivre l’exécution à vitesse normale jusqu’à ce que le point d’arrêt soit à nouveau rencontré.
Pour supprimer un point d’arrêt, il suffit de cliquer sur la puce rouge correspondante, dans la marge du code. Pour aller encore plus loin, vous pouvez définir une trace (TracePoint). Cliquez du bouton droit sur la puce rouge qui matérialise le point d’arrêt et choisissez l’entrée Lorsqu’il est atteint dans le menu. Une boîte de dialogue semblable à la Figure 1.16 s’affiche. Figure 1.16 Définition d’une trace.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 1
Avant de commencer
21
Cochez la case Afficher un message et définissez l’expression à afficher. Par exemple, pour connaître la valeur de la propriété e.X, vous utiliserez le message suivant : La propriété e.X a pour valeur {e.X}
Validez en cliquant sur OK. La puce rouge se transforme en un losange afin de matérialiser la trace. Exécutez le programme en appuyant sur la touche de fonction F5. Les messages générés par la trace s’affichent dans la fenêtre de sortie, comme à la Figure 1.17. Si cette fenêtre n’est pas apparente dans l’IDE, lancez la commande Sortie dans le menu Affichage ou appuyez sur Ctrl+Alt+O. Figure 1.17 La valeur de la propriété s’affiche dans la fenêtre d’exécution.
Les pièges à erreurs Dans certaines situations, il est impossible d’éviter des erreurs pendant l’exécution ; par exemple, lorsque l’utilisateur quitte une boîte de dialogue commune (voir Chapitre 4) sans avoir effectué de sélection. Dans ce cas, vous devez mettre en place un piège à erreur (error trap).
ce Astu
Lorsque l’erreur se produit, le programme interrompt l’exécution en séquence et exécute une ou plusieurs instructions dédiées au traitement de l’erreur.
L’exemple ci-après tente de lire le contenu d’un fichier dont le nom est spécifié dans le contrôle TextBox1. Les instructions "sensibles" sont insérées après le mot-clé Try. Si une instruction provoque une erreur, le bloc situé après le mot-clé Catch est exécuté. Dans le cas contraire, ce bloc est ignoré. Dans tous les cas, l’exécution du bloc Try se termine par l’exécution du bloc situé entre les mots-clés Finally et End Try. Considérez le code suivant : Try FileOpen(1, "c:\TextBox1.txt", OpenMode.Input) While Not EOF(1) texte = texte + LineInput(1) End While TextBox2.Text = tout Catch
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
22
Visual Basic 2010
MsgBox("Le fichier spécifié n’existe pas") Finally FileClose(1) End Try
La première instruction du bloc Try tente d’ouvrir le fichier dont le nom est spécifié dans le contrôle TextBox1 : FileOpen(1, "c:\TextBox1.txt", OpenMode.Input)
Si ce fichier n’existe pas, la prochaine instruction exécutée est celle qui suit le mot-clé Catch. Dans cet exemple, cette instruction affiche un message d’erreur dans une boîte de dialogue : Catch MsgBox("Le fichier spécifié n’existe pas")
Si le fichier existe, l’exécution se poursuit en séquence. La totalité du fichier est lue et stockée dans la variable texte : While Not EOF(1) texte = texte + LineInput(1) End While
Puis le résultat s’affiche dans la zone de texte multiligne TextBox2 : TextBox2.Text = tout
Le bloc Catch est alors sauté. Qu’une erreur se soit produite ou nom, le bloc Finally est alors exécuté, ce qui provoque la fermeture du fichier : Finally FileClose(1) End Try
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
2 Le langage et l’environnement Au sommaire de ce chapitre
∑ Le langage Visual Basic ∑ L’environnement Visual Studio 2010 Peut-être avez-vous du mal à faire la distinction entre Visual Basic et Visual Studio. Si tel est le cas, ce chapitre va vous éclairer. Dans un premier temps, vous découvrirez les objets (variables, tableaux, structures), les opérateurs et les instructions utilisés dans le langage. Dans un second temps, vous apprendrez à définir des solutions Visual Basic, à exploiter le système de menus, les barres d’outils et les nombreuses fenêtres filles de l’environnement de développement.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
24
Visual Basic 2010
Le langage Visual Basic Vous trouverez dans les pages suivantes quelques rappels sur le langage de programmation. N’hésitez pas à consulter l’aide en ligne pour parfaire vos connaissances.
Variables Pour définir une variable, vous utiliserez l’instruction Dim. Par exemple : Dim v1 as Integer
ou encore : Dim v2 as String
Les types autorisés dans Visual Basic sont les suivants : Type
Signification
Integer
Nombres entiers compris entre –32 768 et 32 767
Long
Nombres entiers compris entre –2 147 483 648 et 2 147 483 647
Single
Nombres réels avec sept chiffres après la virgule
Double
Nombres réels avec quinze chiffres après la virgule
Currency
Nombres réels comprenant quinze chiffres avant la virgule et quatre après
String
Chaînes de caractères dont la longueur ne peut excéder 231 caractères
Il est possible d’utiliser un symbole pour définir implicitement le type d’une variable. Dans l’exemple ci-après, les deux premières instructions sont équivalentes à la troisième : Dim v1 as Integer v1= 45 v1%=45
Pour en terminer avec les variables, voici la liste des symboles qui définissent implici tement le type des variables. Symbole
Variable
%
Integer
&
Long
!
Single
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 2
Le langage et l’environnement
Symbole
Variable
#
Double
@
Currency
$
String
25
Notez qu’il est également possible de définir une énumération à l’aide du mot-clé Enum, comme dans l’exemple suivant : Enum NiveauSecurite Illegal = -1 Niveau1 = 0 Niveau 2 = 1 End Enum
Cette instruction ne peut être utilisée que dans un module.
Tableaux Un tableau contient des données de même type accessibles par un indice. Pour déclarer un tableau contenant vingt valeurs entières, vous utiliserez une instruction du type : Dim Tableau1(0 To 20) As Integer
Si le tableau doit comprendre plusieurs dimensions, il suffit de les déclarer dans la parenthèse. Par exemple, l’instruction suivante définit un tableau à deux dimensions contenant 20 × 1 000 données de type Long : Dim Tableau2(0 To 20, 0 To 1000) As Long
Pour accéder à un élément dans un tableau, il suffit d’indiquer son ou ses indices. Par exemple : ∑ Tableau1(5) correspond au cinquième élément du tableau Tableau1. ∑ Tableau2(2,10) correspond à l’élément d’indices 2 et 10 dans le tableau Tableau2.
Commentaires Il est souvent nécessaire d’insérer des commentaires dans un programme pour faciliter sa maintenance et son évolution. Pour cela, vous utiliserez indifféremment le signe ‘ ou le mot-clé REM. Les deux instructions ci-après sont équivalentes : ‘ Ceci est un commentaire REM Ceci est un commentaire
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
26
Visual Basic 2010
Opérateurs Tous les opérateurs mathématiques, de comparaison et logiques habituels sont disponibles. Le signe = affecte une valeur à une variable. Par exemple, l’instruction ci-après affecte la valeur 12 à l’élément d’indice 4 dans le tableau Ta : Ta(4)=12
Les opérateurs +, -, *, /, ^, \ et Mod s’utilisent comme dans les autres langages. Vous pouvez utiliser une ou plusieurs paires de parenthèses pour forcer l’ordre d’exécution des opérateurs. L’instruction suivante, par exemple, calcule le déterminant d’une équation du second degré : Delta = b^2 - 4 * a * c
Les opérateurs de comparaison =, , = sont essentiellement utilisés dans l’instruction If then else : If Delta < 0 then Text1.TEXT = "Pas de solution" End If
Enfin, les opérateurs logiques Not, And et Or permettent d’inverser une valeur logique ou de combiner deux valeurs logiques. L’instruction de test ci-après affecte la valeur 1 à la variable Résultat si a est plus grand que 10 ou si b est différent de 0 : If a>10 or b0 then Résultat = 1 End If
Tests L’instruction de test la plus utilisée est If then else. Voici sa structure : If c1 then Instructions ElseIf c2 then Instructions ElseIf c3 then Instructions … Else Instructions End if
1 2 3
N
Si la condition c1 est vérifiée, le bloc d’instructions Instructions 1 est exécuté. Dans le cas contraire, si la condition c2 est vérifiée, le bloc d’instructions Instructions 2 est
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 2
Le langage et l’environnement
27
exécuté, et ainsi de suite jusqu’au dernier ElseIf. Si aucune des instructions précédentes n’est vérifiée, le bloc d’instructions Instructions N est exécuté. Bien qu’un peu lourde, la structure If Then Else est très simple à utiliser. Lorsque l’action accomplie consiste à affecter une valeur ou une autre en fonction du résultat du test, vous gagnerez à utiliser l’instruction IIf (Immediate If) : Variable=IIf(Condition, Valeur si vrai, Valeur si faux)
Par exemple, l’instruction suivante affecte la valeur 5 à la variable Résultat si a est supérieur à 0 et la valeur 6 dans le cas contraire : Résultat = IIf(a > 0, 5, 6)
Pour terminer, sachez que, si vous devez effectuer des tests répétitifs sur la valeur d’une variable, vous avez tout intérêt à utiliser l’instruction Select Case : Select Case Variable Case liste de valeurs Bloc d’instructions Case liste de valeurs Bloc d’instructions … Case Else Bloc d’instructions End Select
1 1 2 2
N
À titre d’exemple, les instructions If et Case ci-après sont équivalentes : If a = 1 Then b = 57 ElseIf a = 2 Then b = 12 ElseIf a = 3 Then b = 39 Else b = 9 End If Select Case a Case 1 b = 57 Case 2 b = 12 Case 3 b = 39 Else b = 9 End Select
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
28
Visual Basic 2010
Boucles Lorsqu’un traitement doit être répété, utilisez une boucle. La plus classique fait appel à l’instruction For Next. Par exemple, l’instruction suivante affecte les valeurs 1 à 10 aux éléments d’indice 1 à 10 du tableau T : For i = 1 To 10 T(i) = i Next i
Lorsque le nombre de passages dans la boucle n’est pas connu à l’avance, vous pouvez utiliser une instruction Do Loop ou While Wend : Les deux blocs d’instructions suivants sont équivalents : i = 1 Do T(i) = i i = i + 1 Loop Until i > 10 i = 1 While i < 10 T(i) = i i = i + 1 Wend
Info
Les conditions sont inversées dans les deux instructions. Do Loop effectue un bouclage jusqu’à ce qu’une condition soit vraie, alors que While Wend effectue un bouclage tant qu’une condition est vraie.
Notre petit tour d’horizon des instructions est terminé ; seules les plus courantes ont été décrites. Pour avoir des informations plus complètes, consultez l’aide des manuels en ligne à la rubrique Instructions. Nous allons maintenant passer en revue quelques fonctions spécialisées particulièrement utiles.
Conversion de données La plupart du temps, vous utiliserez des variables typées (Integer, Long, String, etc.). Si vous êtes amené à affecter un type de données à une variable d’un autre type, une erreur se produira à l’exécution de l’instruction d’affectation, à moins que vous n’utilisiez une
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 2
Le langage et l’environnement
29
f onction de conversion. Par exemple, pour affecter une valeur numérique à une variable chaîne, vous utiliserez la fonction Val. Pour connaître le nom et les modalités d’utilisation des fonctions de conversion, consultez l’aide en ligne à la rubrique Conversion.
Chaînes de caractères Le type chaîne de caractères est un des plus utilisés dans le code Visual Basic ; un ensemble de fonctions lui est dédié. Consultez l’aide en ligne à la rubrique Chaînes(fonctions), liste pour avoir de plus amples renseignements.
Dates et heures Nous allons terminer par les fonctions dédiées à la manipulation des dates et heures. Pour accéder à la liste de ces fonctions, consultez l’aide en ligne à la rubrique Dates(fonctions), liste.
Collections d’objets L’objet Collection constitue un moyen pratique de faire référence à un groupe d’éléments analogues, en les considérant comme un seul objet. Les éléments contenus dans une collection sont appelés membres. Pour créer une nouvelle collection, vous utiliserez une instruction du type suivant : Dim Objet As New Collection
où Objet est le nom de l’objet Collection à créer. Une fois l’objet Collection créé, il est possible de lui ajouter des membres avec la méthode Add : Objet.Add Nom
où Nom est le nom du membre à ajouter à l’objet Collection. Il est également possible de supprimer des objets avec la méthode Remove : objet.Remove index
où Index est une expression qui indique la position d’un membre de la collection. Des membres donnés peuvent être renvoyés à partir de l’objet Collection au moyen de la méthode Item : objet.Item(index)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
30
Visual Basic 2010
où Index est une expression qui indique la position d’un membre de la collection. Le parcours de l’ensemble de la collection est possible au moyen de l’instruction For Each … Next. À la différence des tableaux, le redimensionnement des collections est dynamique. Vous n’avez donc pas besoin d’utiliser des instructions Redim ou Redim Preserve : l’objet Collection le fait pour vous.
Info
Plusieurs collections prédéfinies sont disponibles. En voici la liste : Collection
Type
ArrayList
Collection simple d’objets. Les éléments sont obtenus par leur index.
BitArray
Collection de booléens. Les éléments sont obtenus par leur index.
CollectionBase
Classe abstraite servant de base pour vos propres collections.
DictionaryBase
Classe abstraite servant de base pour vos propres collections. Les éléments sont stockés suivant une clé.
HashTable
Collection d’objets associés à une clé. Les éléments sont obtenus par leur index ou par leur clé.
Queue
Collection de type FIFO (first in, first out, premier entré, premier sorti).
SortedList
Collection identique à HashTable, à ceci près que les éléments sont triés suivant leur clé. Les éléments sont obtenus par leur index ou leur clé.
Stack
Collection de type LIFO (last in, first out, dernier entré, premier sorti).
Voici un petit exemple qui vous donnera une idée des immenses possibilités offertes par les collections. Dim ColMois as New ArrayList ColMois.Add("Janvier") ColMois.Add("Février") ColMois.Add("Mars") ColMois.add("Mai") ColMois.Add("Juin") ColMois.Add("Juillet") ColMois.Add("Août") ColMois.Add("Septembre") ColMois.Add("Octobre") ColMois.Add("Novembre") ColMois.Add("Décembre")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 2
Le langage et l’environnement
31
Le mois "Avril" a été oublié en quatrième position. Pour l’ajouter, il suffit d’utiliser l’instruction suivante : ColMois.Insert(3,"Avril")
Pour supprimer ce même objet, vous utiliserez l’instruction suivante : ColMois.Remove(0)
Pour afficher les membres de la collection, vous utiliserez une structure For du type suivant : Dim obj as Object For Each o in ColMois Write o.ToString Next
Enfin, pour trier les éléments de la liste par ordre alphabétique, vous utiliserez l’instruction suivante : ColMois.Sort
L’environnement Visual Studio 2010 Visual Studio uniformise le développement des applications en Visual Basic, Visual C#, Visual C++, Visual F#, ASP.NET, Silverlight et Cloud. D’autre part, en installant des modules complémentaires (appelés SDK, ou Software Development Toolkit), il est possible d’ajouter d’autres langages à l’environnement de développement. À titre d’exemple, il suffit d’installer le SDK de BlackBerry pour être en mesure de développer des applications pour terminaux BlackBerry dans Visual Studio, tout en profitant de l’intellisense et du débogueur de l’environnement de développement. Comme dans les versions précédentes de Visual Basic, les applications se composent de formulaires (Forms). La conception et la mise au point d’applications se font selon le modèle qui a fait ses preuves depuis la première version de Visual Basic :
∑
La conception de l’interface utilisateur se fait par le déplacement de contrôles, depuis la Boîte à outils vers le formulaire de l’application.
∑
Le code événementiel relatif à un objet est saisi dans un éditeur de code intelligent qui colorise différemment les mots-clés, les instructions et les commentaires.
∑
La mise au point d’une application se fait dans le débogueur intégré. Il est ainsi possible d’exécuter le code instruction par instruction, de connaître le contenu de certaines variables sensibles ou encore d’exécuter un bloc d’instructions d’une seule traite.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
32
Visual Basic 2010
Définition d’un nouveau projet Lorsque vous définissez un nouveau projet avec la commande Nouveau/Projet dans le menu Fichier, une boîte de dialogue vous demande de préciser le modèle sur lequel doit être construit le projet (voir Figure 2.1). Figure 2.1 Définition d’un nouveau projet.
Vous pouvez créer un projet pour cibler des versions antérieures du .NET Framework en utilisant la liste déroulante Framework, dans la partie supérieure de la boîte de dialogue. Choisissez une entrée dans cette liste avant de sélectionner un modèle de projet, car seuls les modèles compatibles avec cette version du .NET Framework s’affichent dans la liste. Dans le volet gauche de la boîte de dialogue, sélectionnez Modèles installés, développez l’entrée Visual Basic et cliquez sur Windows. Dans le volet central, vous choisirez essentiellement :
∑
Application console. Pour créer une application dont les sorties s’effectuent uniquement en mode texte.
∑ ∑ ∑ ∑
Application Windows Forms. Pour créer une application Windows traditionnelle. Bibliothèque de classes. Pour créer une classe ou un composant réutilisable. Bibliothèque de contrôles Windows Forms. Pour créer un contrôle personnalisé. Application WPF. Pour créer une application Windows Presentation Foundation. Consultez le Chapitre 19 pour en savoir plus sur ce type d’applications.
Une fois le type de l’application sélectionné, le bureau contient plusieurs fenêtres, volets et palettes (voir Figure 2.2).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 2
Le langage et l’environnement
33
Figure 2.2 L’environnement de développement Visual Studio 2010 pendant la création d’une application Windows.
ce Astu
Si votre système graphique le permet, utilisez une résolution d’affichage supérieure à 1 024 × 768 points. Travaillez si possible en 1 280 × 1 024 points ou plus, sur deux ou trois écrans. Vous pourrez ainsi dispatcher les composantes de l’environnement de développement sur une plus grande surface de telle sorte qu’elles ne se chevauchent pas.
Le système de menus La partie supérieure de l’écran donne accès au système de menus et à la barre d’outils Standard du langage. Le système de menus est très classique :
∑ ∑ ∑ ∑ ∑ ∑ ∑
Le menu Fichier permet de charger et de sauvegarder des projets Visual Basic. Le menu Édition donne accès aux commandes Couper, Copier et Coller classiques. Le menu Affichage est utilisé pour afficher/masquer les onglets et barres d’outils de l’Environnement de développement. Le menu Projet permet d’ajouter des éléments au projet en cours d’édition. Le menu Générer est utilisé pour créer la version finale exécutable d’un projet. Le menu Déboguer permet de compiler, de lancer et de tester le projet. Le menu Équipe permet de se connecter à Team Foundation Server dans le cas d’un travail au sein d’une équipe.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
34
∑ ∑ ∑ ∑ ∑
Visual Basic 2010
Le menu Données donne accès aux sources de données associées au projet. Le menu Format permet de définir des options de mise en forme des éléments affichés dans la fenêtre du projet. Le menu Outils donne accès à de nombreuses options permettant de personnaliser l’IDE, d’établir une connexion avec une base de données ou encore d’accéder à l’éditeur de macros. Le menu Test permet de lancer des tests unitaires manuels ou générés sur votre code Visual Basic ou ASP.NET. Enfin, le menu Fenêtre permet d’accéder aux différentes fenêtres ouvertes et de choisir leur disposition sur les écrans.
Les barres d’outils Les barres d’outils facilitent l’accès aux commandes les plus fréquentes. Pour les faire apparaître, sélectionnez la commande Barre d’outils du menu Affichage (voir Figure 2.3) ou cliquez du bouton droit sur une barre d’outils existante. Figure 2.3 Visual Studio donne accès à de nombreuses barres d’outils thématiques.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 2
Info
Le langage et l’environnement
35
Pour transformer une fenêtre secondaire en palette flottante (et inversement), il suffit de double-cliquer sur sa barre de titre.
Vous emploierez essentiellement les barres d’outils Standard, Disposition et Éditeur de texte. La barre d’outils Standard facilite l’accès aux commandes de menu les plus fréquemment utilisées : ouverture/sauvegarde d’un projet, exécution/arrêt de l’application, placement d’un point d’arrêt, etc. (voir Figure 2.4). Figure 2.4 Les icônes de la barre d’outils Standard.
La barre d’outils Disposition permet d’ajuster les contrôles déposés sur les feuilles des applications (voir Figure 2.5). Figure 2.5 Les icônes de la barre d’outils Disposition.
La barre d’outils Éditeur de texte propose des fonctionnalités dédiées à l’éditeur de code de Visual Studio (voir Figure 2.6). Figure 2.6 Les icônes de la barre d’outils Éditeur de texte.
Les fenêtres filles L’environnement de développement contient plusieurs fenêtres secondaires (également appelées fenêtres filles) ancrées sur la périphérie de la fenêtre ou affichées sous la forme de palettes flottantes. Vous utiliserez en particulier :
∑ ∑ ∑
l’explorateur de solutions ; la boîte à outils ; la fenêtre des propriétés.
L’Explorateur de solutions donne la liste des éléments qui constituent l’application (voir Figure 2.7).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
36
Visual Basic 2010
Figure 2.7 Dans cet exemple, le projet ne comprend qu’une feuille, nommée Form1.
La Boîte à outils regroupe sous différents onglets les contrôles qui seront utilisés pour constituer la partie visuelle de l’application. Pour placer un nouveau contrôle sur une feuille, il suffit de le sélectionner dans la Boîte à outils et de tracer une zone rectangulaire sur la feuille (voir Figure 2.8). Figure 2.8 La Boîte à outils contient plusieurs onglets thématiques.
Pour accéder à des contrôles supplémentaires, lancez la commande Choisir des éléments de boîte à outils, dans le menu Outils. Sélectionnez l’onglet Composants COM, Composants .NET Framework, Composants WPF ou Composants Silverlight, cochez les cases correspondant aux composants que vous souhaitez rendre disponibles et cliquez sur OK (voir Figure 2.9).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 2
Le langage et l’environnement
37
Figure 2.9 Cette fenêtre liste les composants additionnels disponibles.
La fenêtre Propriétés (voir Figure 2.10) liste les propriétés associées à la feuille ou au contrôle sélectionné. Certaines propriétés ne sont accessibles qu’en mode Création. D’autres, au contraire, ne sont accessibles que pendant l’exécution, à l’aide de lignes de code. Figure 2.10 La fenêtre Propriétés donne les caractéristiques de la feuille ou de l’objet sélectionné.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
38
Visual Basic 2010
Enfin, par l’intermédiaire de plusieurs onglets, la feuille de travail donne accès à la représentation visuelle des formulaires de l’application et aux codes correspondants (voir Figure 2.11). Figure 2.11 Cette application est composée d’un formulaire contenant quatre labels, trois champs texte et deux boutons de commande.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
3 Nouveautés et concepts utiles du langage et de l’environnement Au sommaire de ce chapitre
∑ Innovations de l’environnement de développement ∑ Innovations du langage ∑ Techniques évoluées de Visual Studio 2008 toujours d’actualité dans Visual Studio 2010
Le tableau ci-après décrit les évolutions du langage Visual Basic et de l’environnement Visual Studio depuis 2002.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
40
Visual Basic 2010
2002 EnvironVS.NET 2002 nement de développement Visual Basic
2003
2005
2006
2007
2010
VS.NET 2003
VS 2005
VS 2005 + Extensions
VS 2008
VS 2010
VB.NET (v7.0) VB.NET (v7.1)
VB 2005 (v8.0) VB 2005 (v8.0) VB 9
VB 2010
Librairies du NetFx v1.0 Framework
NetFx v1.1
NetFx v2.0
NetFx v3.0
NetFx v3.5 .NET 4.0
CLR
1.1
2.0
2.0
2.0
1.0
4.0
Comme vous pouvez le voir, le CLR (Common Language Runtime) de Visual Basic 2010 est désormais en version 4.0. Le CLR fournit divers services à l’exécution : compilation JIT, gestion de la mémoire, de la sécurité, des exceptions, etc. Il met également à la disposition des langages de l’environnement de développement la librairie des classes de base. On est donc en droit de craindre le pire au niveau de l’interopérabilité1. Le CLR apporte une solution élégante à ce sujet : les différentes versions du CLR peuvent désormais cohabiter dans un seul et même process. Ainsi, si une application utilise des composants basés sur une version précédente du CLR, elle continuera à utiliser ces mêmes composants. Si de nouveaux composants relatifs du CLR 4.0 sont ajoutés à cette application, ils utiliseront tout simplement, de façon automatique et totalement transparente, cette version du CLR. Les anciennes applications Visual Basic sont donc totalement compatibles avec la nouvelle version du CLR et peuvent même être mises à jour sans provoquer de problèmes de compatibilité. Cette évolution majeure du moteur d’exécution du Framework .NET apporte son lot de nouveautés. Citons entre autres :
∑
TLBIMP (Type LiBrary IMPorter). Cet outil permettant de convertir les définitions de types présentes dans une bibliothèque de types COM en leur équivalent dans un assembly de CLR, est désormais disponible en Shared Source sur Codeplex, à l’adresse http://clrinterop.codeplex.com/.
∑
L’interopérabilité avec de nouveaux langages. IronPython, IronRuby et F#. Cette étape a nécessité l’implémentation de nouveaux types, notamment Tuple et BigInteger.
∑
Le Framework. ParallelFX Il fournit des mécanismes puissants pour mettre en place la parallélisation des traitements tout en fournissant un haut niveau d’abstraction, et donc une facilité d’utilisation jusqu’ici inégalée. Ce Framework peut également être utilisé
1. L’interopérabilité d’un programme Visual Basic est sa capacité à fonctionner dans différents systèmes d’exploitation et/ou versions .NET.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
41
pour découper l’exécution des requêtes LINQ qui s’exécutent en mémoire en différents threads afin d’optimiser leur traitement sur les systèmes à plusieurs processeurs et/ou cœurs.
∑
Le processus de gestion de la mémoire (Garbage Collector). Il a été amélioré, tant au niveau serveur que client. Côté serveur, la collecte de génération 21 génère une notification à laquelle il suffit de s’abonner. Lorsqu’une telle collecte a lieu, il suffit alors de répercuter le traitement sur une autre machine. Côté client, les collectes de génération 0, 1 et 2 se font en arrière-plan, et donc, n’occasionnent aucun temps de latence dans l’exécution de l’application.
∑
Corrupted State Exceptions. Certaines exceptions qui ne peuvent pas être capturées par le mécanisme Try Catch (par exemple les exceptions de type Invalid Memory, Stack Overflow ou encore A/V Exception) peuvent désormais être capturées à l’aide d’un nouveau type de gestion des exceptions : Corrupted State Exceptions.
∑
Historical debogger. Lors du débogage d’une application, toute la session de débogage est enregistrée. Cette nouvelle fonctionnalité, appelée "historical debogger", permet de rejouer autant de fois que nécessaire la session afin de trouver d’où vient le problème.
∑ ∑
Le débogueur. Il supporte désormais le 64-bit en mixed-mode, pour le live et les dumps. Contraintes. Il est désormais possible de définir des contraintes avant (Requires), pendant (Invariant) et après (Ensures) l’exécution d’une méthode. Tous les tests unitaires liés aux contraintes peuvent alors être générés automatiquement.
Dans ce chapitre, nous allons passer en revue les évolutions majeures de l’environnement de développement Visual Studio 2010, ainsi que les principales nouveautés, évolutions et facilités d’écriture de la version 10 de Visual Basic. Nous rappellerons également les techniques évoluées de Visual Studio 2008/Visual Basic 2008, toujours en vigueur dans Visual Studio 2010/Visual Basic 2010.
Innovations de l’environnement de développement En quelques pages, nous allons lister les principales innovations de l’environnement de développement.
Intégration de WPF dans l’IDE L’environnement de développement de Visual Studio 2010 a été entièrement réécrit en tirant parti de la technologie WPF (Windows Presentation Foundation). De cette évolution 1. Les collectes de génération 0 et 1 concernent les petits objets. Elles sont rapides car le segment traité est de petite taille. Par contre, les collectes de génération 2 concernent les objets de grande taille et peuvent introduire des temps de latence dans l’exécution d’une application.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
42
Visual Basic 2010
ergonomique découle la possibilité d’utiliser plusieurs écrans. Le cas échéant, vous pouvez y répartir à votre gré les différentes fenêtres qui composent l’IDE (voir Figure 3.1). Figure 3.1 Les éléments de l’IDE peuvent être répartis sur plusieurs écrans.
Dans chacune des fenêtres de l’IDE, une icône en forme de flèche orientée vers le bas (dans l’angle supérieur droit de la fenêtre), vous permet d’ancrer, de laisser flotter ou de cacher la fenêtre (voir Figure 3.2). Pour déplacer une fenêtre flottante (éventuellement sur un autre écran), il suffit de pointer sa barre de titre et d’utiliser la technique de glisser-déposer de Windows. Figure 3.2 Choix de la position d’une fenêtre.
Projets fondés sur des modèles Lorsque vous définissez un nouveau projet, il est par défaut basé sur les modèles installés sur l’ordinateur. En sélectionnant l’entrée Modèles en ligne, dans la partie inférieure gauche de la fenêtre Nouveau projet, vous pouvez étendre les modèles existants avec ceux proposés en ligne par Microsoft (voir Figure 3.3).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
43
Figure 3.3 Un nouveau projet peut être basé sur un modèle en ligne. Ici, par exemple, un économiseur d’écran WPF qui affiche les posts d’un flux Twitter.
Info
Lorsque vous ajoutez un élément à votre projet, il est également possible de le piocher dans les éléments disponibles sur l’ordinateur ou dans la bibliothèque en ligne, en cliquant sur l’entrée Modèles en ligne dans la boîte de dialogue Ajouter un nouvel élément.
Gestion des projets récents Lorsque vous lancez Visual Studio, les projets récemment ouverts sont directement accessibles dans la page de démarrage (voir Figure 3.4). Un clic suffit pour retourner au projet sur lequel vous travailliez la veille. Figure 3.4 Les projets récents sont directement accessibles sur la page de démarrage.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
44
Visual Basic 2010
Si vous cliquez du bouton droit sur un projet récent, vous pouvez l’ouvrir dans Visual Studio, ouvrir le dossier dans lequel il est stocké ou le supprimer de la liste des projets récents (voir Figure 3.5). Figure 3.5 Le menu contextuel des projets récents.
Il est également possible d’ancrer un projet dans la liste en cliquant devant son icône. Une punaise s’affiche pour matérialiser sa persistance.
Multitargetting Lorsque vous lancez la commande Nouveau/Projet dans le menu Fichier pour concevoir un nouveau projet Visual Basic 2010, la boîte de dialogue Nouveau projet apparaît. Utilisez la liste déroulante affichée dans la partie supérieure droite de la boîte de dialogue pour choisir le Framework cible : 2.0, 3.0, 3.5 ou 4.0 (voir Figure 3.6). Figure 3.6 Choisissez le Framework à utiliser.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Info
Nouveautés et concepts utiles du langage et de l’environnement
45
Un projet créé avec une version précédente de Visual Basic peut être complété dans Visual Studio 2010. Les anciens composants, basés sur les versions 1.0, 1.1 et/ou 2.0 du CLR continueront à fonctionner comme auparavant. Les composants ajoutés dans le projet et basés sur la version 4.0 du CLR cohabiteront avec eux sans qu’aucun problème de compatibilité n’apparaisse : différentes versions du CLR peuvent en effet être abritées dans un seul et même process.
Zoom dans le code L’éditeur de code de Visual Studio 2010 implémente (enfin !) la fonctionnalité de zoom rapide avec la roulette de la souris. Il vous suffit désormais de maintenir la touche Ctrl enfoncée et d’utiliser la roulette pour modifier le facteur de zoom du code. Cette technique se révèle très pratique, notamment lors de présentations et de démonstrations.
Intellisense L’intellisense est une fonctionnalité très intéressante qui vous permet d’écrire du code plus rapidement et de façon plus exacte. Dès que vous commencez à taper un mot-clé reconnu par le compilateur, il affiche le modèle qui permettra de compléter l’instruction en cours (voir Figure 3.7). Figure 3.7 L’intellisense de Visual Basic 2010.
Lorsque vous poursuivez la frappe, l’intellisense s’adapte automatiquement au contenu. Cette fonctionnalité est utilisable lors de développement VB.NET et XAML. Elle a également été améliorée pour le langage JavaScript : non content de proposer les variables et fonctions écrites par l’utilisateur, Intellisense inclut désormais les objets gérés dynamiquement. À noter que les commentaires sont également pris en charge par cette fonctionnalité.
Naviguer vers La commande Naviguer vers du menu Édition (ou le raccourci Ctrl+,) donne accès à une boîte de dialogue de recherche évoluée qui complète à merveille l’ancienne boîte de
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
46
Visual Basic 2010
d ialogue Rechercher et remplacer. Entrez un terme dans la zone de texte Rechercher les termes, et les résultats correspondants apparaissent dans la partie centrale de la boîte de dialogue Naviguer vers (voir Figure 3.8). Figure 3.8 La boîte de dialogue Naviguer vers est bien plus pratique et directe que la boîte de dialogue Rechercher et remplacer.
Il vous suffit de sélectionner un des résultats et de cliquer sur OK pour ouvrir le code source correspondant et y surligner l’objet de la recherche. Si nécessaire, vous pouvez utiliser :
∑
les caractères de remplacement "?" et "*" pour remplacer (respectivement) un caractère quelconque et un nombre quelconque de caractères dans l’élément recherché ;
∑ ∑
plusieurs mots pour affiner votre recherche ; une ou plusieurs lettres majuscules pour rechercher les termes qui contiennent les majuscules spécifiées (par exemple, MU identifiera les objets Form1_MouseUp(), Form2_ MouseUp(), mais également, si elle existe, la fonction MindUp().
Surbrillance des références Le simple fait de cliquer sur un nom de variable, un paramètre ou un champ provoque la mise en surbrillance des mêmes éléments dans le reste du code (voir Figure 3.9). Pour vous déplacer rapidement d’une occurrence à la suivante, vous utiliserez le raccourci Ctrl+Maj+Bas. Pour atteindre l’occurrence précédente, vous utiliserez le raccourci Ctrl+ Maj+Haut.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
47
Figure 3.9 Il a suffi de cliquer sur une des occurrences de la variable OutilEnCours pour que les autres occurrences soient surlignées dans le code.
Info
Une fois arrivé à la dernière occurrence d’une référence, le raccourci Ctrl+Maj+Bas affiche la première occurrence dans le code. Inversement, une fois arrivé à la première occurrence d’une référence, le raccourci Ctrl+Maj+Haut affiche la dernière occurrence dans le code.
Recherche des références Pour avoir un aperçu des méthodes qui appellent et qui sont appelées par un élément (méthode, attribut ou variable), il suffit de cliquer du bouton droit sur cet élément et de sélectionner Rechercher toutes les références dans le menu contextuel. Vous pouvez également double-cliquer sur l’élément et appuyer sur Maj+F12 pour parvenir au même résultat (voir Figure 3.10). Figure 3.10 Il a suffi de cliquer sur une des occurrences de la variable OutilEnCours pour que les autres occurrences soient surlignées dans le code.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
48
Visual Basic 2010
Générer à partir de l’utilisation Avec Visual Studio 2010, il est désormais possible de définir une déclaration de fonction pendant l’écriture du code qui appelle cette fonction. Le code définitif de la fonction pourra alors être défini dans un deuxième temps. À la Figure 3.11 par exemple, la fonction calcul() est appelée dans la solution Premier alors qu’elle n’a pas encore été définie. Le mot calcul est automatiquement souligné d’une ligne ondulée bleue et d’un marqueur rectangulaire rouge. Figure 3.11 La fonction calcul() n’a pas encore été implémentée.
Pointez le marqueur pour faire apparaître l’icône d’options de correction d’erreur. Cliquez sur cette icône, puis sur l’entrée Générer un stub de méthode pour ‘calcul’ dans ‘Premier. Form1’ (voir Figure 3.12). Figure 3.12 Le rectangle rouge donne accès aux options de correction d’erreur.
Le squelette de la fonction calcul() est alors automatiquement créé en s’adaptant aux contraintes imposées par le code. Ici, passage d’un Double et récupération d’un String (voir Figure 3.13). Figure 3.13 La fonction calcul() a été générée à partir de son utilisation.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
49
Gestionnaire d’extensions Le Gestionnaire d’extensions de Visual Studio 2010 permet de télécharger et d’installer des "extensions" en ligne, proposées par Microsoft ou par des utilisateurs de Visual Studio. Ces extensions vont des contrôles aux modèles en passant par divers types d’outils. Pour accéder aux extensions en ligne, lancez la commande Gestionnaire d’extensions dans le menu outils, sélectionnez l’onglet Galerie en ligne, choisissez un type d’extensions dans le volet gauche, une extension dans le volet central et cliquez sur le bouton Télécharger correspondant (voir Figure 3.14). Figure 3.14 Le contrôle ComponentOne Studio for iPhone est sur le point d’être téléchargé.
Info
Il existe un grand nombre d’extensions disponibles sur le Web. Si vous connaissez le nom (complet ou partiel) de l’extension recherchée, il est pratique d’utiliser la case de recherche, dans la partie supérieure droite du Gestionnaire d’extensions, comme vous le feriez dans une fenêtre de l’Explorateur de fichiers de Windows 7 ou Vista.
Data Binding avec un glisser-déposer dans WPF Après avoir ajouté une source de données à un projet WPF, de simples glisser-déposer permettent de relier les contrôles Windows Presentation Foundation aux champs de données (voir Figure 3.15).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
50
Visual Basic 2010
Figure 3.15 Le Data Binding se fait par simples copier-coller depuis la source de données.
Débogage Intellitrace Traditionnellement, lorsqu’une exception se produit dans une application, le programmeur insère des points d’arrêt dans le code pour localiser l’instruction ou le groupe d’instructions qui pose problème. À partir de ces points d’arrêt, il teste la valeur des variables et objets qu’il soupçonne être à la source du problème. La recherche du bogue se fait alors par dichotomies successives. Son aboutissement est lié aux connaissances du programmeur et à la complexité du code. Il peut parfois nécessiter de longues minutes pour aboutir ! Le débogage Intellitrace est une nouveauté de Visual Studio 2010 édition Ultimate. Précédemment connue sous le nom d’"Historical Debugger", cette fonctionnalité permet de déboguer une application en enregistrant les événements différents événements qui s’y produisent, ou en journalisant de façon automatique les appels de méthodes (trace) et la navigation dans ces traces. Cette fonctionnalité dépasse le cadre de cet ouvrage, qui se limite à l’édition professionnelle de Visual Studio 2010. Si vous travaillez avec l’édition Ultimate, vous pouvez vous reporter à l’article MSDN "Débogage avec Intellitrace", à l’adresse http://msdn.microsoft.com/fr-fr/library/dd264915.aspx.
Publication en un clic Visual Studio 2010 est en mesure de réaliser un interfaçage direct d’IIS pour déployer un site ASP.NET en un simple clic de souris.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
51
Pour arriver à cette prouesse, une étape d’initialisation est nécessaire. Cliquez du bouton droit sur une barre d’outils de Visual Studio et sélectionnez Publication web en un clic. Dans cette nouvelle barre d’outils, déroulez la liste Publier et sélectionnez . Paramétrez la boîte de dialogue Publier le site web en accord avec la méthode de publi cation et les paramètres de votre site (voir Figure 3.16). Figure 3.16 Le site ASP.NET en cours d’édition va être publié sur un serveur FTP.
Une fois le paramétrage effectué, il vous suffira de cliquer sur l’icône Publier le site web de la barre d’outils Publication web en un clic pour que votre application soit publiée sur le serveur ciblé. Pendant la publication, la fenêtre Sortie vous tiendra au courant des actions effectuées : ------ Début de la génération : Projet : WebApplication1, Configuration : „ Debug Any CPU -----WebApplication1 -> c:\users\x4\documents\visual studio „ 2010\Projects\WebApplication1\WebApplication1\bin\WebApplication1.dll ------ Démarrage de la publication : Projet : WebApplication1, Configuration : Debug Any CPU -----Connexion à ftp://ftp.ftp.monserveur.fr... Web.config transformé en obj\Debug\TransformWebConfig\transformed\Web.config avec „ Web.Debug.config. Copie de tous les fichiers à l’emplacement temporaire suivant pour le package/ „ la publication :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
52
Visual Basic 2010
obj\Debug\Package\PackageTmp. Publication du dossier / en cours... Publication du dossier Account en cours... Publication du dossier bin en cours... Publication du dossier Scripts en cours... Publication du dossier Styles en cours... ======= Génération : 1 a réussi ou est à jour, 0 a échoué, 0 a été ignoré ====== ======= Publication : 1 a réussi, 0 a échoué, 0 a été ignoré ==========
Tests unitaires Une des grandes nouveautés de Visual Studio 2010 est la possibilité de créer des tests unitaires. Par leur intermédiaire, il est possible de tester une fonction particulière d’un programme afin de mettre en évidence un ou plusieurs problèmes dans le code ou dans les données. Considérons le code suivant : Public Class Form1 Private Function calcul() As Single calcul = Rnd(1) * 2 + 1 End Function Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click Label3.Text = CStr(calcul()) End Sub End Class
La fonction calcul() retourne un Single aléatoire et la fonction événementielle Button1_ Click affiche, après conversion en un String, la valeur retournée par calcul() dans l’objet Label3. Supposons que la valeur retournée par calcul() doit être comprise entre 0 et 2. Nous allons définir un test unitaire sur la fonction Button1_Click() pour mettre en évidence un dysfonctionnement dans calcul(). Dans l’éditeur de code, cliquez du bouton droit sur la fonction Button1_Click() et sélectionnez Créer des tests unitaires dans le menu contextuel. La boîte de dialogue Créer des tests unitaires s’affiche. Sous Sélection actuelle, une arborescence affiche la hiérarchie de classes et de membres de l’assembly qui héberge la classe du projet. Dans l’exemple de la Figure 3.17, cette classe a pour nom Premier. Vous pouvez utiliser cette page pour générer des tests unitaires pour toute sélection de ces membres et pour choisir un projet de test dans lequel vous souhaitez placer les tests unitaires générés.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
53
Figure 3.17 Création d’un test unitaire sur la fonction Button1_ Click().
Cliquez sur OK pour valider la création du test unitaire. Après quelques instants, le projet de test apparaît dans l’Explorateur de solutions (voir Figure 3.18). Figure 3.18 Le projet de test TestProject1 a été ajouté à l’Explorateur de solutions.
Lancez la commande Fenêtres/Affichage des tests dans le menu Test pour afficher la fenêtre Affichage des tests. Dans cette fenêtre, cliquez sur le bouton Actualiser pour faire apparaître le test (voir Figure 3.19).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
54
Visual Basic 2010
Figure 3.19 Le test est accessible dans la fenêtre Affichage des tests.
Toujours dans la fenêtre Affichage des tests, cliquez du bouton droit sur Button1_ClickTest et sélectionnez Exécuter la sélection dans le menu contextuel. La fenêtre Résultats des tests donne son verdict (voir Figure 3.20). Figure 3.20 Le test n’est pas concluant.
Ce
résultat
provient
de
l’instruction
Assert.Inconclusive()
de
la
fonction
Button1_ClickTest() : Public Sub Button1_ClickTest() Dim target As Form1_Accessor = New Form1_Accessor() ‘ TODO: initialisez à „ une valeur appropriée Dim sender As Object = Nothing ‘ TODO: initialisez à une valeur appropriée Dim e As EventArgs = Nothing ‘ TODO: initialisez à une valeur appropriée target.Button1_Click(sender, e) Assert.Inconclusive("Une méthode qui ne retourne pas une valeur ne peut pas „ être vérifiée.") End Sub
Supprimez cette instruction et remplacez-la par une instruction de test du type suivant : Assert.AreEqual(1, target.calcul(), 1)
Cette instruction va tester si le résultat renvoyé par la fonction calcul() est compris entre 0 et 2 : le premier paramètre de Assert.AreEqual() représente la valeur cible, le deuxième, la valeur renvoyée par la fonction calcul() et le troisième la tolérance sur la valeur cible. Dans la fenêtre Affichage des tests, cliquez sur Actualiser pour mettre à jour le test en fonction de la modification du code. Cliquez du bouton droit sur Button1_ClickTest et sélectionnez Exécuter la sélection dans le menu contextuel.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
55
Selon la valeur tirée aléatoirement dans la fonction calcul(), vous pourrez avoir une réussite ou un échec, comme à la Figure 3.21. Figure 3.21 Le test a échoué.
Il est clair que l’erreur vient de la fonction calcul(). Pour solutionner le problème, l’instruction responsable du résultat pourrait être modifiée comme suit : calcul = Rnd(1) + 1
Cet exemple simpliste donne un aperçu des immenses possibilités des tests unitaires de Visual Studio 2010 : en quelques clics et en définissant le code de test approprié, vous pouvez trouver les causes du dysfonctionnement d’une fonction. Cette technique ne supprime en aucun cas l’intérêt de la méthode de débogage traditionnelle qui consiste à insérer des points d’arrêt dans le code et à tester les valeurs de variables ou de propriétés. Elle vient en complément et peut s’avérer plus efficaces dans certains cas. À vous de tester les deux techniques et de trouver celle qui vous convient le mieux dans chaque cas de figure.
Migrer un projet existant vers le Framework .NET 4.0 Si vous voulez modifier le code ou l’interface d’un projet basé sur une version précédente du Framework .NET en utilisant Visual Studio 2010, il vous suffit d’ouvrir ce projet dans Visual Studio 2010. Cette action provoque l’exécution de l’Assistant Conversion de Visual Studio (voir Figure 3.22). Figure 3.22 La commande Fichier > Ouvrir > Projet > Solution a provoqué l’exécution de l’Assistant Conversion.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
56
Visual Basic 2010
Cliquez sur Suivant et validez la création d’une sauvegarde avant conversion (voir Figure 3.23). Figure 3.23 Le projet original sera sauvegardé avant d’opérer la conversion.
Cliquez sur Suivant puis sur Terminer. Après quelques instants, l’Assistant vous informe du statut de la conversion. Le cas échéant, consultez le journal de conversion pour visualiser les avertissements ou erreurs rencontrés lors de la conversion (voir Figure 3.24). Après conversion, la version précédente du Framework continuera à être utilisée et vous pourrez travailler avec Visual Studio 2010 comme si de rien n’était. Si vous voulez utiliser les nouvelles possibilités offertes par le Framework 4.0, vous devrez modifier le Framework cible. Ouvrez le projet, double-cliquez sur l’icône My Project dans l’Explorateur de solutions, sélectionnez l’onglet Compiler, cliquez sur Options avancées de compilation, dans la partie inférieure de la page, sélectionnez .NET Framework 4 Client Profile dans la liste déroulante Framework cible et validez en cliquant sur OK.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
57
Figure 3.24 La conversion s’est bien déroulée.
Figure 3.25 Modification du Framework cible.
Innovations du langage Visual Basic 2010 De nombreuses améliorations ont été apportées au langage Visual Basic 2010. Nous allons passer en revue les plus importantes dans cette section.
Continuation de ligne implicite Jusqu’à la version 2010 de Visual Basic, les lignes trop longues devaient être prolongées par l’intermédiaire du caractère de continuation "_".
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
58
Visual Basic 2010
Désormais, il est tout à fait possible d’écrire quelque chose comme ceci sans provoquer d’erreur de syntaxe : Private Sub Button1_Click( ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click End Sub
Implémentation automatique des propriétés Pour définir une propriété à l’aide de code Visual Basic 2008 ou inférieur, vous deviez utiliser quelque chose comme ceci : Private _nombre As Integer = 0 Public Property MonNombre As Integer ‘ Récupération de "_nombre" Get Return _nombre End Get ‘ Affectation à "_nombre" Set _nombre = valeur End Set End Property
Désormais, avec Visual Basic 2010, la syntaxe est bien plus simple : Property MonNombre as Integer
Pour affecter une valeur par défaut à une propriété, vous utiliserez la syntaxe suivante : Property Ville As String = "Paris"
Pour instancier un objet, vous utiliserez la syntaxe suivante : Property Villes As New List(Of String)
Initialiseurs de collections En Visual Basic 9, l’instruction With simplifiait l’accès aux différents membres d’un objet (collection, tableau). À titre d’exemple, le code ci-après crée un tableau de capitales et l’initialise avec quatre lignes de données : Partial Class pays Public Nom As String Public Pays As String
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
59
End Class Dim Capitales = New Ville() { _ New Ville With { _ .Nom = "Paris", _ .Pays = "France"}, _ New Ville With { _ .Nom = "Londres", _ .Pays = "Royaume-Uni"}, _ New Ville With { _ .Nom = "Madrid", _ .Pays = "Espagne"}, _ New Ville With { _ .Nom = "Washington", _ .Pays = "Etats-Unis"} _ }
Grâce à l’instruction With, l’écriture des éléments "Ville.Nom" et "Ville.Pays" est simplifiée en ".Nom" et ".Pays". L’initialisation d’objets fonctionne également pour les objets créés dans les classes du projet. À titre d’exemple, nous allons créer un nouveau projet de type Application Windows Forms. Nous ajoutons une nouvelle classe dans ce projet que nous nommons Ville. Nous ajoutons deux propriétés à la classe Ville que nous nommons Nom et Pays : Public Class Ville Private intNom As String Public Property Nom() As String Get Return intNom End Get Set(ByVal value As String) intNom = value End Set End Property Private intPays As String Public Property Pays() As String Get Return intPays End Get Set(ByVal value As String)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
60
Visual Basic 2010
intPays = value End Set End Property End Class
Info
Pour créer une propriété dans une classe, il suffit de taper Property, d’appuyer sur la touche Tab du clavier et de changer les valeurs à la suite des mots P rivate et Property.
Retournons au code de la classe principale du projet. Pour créer et manipuler un objet de classe Ville en Visual Basic 9, vous faisiez quelque chose comme ceci : Dim Capitale As New Ville Capitale.Nom = "Paris" Capitale.Pays = "France"
En Visual Basic 2010, le code deviendra : Dim Capitale = New Ville With _ {.Nom = "Paris", .Pays = "France"}
Info
Il n’est pas nécessaire d’initialiser toutes les propriétés dans les accolades : elles pourront être définies dans la suite du code.
En Visual Basic 10, l’initialisation de collections est encore plus simple, grâce au mot-clé From. Dim capitales = New New Capitale With New Capitale With New Capitale With New Capitale With }
List (Of Capitale) From { {.Nom = "Paris", .Pays = "France"}, {.Nom = "Londres", .Pays = "Royaume-Uni"}, {.Nom = "Madrid", .Pays = "Espagne"}, {.Nom = "Washington", .Pays = "Etats-Unis"}
Syntaxe simplifiée pour déclarer des tableaux L’inférence de type simplifie grandement la déclaration des tableaux : Dim tab1 = {12, 25, 19} Dim tab2 = {12.2, 6.5}
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
61
Dim tab3 = {1, tab2, "texte"} Dim tab4 = {"texte 1", "texte 2", "texte 3"} Console.WriteLine("Type Console.WriteLine("Type Console.WriteLine("Type Console.WriteLine("Type
de de de de
tab1 tab2 tab3 tab4
: : : :
" " " "
& & & &
tab1.ToString()) tab2.ToString()) tab3.ToString()) tab4.ToString())
Voici l’affichage dans la fenêtre Sortie Type Type Type Type
Info
de de de de
tab1 tab2 tab3 tab4
: : : :
System.Int32[] System.Double[] System.Object[] System.String[]
Cette syntaxe s’étend également aux tableaux multidimensionnels.
Expressions Lambda multilignes et sous-routine Une expression Lambda est une fonction sans nom qui renvoie une valeur unique. À titre d’exemple, l’expression Lambda suivante consiste en une fonction qui admet un argument entier et qui renvoie un calcul réel basé sur cet argument : Dim monExpressionLambda = Function(nombre As Integer) (nombre + 7) / 3
Pour appeler l’expression Lambda, il suffit de préciser son nom et son argument. Par exemple : Console.WriteLine(monExpressionLambda(12))
Visual Basic 2010 permet désormais d’écrire une expression Lambda sur plusieurs lignes. Considérez le code suivant : Dim monExpressionLambda = Function(nombre As Integer) As String If (nombre > 10) Then Return "est supérieur à 10" Else Return "est inférieur ou égal à 10" End If End Function
Dans cet exemple, le code de la fonction lambda repose sur une structure If Then Else. Si nécessaire, il peut être bien plus complexe et compter autant de lignes que nécessaires.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
62
Visual Basic 2010
Cette possibilité n’est pas la seule nouveauté liée aux expressions Lambda : désormais, le compilateur de Visual Basic 2010 autorise également les expressions Lambda de types Sub. Le code suivant est donc tout à fait licite : Dim monExpressionLambda = Sub(nombre As Integer) If (nombre > 10) Then TextBox1.Text = "Argument > 10" Else TextBox1.Text = "Argument
Chapitre 3
∑ ∑ ∑
Nouveautés et concepts utiles du langage et de l’environnement
125
NomDossier est le nom du dossier dans lequel vous voulez effectuer la recherche. InclureSousDossiers vaut True pour inclure les éventuels sous-dossiers dans la recherche, et False pour les exclure. Modèle est le modèle de la recherche (ce modèle peut contenir un ou plusieurs caractères de remplacement : ? pour remplacer un caractère unique ; * pour en remplacer un nombre quelconque).
Nombre de fichiers dans un dossier Pour connaître le nombre de fichiers contenus dans un dossier, vous utiliserez la propriété Count de la fonction My.Computer.FileSystem.GetFiles(). À titre d’exemple, les lignes de code suivantes affichent dans un contrôle Label le nombre de fichiers contenus dans le dossier c:\ : Dim Dossier as String = "c:\" Dim fichiers As System.Collections.ObjectModel.ReadOnlyCollection(Of String) fichiers = My.Computer.FileSystem.GetFiles(Dossier) Label1.Text = "Le dossier " + Dossier + "contient " + CStr(fichiers.Count) + "fichiers."
La première instruction définit la variable String Dossier et y stocke le chemin de recherche : Dim Dossier as String = "c:\"
La deuxième instruction définit l’objet fichiers de type ReadOnlyCollection(Of String) : Dim fichiers As System.Collections.ObjectModel.ReadOnlyCollection(Of String)
La troisième instruction interroge la fonction GetFiles() pour connaître les fichiers contenus dans le dossier "c:\" : fichiers = My.Computer.FileSystem.GetFiles(Dossier)
Enfin, la quatrième instruction affiche le nombre de fichiers renvoyés par GetFiles() à l’aide de la propriété Count : Label1.Text = "Le dossier " + Dossier + "contient " + CStr(fichiers.Count) „ + "fichiers."
Info
Il est possible de compter les fichiers contenus dans les sous-dossiers du dossier spécifié dans le dossier de recherche. Il suffit pour cela d’ajouter la valeur True en deuxième argument de la fonction GetFiles(). En ajoutant un troisième argument chaîne contenant un modèle de sélection, vous pouvez limiter le comptage aux fichiers qui respectent ce modèle1.
1. Le modèle peut inclure un ou plusieurs caractères de remplacement : ? pour remplacer un caractère unique ; * pour en remplacer un nombre quelconque.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
126
Visual Basic 2010
Informations sur un fichier La fonction My.Computer.FileSystem.GetFileInfo() renvoie un objet FileInfo permettant de connaître différentes informations au sujet du fichier spécifié en argument. À titre d’exemple, les lignes de code ci-après affichent quelques informations sur le fichier c:\test\data.txt dans un contrôle TextBox : Dim st As String Dim info As System.IO.FileInfo = My.Computer.FileSystem.GetFileInfo „ ("c:\test\data.txt") st st st st st st st st
= = = = = = = =
"Dossier : " + info.DirectoryName + vbCrLf st + "Nom complet : " + info.FullName + vbCrLf st + "Nom du fichier : " + info.Name + vbCrLf st + "Taille du fichier : " + info.Length.ToString + " octets" + vbCrLf st + "Attributs : " + info.Attributes.ToString + vbCrLf st + "Date de création : " + info.CreationTime + vbCrLf st + "Dernier accès : " + info.LastAccessTime + vbCrLf st + "Dernière sauvegarde : " + info.LastWriteTime + vbCrLf
TextBox1.Text = st
La première ligne définit l’objet String st dans lequel seront stockées les informations concernant l’objet info : Dim st As String
La deuxième ligne affecte la valeur retournée par la fonction GetFileInfo() à l’objet System.IO.FileInfo information : Dim information As System.IO.FileInfo information = My.Computer.FileSystem. „ GetFileInfo("c:\test\data.txt")
Le bloc d’instructions suivant extrait les informations de l’objet info en interrogeant ses propriétés. Par exemple, pour connaître la taille du fichier c:\test\data.txt, il suffit de lire la propriété Length : st = st + "Taille du fichier : " + info.Length.ToString + " octets" + vbCrLf
Une fois que toutes les données souhaitées ont été extraites (et éventuellement converties au format chaîne à l’aide de l’opérateur ToString), elles s’affichent dans le contrôle TextBox : TextBox1.Text = st
Voici un exemple d’informations obtenues par l’intermédiaire de l’objet System. IO.FileInfo et de la fonction GetFileInfo() :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
127
Dossier : c:\ Nom complet : c:\test\data.txt Nom du fichier : data.txt Taille du fichier : 294 octets Attributs : Archive Date de création : 21/03/2010 09:07:10 Dernier accès : 21/03/2010 09:07:10 Dernière sauvegarde : 21/03/2010 09:07:14
Les objets System.IO.FileInfo possèdent de nombreuses propriétés. Pour faciliter leur utilisation, n’hésitez pas à employer la fonctionnalité AutoComplete et les bulles d’aide associées (voir Figure 3.70).
Info
Figure 3.70 AutoComplete et les bulles d’aide vous assisteront pour écrire votre code de façon intuitive.
Informations sur un dossier Pour obtenir des informations sur un dossier, il suffit d’invoquer la fonction My.Computer. FileSystem.GetDirectoryInfo() en spécifiant son chemin complet dans l’argument. GetDirectoryInfo() renvoie un objet DirectoryInfo dont il suffit alors de parcourir les propriétés. Dim st As String Dim Info As System.IO.DirectoryInfo = My.Computer.FileSystem. GetDirectoryInfo("C:\Program Files") st st st st st st
= = = = = =
"Nom st + st + st + st + st +
du dossier : " + Info.Name + vbCrLf "Ce dossier existe : " + Info.Exists.ToString "Attributs : " + Info.Attributes.ToString + vbCrLf "Date de création : " + info.CreationTime + vbCrLf "Dernier accès : " + info.LastAccessTime + vbCrLf "Dernière sauvegarde : " + Info.LastWriteTime + vbCrLf
TextBox1.Text = st
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
128
Visual Basic 2010
Après avoir déclaré un objet String st : Dim st As String
l’objet System.IO.DirectoryInfo Info est défini par l’intermédiaire de la fonction GetDirectoryInfo() : Dim Info As System.IO.DirectoryInfo = My.Computer.FileSystem. GetDirectoryInfo("C:\Program Files")
Le bloc d’instructions suivant interroge les propriétés de l’objet Info pour obtenir les informations souhaitées, par exemple le type du dossier : st = st + "Attributs : " + Info.Attributes.ToString + vbCrLf
Une fois que toutes les informations ont été récupérées et stockées dans la chaîne st, elles apparaissent dans une zone de texte multiligne : TextBox1.Text = st
Voici un exemple d’informations obtenues par l’intermédiaire de l’objet System. IO.DirectoryInfo et de la fonction GetDirectoryInfo() : Nom du dossier : Program Files Ce dossier existe : TrueAttributs : ReadOnly, Directory Date de création : 15/11/2010 07:12:31 Dernier accès : 25/12/2010 19:44:47 Dernière sauvegarde : 19/12/2010 10:59:50
Documents et fichiers récents Windows mémorise la liste des documents utilisés récemment. Cette liste apparaît partiellement dans le menu Démarrer. Si vous le souhaitez, vous pouvez consulter une liste bien plus complète en faisant appel à la fonction DirectoryInfo().GetFiles et en la filtrant par une requête LINQ. Consultez la section intitulée "Liste des documents récents" au Chapitre 27 pour avoir plus d’informations sur le code à utiliser. Une technique similaire permet de lister les fichiers créés depuis un jour, une semaine, un mois ou une tout autre période. Consultez la section intitulé "Liste des fichiers créés ces quinze derniers jours" au Chapitre 27 pour en savoir plus. Nom d’une unité de stockage de masse Pour obtenir des informations sur une unité de stockage de masse (disquette, disque dur, CD, DVD, clé USB, etc.), vous utiliserez la fonction My.Computer.FileSystem.GetDriveInfo() en spécifiant la lettre d’unité dans l’argument. GetDriveInfo() renvoie un objet DriveInfo dont il suffit alors de parcourir les propriétés.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
129
Ces quelques lignes de code affichent des informations sur l’unité "c:\" : Dim st As String Dim disque As System.IO.DriveInfo = My.Computer.FileSystem.GetDriveInfo("c:\") st = "Nom du volume : " + disque.VolumeLabel + vbCrLf st = st + "Dossier racine : " + disque.RootDirectory.ToString + vbCrLf st = st + "Système de fichiers : " + disque.DriveFormat + vbCrLf st = st + "Type du disque : " + disque.DriveType.ToString + vbCrLf st = st + "Espace disponible : " + disque.AvailableFreeSpace.ToString + " octets" „ + vbCrLf TextBox1.Text = st
Après avoir déclaré l’objet String st : Dim st As String
la fonction My.Computer.FileSystem.GetDriveInfo() est invoquée pour obtenir des informations sur le disque c:\. Le résultat de la fonction est stocké dans l’objet System. IO.DriveInfo disque : Dim disque As System.IO.DriveInfo = My.Computer.FileSystem.GetDriveInfo("c:\")
Le bloc d’instructions suivant interroge les propriétés de l’objet DriveInfo disque et stocke les valeurs renvoyées dans la chaîne st. Par exemple, pour connaître l’espace disponible sur l’unité, il suffit de consulter la propriété AvailableFreeSpace : st = st + "Espace disponible : " + disque.AvailableFreeSpace.ToString + " octets" „ + vbCrLf
La dernière instruction affiche le résultat dans la zone de texte multiligne TextBox1 : TextBox1.Text = st
Voici un exemple d’informations retournées lorsque l’unité interrogée est un disque dur : Nom du volume : Disque principal Dossier racine : C:\ Système de fichiers : NTFS Type du disque : Fixed Espace disponible : 30 703 894 528 octets
Les informations renvoyées sont très différentes lorsque l’unité interrogée est un lecteur de CD-ROM contenant un CD audio : Nom du volume : Audio CD Dossier racine : D:\ Système de fichiers : CDFS Type du disque : CDRom Espace disponible : 0 octet
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
130
Visual Basic 2010
Accès aux feuilles du projet L’objet My.Forms donne accès aux feuilles définies dans un projet :
∑ ∑ ∑
My.Forms.Form1 représente la première feuille de l’application. My.Forms.Form2 représente la deuxième feuille de l’application. My.Forms.MaFeuille représente une des feuilles de l’application renommée en MaFeuille – propriété (Name). Utilisez la fonctionnalité Intellisense et les bulles d’aide de Visual Studio pour accéder aux propriétés, procédures et fonctions d’un objet My.Forms (voir Figure 3.71). Figure 3.71 Intellisense et les bulles d’aide sont très appréciables pendant l’écriture du code.
Accès au clavier L’objet My.Computer.Keyboard donne accès au clavier. Vous l’utiliserez pour tester les touches pressées et/ou actives et pour simuler l’appui sur les touches de votre choix. Pour tester les touches spéciales du clavier, employez les propriétés de l’objet My.Computer. Keyboard, comme indiqué dans le tableau ci-après. Propriété de My.Computer.Keyboard
True si…
AltKeyDown
Touche Alt enfoncée
CapsLock
Touche Verr Maj active
CtrlKeyDown
Touche Ctrl enfoncée
NumLock
Touche Verr Num active
ScrollLock
Touche Arrêt défil active
ShiftKeyDown
Touche Maj enfoncée
À titre d’exemple, cette ligne de code affiche une boîte de dialogue si la touche Maj est enfoncée au moment du test : If My.Computer.Keyboard.ShiftKeyDown Then MsgBox("La touche Maj est enfoncée")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
131
Pour simuler l’appui sur une ou plusieurs touches du clavier, employez la fonction SendKeys(). Cette fonction admet deux syntaxes : My.Computer.Keyboard. SendKeys("texte à envoyer") My.Computer.Keyboard. SendKeys("texte à envoyer", attente)
où attente peut prendre l’une des valeurs True (attente de la prise en compte des touches frappées avant de poursuivre) ou False (poursuite du programme sans attendre). À titre d’exemple, ces quelques lignes de code ouvrent le Bloc-Notes de Windows et lui "envoient" un court texte : Dim Processus As Integer Processus = Shell("notepad.exe", AppWinStyle.NormalFocus) AppActivate(Processus) My.Computer.Keyboard.SendKeys("Ce texte est envoyé au Bloc-Notes" + vbCrLf + vbCrLf) My.Computer.Keyboard.SendKeys("par Visual Basic 2010", True)
La première instruction définit la variable Integer Processus : Dim Processus As Integer
Cette variable est utilisée pour obtenir l’identifiant d’un processus créé avec la fonction Shell() : Processus = Shell("notepad.exe", AppWinStyle.NormalFocus)
Pour lancer l’application correspondante, il suffit d’invoquer AppActivate() : AppActivate(Processus)
Plusieurs éléments textuels sont alors envoyés au Bloc-Notes : My.Computer.Keyboard.SendKeys("Ce texte est envoyé au Bloc-Notes" + vbCrLf + vbCrLf) My.Computer.Keyboard.SendKeys("par Visual Basic 2010", True)
La Figure 3.72 représente la fenêtre du Bloc-Notes après l’exécution de ces quelques instructions. Figure 3.72 Le texte spécifié dans les procédures SendKeys() a bien été envoyé au Bloc-Notes.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
132
Visual Basic 2010
Accès à la souris L’objet My.Computer.Mouse donne accès à trois propriétés concernant la souris : Propriété
Effet
ButtonSwapped
True si les boutons gauche et droit de la souris sont inversés, sinon False.
WheelsExists
True si la souris est dotée d’une roulette, sinon False.
WheelScrollLines
Amplitude de la rotation de la roulette.
Accès au réseau L’objet My.Computer.Network donne accès à de nombreuses fonctionnalités concernant le réseau local et la liaison Internet. Vérifier l’état du réseau Pour savoir si l’ordinateur est relié à un réseau local ou à Internet, vous testerez la propriété IsAvailable de l’objet My.Computer.NetWork : If My.Computer.Network.IsAvailable then Label1.Text = "L’ordinateur est relié à un réseau local et/ou à Internet" Else Label1.Text = "L’ordinateur n’est relié ni à un réseau local ni à Internet" End If
Vérifier la disponibilité d’un ordinateur Pour vérifier la disponibilité d’un ordinateur1 dont vous connaissez l’adresse IP ou URL, il suffit d’appeler la fonction Ping(). La valeur retournée est True si l’ordinateur répond au ping, et False dans le cas contraire. If My.Computer.Network.Ping("192.168.0.125") then Label1.Text = "L’ordinateur 192.168.0.125 a répondu au ping" Else Label1.Text = "L’ordinateur 192.168.0.125 n’a pas répondu au ping" End If
1. Cet ordinateur peut faire partie du réseau local ou être connecté à Internet.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Info
Nouveautés et concepts utiles du langage et de l’environnement
133
Si vous ne connaissez pas l’adresse IP de l’ordinateur que vous voulez tester, ouvrez une fenêtre Invite de commandes. Sous Windows 7 ou Vista, cliquez sur Démarrer, tapez invite puis cliquez sur Invite de commandes. Sous Windows XP, cliquez sur Démarrer, sélectionnez Tous les programmes, Accessoires, puis Ligne de commande dans le menu Démarrer. Tapez ipconfig et appuyez sur la touche Entrée du clavier. L’adresse IP de l’ordinateur apparaît clairement (voir Figure 3.73).
Figure 3.73 L’adresse IP de cet ordinateur est 192.168.1.64.
Si l’ordinateur destinataire du ping se trouve sur Internet, vous pouvez spécifier un délai de retour maximal en millisecondes. Par exemple, pour savoir si le site www.monsite.com répond en moins de 500 millisecondes, utilisez l’instruction If de la façon suivante : If My.Computer.Network.Ping("www.monsite.com", 500) then Label1.Text = "La page www.monsite.com a répondu dans le délai imparti" Else Label1.Text = "La page www.monsite.com n’a pas répondu dans les 500 ms imparties" End If
Envoyer un fichier sur un serveur Pour envoyer un fichier sur un serveur FTP ou HTTP, vous utiliserez la procédure UploadFile() : My.Computer.Network.UploadFile("NomFichier", "AdresseServeur", "NomUtilisateur", „ "MotPasse", Interface, TimeOut)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
134
Visual Basic 2010
où :
∑ ∑
NomFichier est le nom complet du fichier à envoyer. AdresseServeur est l’adresse FTP ou HTTP du serveur sur lequel le fichier doit être
copié.
∑ ∑ ∑
NomUtilisateur est le nom à fournir au serveur pour accéder au compte (si nécessaire).
∑
TimeOut définit le délai de réponse maximal du serveur, en millisecondes.
MotPasse est le mot de passe à fournir au serveur pour accéder au compte (si nécessaire). Interface est une valeur booléenne qui indique si l’indicateur de progression du trans-
fert doit (True) ou ne doit pas (False) être affiché.
Supposons que le fichier c:\test\vide.bmp doive être transféré sur les pages perso FTP Free de l’utilisateur bertrand.lebolduc en utilisant le mot de passe "cadeau". L’instruction à utiliser est la suivante : My.Computer.Network.UploadFile("C:\test\vide.bmp", "ftp://ftpperso.free.fr/vide. „ bmp", "bertrand.lebolduc", "cadeau", True, 500)
Lorsque cette instruction est exécutée, un indicateur indique la progression du transfert (voir Figure 3.74). Figure 3.74 Indicateur de progression du transfert.
Télécharger un fichier depuis un serveur Pour télécharger un fichier sur votre ordinateur depuis un serveur FTP ou HTTP, vous utiliserez la procédure DownloadFile() : My.Computer.Network.DownloadFile("AdresseServeur", "NomFichier", "NomUtilisateur", „ "MotPasse", Interface, TimeOut, Ecrasement)
où :
∑ ∑
AdresseServeur est l’adresse FTP ou HTTP du fichier sur le serveur. NomFichier contient le chemin de stockage sur votre ordinateur et le nom à donner au
fichier téléchargé.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
135
∑ ∑ ∑
NomUtilisateur est le nom à fournir au serveur pour accéder au compte (si nécessaire).
∑ ∑
TimeOut définit le délai de réponse maximal du serveur, en millisecondes.
MotPasse est le mot de passe à fournir au serveur pour accéder au compte (si nécessaire). Interface est une valeur booléenne qui indique si l’indicateur de progression du transfert doit (True) ou ne doit pas (False) être affiché.
Ecrasement est une variable booléenne qui indique si un fichier de même nom doit (True) ou ne doit pas (False) être écrasé sur votre ordinateur.
Supposons que vous vouliez télécharger le fichier Total Commander depuis le site Infosdu-net.com. L’adresse de téléchargement est http://download.infos-du-net.com/52282/ tcmdr700.exe. Ce fichier est librement téléchargeable, sans qu’il soit nécessaire de fournir un nom d’utilisateur et un mot de passe. Pour copier le fichier dans le dossier c:\test, sous le nom tcmdr700.exe, vous utiliserez l’instruction suivante : My.Computer.Network.DownloadFile("http://download.infos-du-net.com/52282/ „ tcmdr700.exe", "c:\test\tcmdr700.exe", "", "", True, 500, True)
Lorsque cette instruction est exécutée, un indicateur indique la progression du transfert (voir Figure 3.75). Figure 3.75 Indicateur de progression du transfert.
Manipulation du Registre L’objet My.Computer.Registry donne accès à de nouvelles procédures en rapport avec le Registre de Windows : Procédure
Utilité
My.Computer.Registry.CurrentUser.CreateSubKey()
Création d’une clé
My.Computer.Registry.SetValue()
Définition de la valeur d’une clé
My.Computer.Registry.GetValue()
Lecture d’une clé
My.Computer.Registry.CurrentUser.DeleteSubKey()
Suppression d’un clé
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
136
Visual Basic 2010
Lecture d’une valeur Vous utiliserez la fonction GetValue() pour lire une valeur dans le Registre : resultat = My.Computer.Registry.GetValue(Nom, Valeur, RetourParDefaut)
où :
∑ ∑ ∑
Nom est un String contenant le nom de la clé à laquelle accéder. Valeur est un String contenant le nom de la valeur à laquelle accéder dans la clé.
RetourParDefaut est un Object contenant le résultat retourné par la fonction si la valeur spécifiée dans le deuxième argument n’existe pas. La valeur HKEY_USERS\.DEFAULT\Control Panel\Keyboard\InitialKeyboardIndicators indique si la touche Verr Num est activée (2) ou désactivée (0) au démarrage de l’ordinateur. Ces quelques lignes de code lisent la valeur InitialKeyboardIndicators et affichent un message en fonction de son contenu : Dim valeur As String valeur = My.Computer.Registry.GetValue("HKEY_USERS\.DEFAULT\Control Panel\Keyboard", „ "InitialKeyboardIndicators", Nothing) If valeur = "0" Then MsgBox("La touche Verr Num est désactivée au démarrage de l’ordinateur") Else MsgBox("La touche Verr Num est activée au démarrage de l’ordinateur") End If
Test de l’existence d’une valeur Pour tester l’existence d’une valeur dans le Registre, il suffit d’utiliser la fonction GetValue() et de déterminer si la valeur renvoyée est égale au troisième argument de la fonction : If My.Computer.Registry.GetValue(Nom, Valeur, RetourParDefaut) Is RetourParDefaut Then MsgBox("La valeur " + Valeur + " n’existe pas.) End If
Écriture d’une valeur Vous utiliserez la fonction SetValue() pour lire une valeur dans le Registre : My.Computer.Registry.SetValue(Nom, Valeur, Donnée, type)
où :
∑ ∑ ∑
Nom est un String contenant le nom de la clé à laquelle accéder. Valeur est un String contenant le nom de la valeur à laquelle accéder dans la clé. Donnée est la donnée à écrire dans la valeur.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
∑ ∑ ∑ ∑ ∑ ∑ ∑
Nouveautés et concepts utiles du langage et de l’environnement
137
Type est le type de la valeur (cet argument est facultatif) : Microsoft.Win32.RegistryValueKind.Binary : REG_BINARY Microsoft.Win32.RegistryValueKind.Dword : REG_DWORD Microsoft.Win32.RegistryValueKind.ExpandString : REG_EXPAND_SZ Microsoft.Win32.RegistryValueKind.MultiString : REG_MULTI_SZ Microsoft.Win32.RegistryValueKind.QWord : REG_QWORD Microsoft.Win32.RegistryValueKind.String : REG_SZ
L’instruction ci-après active la touche Verr Num au démarrage de l’ordinateur en stockant la chaîne 2 dans la valeur HKEY_USERS\.DEFAULT\Control Panel\Keyboard\ InitialKeyboardIndicators : My.Computer.Registry.SetValue("HKEY_USERS\.DEFAULT\Control Panel\Keyboard", „ "InitialKeyboardIndicators", "2")
Création d’une clé La procédure CreateSubKey() permet de créer une nouvelle clé : CreateSubKey("Nom")
où Nom est le nom de la clé que vous souhaitez créer. Cette fonction est accessible à partir des objets listés dans le tableau ci-après. Objet
Accès à…
ClassesRoot
HKEY_CLASSES_ROOT
CurrentConfig
HKEY_CURRENT_CONFIG
CurrentUser
HKEY_CURRENT_USER
LocalMachine
HKEY_LOCAL_MACHINE
Users
HKEY_USERS
Par exemple, pour créer la clé CleTest dans la branche HKEY_CURRENT_CONFIG, vous utiliserez l’instruction suivante : My.Computer.Registry.CurrentConfig.CreateSubKey("CleTest")
Une fois la clé CleTest créée, vous pouvez définir la valeur ValeurTest et y stocker une valeur quelconque à l’aide de la procédure SetValue() : My.Computer.Registry.SetValue("HKEY_CURRENT_CONFIG\CleTest", "ValeurTest", „ "Donnée test", Microsoft.Win32.RegistryValueKind.String)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
138
Visual Basic 2010
Comme le montre la Figure 3.76, après l’exécution de ces deux instructions, la clé et la valeur ont bien été créées. Figure 3.76 CleTest et ValeurTest ont bien été créées.
ntion Atte
Si vous travaillez sous Windows 7 ou Vista, vous devez disposer des privilèges de l’administrateur pour modifier le Registre. Pour les acquérir, affichez le dossier contenant l’exécutable du projet, cliquez du bouton droit sur son icône et sélectionnez Exécuter en tant qu’administrateur dans le menu (voir Figure 3.77). Si cela vous est demandé, entrez le nom de l’utilisateur et le mot de passe associé puis validez.
Figure 3.77 Demande d’exécution du programme en tant qu’administrateur.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
139
Suppression d’une clé Pour supprimer une clé et les éventuelles valeurs qu’elle héberge, vous utiliserez la fonction DeleteSubKey() : CreateSubKey("Nom")
où Nom est le nom de la clé que vous souhaitez supprimer. À l’instar de la fonction CreateSubKey(), DeleteSubKey() est accessible à partir des objets ClassesRoot, CurrentConfig, CurrentUser, LocalMachine et Users. À titre d’exemple, pour supprimer la clé HKEY_CURRENT_CONFIG\CleTest, employez l’instruction ci-après : My.Computer.Registry.CurrentConfig.DeleteSubKey("CleTest")
Comme le montre la Figure 3.78, la clé CleTest a bien été supprimée. Figure 3.78 CleTest a disparu de la branche HKEY_CURRENT_CONFIG.
Ports série Les ports série de l’ordinateur sont accessibles via l’objet My.Computer.Ports. Vous utiliserez essentiellement les fonctions, procédures et propriétés de cet objet pour dialoguer avec un modem RTC et pour échanger des données entre deux ordinateurs reliés par un câble série. Liste des ports série La propriété SerialPortNames donne accès à une collection de String contenant le nom des ports série de l’ordinateur. Pour connaître le nom des différents ports série, il suffit de décrire la collection avec une instruction For Each :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
140
Visual Basic 2010
Dim st As String = "Les ports série de cet ordinateur sont :" + vbCrLf For Each PortSerie As String In My.Computer.Ports.SerialPortNames st = st + " - " + PortSerie + vbCrLf Next TextBox1.Text = st
Communiquer avec un modem Pour communiquer avec un modem, vous devez lui envoyer des commandes de type AT, par exemple :
∑
Composition du numéro de téléphone 01 45 89 44 65 :
∑
Interruption de la liaison :
∑
ATDT0145894465;
ATH
Réglage du volume du haut-parleur sur Faible : ATL0
L’objet My.Computer.Ports simplifie à l’extrême la communication avec un modem : 1. Identifiez le port série sur lequel est connecté le modem. 2. Utilisez la fonction My.Computer.Ports.OpenSerialPort() pour ouvrir le port de communication. 3. Employez une commande Write pour envoyer les commandes voulues au modem. Supposons que le modem soit connecté sur le port série COM2. Pour lui demander de composer le numéro 01 45 89 44 65, mettez en œuvre les instructions suivantes : Dim com2 As IO.Ports.SerialPort = My.Computer.Ports.OpenSerialPort("COM2", 9600) com2.Write("ATDT0145894465" & vbCrLf)
Envoyer et recevoir des données sur un port série Pour envoyer des données sur un port série, procédez comme suit : 1. Définissez un objet IO.Ports.SerialPorts. 2. Instanciez-le avec la valeur retournée par la fonction OpenSerialPort(). 3. Utilisez la procédure Write() pour envoyer les données chaînes souhaitées : Dim com1 As IO.Ports.SerialPort com1 = My.Computer.Ports.OpenSerialPort("COM1", 19200) com1.Write("chaîne 1" & vbCrLf) … com1.Write("chaîne n" & vbCrLf)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
141
Pour recevoir des données sur un port série, procédez comme suit : 1. Définissez un objet IO.Ports.SerialPorts. 2. Instanciez-le avec la valeur retournée par la fonction OpenSerialPort(). 3. Utilisez la fonction ReadLine() en boucle pour acquérir les chaînes qui parviennent sur le port série : Dim com1 As IO.Ports.SerialPort com1 = My.Computer.Ports.OpenSerialPort("COM1", 19200) Dim st as String = "" Do st = com1.ReadLine() Label1.Text = st Loop
Système d’affichage L’objet My.Computer.Screen donne accès à des fonctions, procédures et propriétés en rapport avec le système d’affichage. Le tableau ci-après dresse la liste des principales propriétés de cet objet. Propriété
Signification
My.Computer.Screen.WorkingArea.Size
Taille de l’écran
My.Computer.Screen.WorkingArea.Height ou My.Computer.Screen.WorkingArea.Bounds.Height
Hauteur de l’écran
My.Computer.Screen.WorkingArea.Width ou My.Computer.Screen.WorkingArea.Bounds.Width
Largeur de l’écran
My.Computer.Screen.WorkingArea.X
Abscisse du coin supérieur gauche de la zone de tracé (System.Drawing.Rectangle)
My.Computer.Screen.WorkingArea.Y
Ordonnée du coin supérieur gauche de la zone de tracé (System.Drawing.Rectangle)
My.Computer.Info L’objet My.Computer.Info donne accès aux informations concernant l’ordinateur sur lequel le code est exécuté : mémoire, assemblies, nom de l’application, nom du système d’exploitation, etc.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
142
Visual Basic 2010
Propriété
Signification
AvailablePhysicalMemory
Mémoire physique disponible
AvailableVirtualMemory
Mémoire virtuelle disponible
OSFullName
Nom du système d’exploitation
OSPlatform
Nom de la plateforme
OSversion
Version du système d’exploitation
InstalledUICulture
Langue du système
TotalPhysicalMemory
Mémoire physique totale
TotalVirtualMemory
Mémoire virtuelle totale
À titre d’exemple, nous allons définir une petite application qui affiche les propriétés décrites dans le tableau précédent. Après avoir créé un nouveau projet de type Application Windows Forms, nous ajoutons huit contrôles Label et huit contrôles TextBox à la feuille de l’application. Les propriétés des contrôles sont modifiées comme suit : Contrôle
Propriété
Valeur
Label1
Text
Mémoire RAM totale
Label2
Text
Mémoire RAM disponible
Label3
Text
Mémoire virtuelle totale
Label4
Text
Mémoire virtuelle disponible
Label5
Text
Nom complet du système
Label6
Text
Plateforme
Label7
Text
Version
Label8
Text
Culture
Form1
Text
Informations sur le système
Double-cliquez sur un emplacement inoccupé de la feuille et complétez la procédure Form1_Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load TextBox1.Text = My.Computer.Info.TotalPhysicalMemory TextBox2.Text = My.Computer.Info.AvailablePhysicalMemory TextBox3.Text = My.Computer.Info.TotalVirtualMemory TextBox4.Text = My.Computer.Info.AvailableVirtualMemory
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
TextBox5.Text TextBox6.Text TextBox7.Text TextBox8.Text End Sub
Nouveautés et concepts utiles du langage et de l’environnement
= = = =
143
My.Computer.Info.OSFullName My.Computer.Info.OSPlatform My.Computer.Info.OSVersion My.Computer.Info.InstalledUICulture.ToString
Cette procédure se contente de lire les propriétés de l’objet My.Computer.Info et de les afficher dans les contrôles TextBox (voir Figure 3.79). Figure 3.79 Informations système provenant de l’objet My.Computer.Info.
Tous les fichiers relatifs à cette application se trouvent dans le dossier Projects\Infos Systeme des sources de l’ouvrage.
My.User Vous utiliserez l’objet My.User pour obtenir des informations sur la personne qui exécute le programme. Vous pourrez en particulier connaître :
∑ ∑ ∑
son nom de domaine : première partie de la propriété Name ; son nom d’utilisateur : seconde partie de la propriété Name ; son type (simple utilisateur, administrateur) : propriété BuiltInRole.
Les lignes de code suivantes lisent les propriétés de l’objet My.User et les affichent dans un contrôle TextBox multiligne : Dim st As String Dim nom() As String = Split(My.User.Name, "\") st = "Nom de domaine : " + nom(0) + vbCrLf
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
144
Visual Basic 2010
st = st + "Nom d’utilisateur : " + nom(1) + vbCrLf If My.User.IsInRole(ApplicationServices.BuiltInRole.Guest) Then st = st „ + "L’utilisateur n’est pas un administrateur" If My.User.IsInRole(ApplicationServices.BuiltInRole.Administrator) Then st = st „ + "L’utilisateur est un administrateur" TextBox1.Text = st
Après avoir défini la variable String st : Dim st As String
la propriété Name de l’objet My.User est lue et ses deux composantes sont stockées dans le tableau de String nom() : Dim nom() As String = Split(My.User.Name, "\")
Le nom de domaine et le nom d’utilisateur sont alors extraits du tableau et stockés dans la variable st : st = "Nom de domaine : " + nom(0) + vbCrLf st = st + "Nom d’utilisateur : " + nom(1) + vbCrLf
Les deux instructions suivantes testent le type de l’utilisateur et ajoutent l’information correspondante dans la variable st : If My.User.IsInRole(ApplicationServices.BuiltInRole.Guest) Then st = st + „ "L’utilisateur n’est pas un administrateur" If My.User.IsInRole(ApplicationServices.BuiltInRole.Administrator) Then st = st „ + "L’utilisateur est un administrateur"
Enfin, le contenu de la variable st s’affiche dans le contrôle TextBox multiligne : TextBox1.Text = st
My.Resources Lorsque vous prévoyez d’utiliser des icônes, des images, des sons ou tout autre type de fichier dans une application Visual Basic 2010, vous pouvez les placer dans un dossier particulier (par exemple celui dans lequel se trouve l’exécutable) ou bien les inclure dans les "ressources" de l’application. Dans le second cas, ils feront partie intégrante de l’exécutable et ne pourront pas en être discernés par les utilisateurs. Pour inclure une nouvelle ressource dans l’application en cours d’édition, procédez comme suit : 1. Lancez la commande Propriétés de Nom (où Nom est le nom de l’application) du menu Projet.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
145
2. Sélectionnez l’onglet Ressources (voir Figure 3.80). Figure 3.80 L’onglet Ressources des propriétés de l’application.
3. Choisissez le type de ressource à ajouter à l’application dans la première liste déroulante : Chaînes, Images, Icônes, Audio, Fichiers ou Autre (vous pouvez également utiliser les raccourcis Ctrl+1 à Ctrl+6). 4. Déroulez la liste Ajouter une ressource et sélectionnez Ajouter un fichier existant. 5. Choisissez le fichier que vous souhaitez ajouter dans les ressources de l’application (voir Figure 3.81). Figure 3.81 Le fichier WAV ding a été ajouté à l’application.
Pour accéder aux ressources de l’application dans le code, il suffit d’utiliser l’objet My.Resources. Par exemple, pour jouer le son WAV ding, employez l’instruction suivante : My.Computer.Audio.Play(My.Resources.ding, AudioPlayMode.Background)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
146
Visual Basic 2010
La fonctionnalité AutoComplete de Visual Basic 2010 facilite l’accès aux ressources incluses dans l’application : entrez My.Computer dans l’éditeur de code et faites votre choix dans la liste déroulante (voir Figure 3.82). Figure 3.82 AutoComplete donne accès aux différentes ressources incluses dans l’application.
My.Settings L’objet My.Settings donne accès à un ensemble de procédures, fonctions et propriétés liées au paramétrage de l’application. Par son intermédiaire, vous pouvez stocker de façon dynamique toute information jugée nécessaire et retrouver celle-ci lors des prochaines exécutions de l’application. Cela permet de mémoriser les préférences de l’utilisateur (couleurs, polices, particularités d’affichage, etc.) ou encore de savoir combien de fois l’application a été lancée. À titre d’exemple, nous allons ajouter la variable Integer NombreExecution dans les paramètres de l’application et lui affecter la valeur 0 : 1. Lancez la commande Propriétés de Nom (où Nom est le nom de l’application) du menu Projet. 2. Sélectionnez l’onglet Propriétés et remplissez les champs Nom, Type, Portée et Valeur (voir Figure 3.83).
Info
Pour être en mesure de modifier un élément défini sous l’onglet Paramètres, vous devez lui affecter une portée Utilisateur (et non Application).
3. Retournez dans le code. La propriété NombreExecution est directement accessible dans l’objet My.Settings (voir Figure 3.84).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
147
Figure 3.83 L’onglet Paramètres permet de créer des paramètres propres à l’application.
Figure 3.84 Le paramètre NombreExecution est directement accessible dans le code.
Si vous développez des programmes en shareware, vous souhaiterez peut-être limiter le nombre d’exécutions de la version non enregistrée de vos créations. Il suffit pour cela d’incrémenter le paramètre NombreExecution à chaque exécution du programme et de tester sa valeur : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load My.Settings.NombreExecution = My.Settings.NombreExecution + 1 If My.Settings.NombreExecution = 30 Then MsgBox("Vous avez exécuté l’application 30 fois." + vbCrLf + "Pour „ continuer à l’utiliser, vous devez vous enregistrer." + vbCrLf + "Pour „ cela, rendez-vous sur le site www.MonSite.com") End End If End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
148
Visual Basic 2010
My.WebServices L’objet My.WebServices facilite grandement l’interfaçage avec un service web. Après avoir référencé le service web dans le projet à l’aide de la commande Ajouter une référence web du menu Projet, les fonctions et procédures du service sont directement accessibles par l’intermédiaire de l’objet My.WebServices. Par exemple, pour accéder à la fonction NomFonction du service NomService, vous utiliserez la syntaxe suivante : Dim resultat as Type = My.WebServices.NomService.NomFonction(param1, …, paramN)
où :
∑
resultat est la variable de type Type dans laquelle le résultat de la fonction NomFonction est stocké.
∑
NomService est le nom du service web interrogé.
∑
NomFonction est le nom de la fonction du service web interrogée.
∑
param1 à paramN sont les paramètres transmis à la fonction NomFonction.
Vous trouverez un exemple concret d’utilisation de l’objet My.WebServices au Chapitre 25 dédié aux services web.
Assistant Publication Lorsqu’une application aura donné les résultats escomptés, vous souhaiterez certainement la diffuser. Pour cela, Visual Studio vous propose son Assistant Déploiement. Lancez la commande Publier Nom dans le menu Générer (où Nom est le nom de la solution en cours d’édition). Cette commande lance l’Assistant Publication. Spécifiez l’emplacement de publication de votre solution. Comme le montre la Figure 3.85, vous pouvez indiquer un dossier sur le disque dur, un chemin sur le serveur local, ou bien une adresse FTP ou HTTP. Si vous décidez de publier la solution sur votre disque dur ou sur un disque dur partagé du réseau, un fichier Setup.exe est automatiquement généré (voir Figure 3.86). Pour installer votre solution, il suffit de copier le contenu du dossier de publication sur le CD-ROM/DVD-ROM et d’exécuter le fichier Setup.exe.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 3
Nouveautés et concepts utiles du langage et de l’environnement
149
Figure 3.85 L’assistant Publication est la dernière étape dans le développement d’une solution.
Figure 3.86 Ces fichiers ont été générés par l’Assistant Publication.
Assistant Mise à niveau Pour convertir un projet écrit dans une version antérieure de Visual Basic en Visual Basic 2010, ouvrez-le dans Visual Studio à l’aide de la commande Ouvrir un projet du menu Fichier. Cette action provoque l’exécution de l’Assistant Mise à niveau (voir Figure 3.87).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
150
Visual Basic 2010
Figure 3.87 La première boîte de dialogue de l’Assistant Mise à niveau de Visual Basic.
L’Assistant Mise à niveau vous guide tout au long du processus et crée un nouveau projet Visual Basic 2010. Votre ancien projet demeure intact. Cependant, ce processus est à sens unique : le nouveau projet Visual Basic 2010 ne peut plus être ouvert dans l’environnement de développement précédent. Après la mise à jour de votre projet, le langage est modifié pour tout changement de syntaxe et vos anciens formulaires sont convertis au format Visual Basic 2010. Dans la plupart des cas, vous devrez ensuite apporter quelques modifications à votre code, car certains objets et fonctionnalités du langage n’ont pas d’équivalent dans Visual Basic 2010 (ou celui proposé est trop différent pour une mise à niveau automatique). Après la mise à niveau, vous pourrez également modifier votre application afin de tirer parti des nouvelles fonctionnalités de Visual Basic 2010.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
II Programmation Windows Au travers de nombreux exemples, cette partie vous montre comment aborder la plupart des domaines de programmation Windows : utilisation de boîtes de dialogue communes, mise en place de menus, barres d’outils et barres d’état, manipulations graphiques, accès au système de fichiers, exploitation de données tabulaires, bases de données locales et distantes, accès au Registre de Windows, interfaçage de Word et d’Excel, accès aux fonctions API, traitement multitâche/multicœur, etc. Tous les codes présentés dans cette partie sont réutilisables : un copier-coller est généralement suffisant pour les incorporer dans vos propres développements.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
4 Boîtes de dialogue communes Windows met à la disposition des programmeurs un ensemble de boîtes de dialogue "communes". En les utilisant, les applications ont un look and feel constant, ce qui facilite l’apprentissage de leurs utilisateurs. La mise en œuvre des boîtes de dialogue communes est des plus simple. Il suffit d’initialiser des propriétés et d’appeler la méthode adéquate. Les boîtes de dialogue accessibles par ce procédé concernent l’ouverture, l’enregistrement et l’impression de fichiers, la sélection de dossiers, de couleurs et de polices. Chacune de ces boîtes de dialogue est attachée à un contrôle spécifique dans la Boîte à outils :
∑ ∑ ∑ ∑ ∑
OpenFileDialog pour la boîte de dialogue Ouvrir ; SaveFileDialog pour la boîte de dialogue Enregistrer sous ; ColorDialog pour la boîte de dialogue Couleur ; FontDialog pour la boîte de dialogue Polices de caractères ; PrintDialog pour la boîte de dialogue Imprimer ;
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
154
∑ ∑
Visual Basic 2010
PrintPreviewDialog pour la boîte de dialogue Aperçu avant impression ; FolderBrowserDialog pour la boîte de dialogue Rechercher un dossier.
La boîte de dialogue Ouvrir La boîte de dialogue Ouvrir permet de sélectionner un fichier dans les mémoires de masse de l’ordinateur : disquettes, disques durs, CD-ROM, etc. Elle est attachée à la méthode ShowDialog. Pour pouvoir afficher une boîte de dialogue Ouvrir, une ou plusieurs propriétés doivent être renseignées. Le tableau suivant dresse la liste des principales propriétés utilisables. Propriété
Effet
DefaultExt
Définit l’extension par défaut du nom du fichier à ouvrir.
Title
Définit la chaîne affichée dans la barre de titre de la boîte de dialogue.
FileName
Définit le chemin d’accès et le nom du fichier sélectionné par défaut.
Filter
Définit les filtres à utiliser. Ces filtres apparaissent dans la liste modifiable Type de la boîte de dialogue. La syntaxe est objet.Filter [= description1 |filtre1 |description2 |filtre2…].
FilterIndex
Spécifie le filtre à utiliser par défaut dans la boîte de dialogue Ouvrir. La syntaxe est objet.FilterIndex [= 1 | 2 | 3 | 4…].
InitialDirectory
Définit le répertoire des fichiers affichés à l’ouverture de la boîte de dialogue.
Une fois que les propriétés de votre choix ont été renseignées, un simple appel à la méthode ShowDialog() affiche la boîte de dialogue Ouvrir. Vous pouvez ensuite utiliser la propriété FileName pour connaître le nom du fichier sélectionné. Lancez la commande Nouveau/Projet du menu Fichier pour définir un nouveau projet. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom Ouvrir au projet et cliquez sur OK. Ajoutez deux boutons de commande (Button), une zone de texte (TextBox) et une boîte de dialogue Ouvrir (OpenFileDialog) dans la feuille. Modifiez les propriétés des différents contrôles comme suit : Contrôle
Propriété
Valeur
Form1
Text
La boîte de dialogue Ouvrir
Button1
Text
Ouvrir
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 4
Boîtes de dialogue communes
Contrôle
Propriété
Valeur
Button2
Text
Quitter
TextBox1
Multiline
True
OpenFileDialog
(Name)
CMD
155
Si vous avez suivi nos indications, la feuille du projet doit maintenant ressembler à la Figure 4.1. Figure 4.1 La boîte de dialogue du projet, en mode Création.
Vous allez maintenant définir le code des deux boutons de commande. Double-cliquez sur le bouton Ouvrir et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click CMD.Title = "Choisissez un fichier" CMD.Filter = "Bitmap (*.BMP)|*.BMP|DLL (*.DLL)|*.DLL|Exécutables (*.EXE)|*. EXE|Fichiers d’aide (*.HLP)|*.HLP" CMD.FilterIndex = 1 CMD.InitialDirectory = "C:\WINDOWS" CMD.ShowDialog() ‘ ‘ Message affiché selon la sélection de l’utilisateur ‘ If (CMD.FileName "") Then TextBox1.Text = "Le fichier " + CMD.FileName + " a „ été sélectionné." Else TextBox1.Text = "Vous n’avez sélectionné aucun fichier." End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
156
Visual Basic 2010
Les quatre premières lignes paramètrent la boîte de dialogue Ouvrir :
∑ ∑ ∑
Title définit le texte qui apparaît dans la barre de titre.
∑
InitialDirectory définit le dossier par défaut.
Filter définit le filtre de sélection des fichiers de la liste déroulante Fichiers de type. FilterIndex désigne l’entrée sélectionnée par défaut dans la liste déroulante Fichiers
de type. CMD.Title = "Choisissez un fichier" CMD.Filter = "Bitmap (*.BMP)|*.BMP|DLL (*.DLL)|*.DLL|Exécutables (*.EXE)|*. „ EXE|Fichiers d’aide (*.HLP)|*.HLP" CMD.FilterIndex = 1 CMD.InitialDirectory = "C:\WINDOWS"
Lorsque la boîte de dialogue a été paramétrée, elle s’affiche : CMD.ShowDialog()
Lors de sa fermeture, la propriété FileName du contrôle CMD contient l’entrée sélectionnée par l’utilisateur. En fonction de cette entrée, un message apparaît dans la zone de texte : If (CMD.FileName "") Then TextBox1.Text = "Le fichier " + CMD.FileName + " a été „ sélectionné." Else TextBox1.Text = "Vous n’avez sélectionné aucun fichier."
Double-cliquez sur le bouton de commande Quitter et complétez la procédure Button2_ Click() en ajoutant le mot End : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click End End Sub
Cette instruction met fin au programme lorsqu’on clique sur le bouton Quitter. Exécutez la solution en cliquant sur le bouton Démarrer le débogage de la barre d’outils Standard. Les boutons Ouvrir et Quitter sont totalement opérationnels (voir Figure 4.2). Figure 4.2 Un fichier a été sélectionné dans le dossier c:\Windows.
Cette application se trouve dans le dossier Ouvrir après installation des sources de l’ouvrage.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 4
Boîtes de dialogue communes
157
La boîte de dialogue Enregistrer sous Les boîtes de dialogue Enregistrer sous et Ouvrir sont assez semblables. Seule la méthode à utiliser est différente. Vous trouverez dans le dossier Projects\Enreg des sources de l’ouvrage une application permettant de définir le nom d’un fichier de sauvegarde dans une boîte de dialogue Enregistrer sous (voir Figure 4.3). Figure 4.3 Les deux boîtes de dialogue affichées par le projet ENREG.
Voici le listing de la procédure associée au clic sur le premier bouton de commande : Private Sub Command1_Click() ‘ - - - - - - - - - - - - - - - - - - - - - - - - - ‘ Définition des propriétés de la boîte de dialogue ‘ - - - - - - - - - - - - - - - - - - - - - - - - - CMD.DialogTitle = "Enregistrer le fichier sous …" CMD.CancelError = True CMD.Filter = "Perso (*.PER)|(*.PER)|Tous les fichiers (*.*)|*.*" CMD.FilterIndex = 1 CMD.InitDir = "C:\WINDOWS" CMD.filename = "Agenda.per" CMD.ShowSave If (CMD.FileName "") Then Text1.TEXT = "La sauvegarde sera réalisée dans le „ fichier " + CMD.filename + "." Else Text1.Text = "Vous n’avez sélectionné aucun „ fichier." End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
158
Visual Basic 2010
Remarquez en particulier la définition restreinte des filtres de sauvegarde : CMD.Filter = "Perso (*.PER)|(*.PER)|Tous les fichiers (*.*)|*.*"
et la sélection du nom de la sauvegarde par défaut : CMD.filename = "Agenda.per"
Ce projet se trouve dans le dossier Enreg après installation des sources de l’ouvrage.
La boîte de dialogue Couleur La boîte de dialogue Couleur permet de sélectionner une couleur dans un ensemble de couleurs de base. En agrandissant cette boîte, vous pouvez également définir une couleur par ses composantes : teinte, saturation, luminance, rouge, vert, bleu. Pour faire apparaître la boîte de dialogue Couleur, il suffit d’appeler la fonction ShowDialog(). Cette fonction renvoie une valeur qui indique sur quel bouton l’utilisateur a cliqué pour la fermer : Windows.Forms.DialogResult.OK (bouton OK) ou Windows.Forms.Dialog Result.Cancel (bouton Annuler). Le cas échéant, l’objet Color donne tous les rensei gnements nécessaires sur la couleur sélectionnée.
Exemple Nous allons définir un projet qui permettra à l’utilisateur de sélectionner une couleur dans une boîte de dialogue Couleur. Le résultat à atteindre est représenté à la Figure 4.4. Figure 4.4 Utilisation d’une boîte de dialogue Couleurs pour sélectionner une couleur prédéfinie ou personnalisée.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 4
Boîtes de dialogue communes
159
Réalisation Définissez un nouveau projet. Ajoutez le contrôle ColorDialog1 dans la feuille de l’application. Cliquez dessus et donnez-lui le nom CMD (propriété Name). Définissez deux boutons de commande et une zone de texte. Nommez les deux boutons Couleur et Quitter (propriété Caption). Définissez enfin le titre de la boîte de dialogue : Choix d’une couleur (propriété Caption de la boîte de dialogue). La feuille du projet doit maintenant ressembler à la Figure 4.5. Figure 4.5 La boîte de dialogue du projet, en mode Création.
Affectez à présent des lignes de code aux deux boutons de commande. La procédure associée au bouton Quitter comprend une seule instruction qui met fin au programme : Private Sub Command2_Click() End End Sub
La procédure associée au bouton Couleur est plus complexe. Double-cliquez sur le bouton Couleur et définissez les lignes de code suivantes : Private Sub Command1_Click() If CMD.ShowDialog() = Windows.Forms.DialogResult.OK Then TextBox1.Text = "Le code RGB de la couleur est : R=" + Str(CMD.Color.R) + " „ V=" + Str(CMD.Color.G) + " B=" + Str(CMD.Color.B) Else TextBox1.Text = "Aucune couleur n’a été sélectionnée" EndIf End Sub
La procédure consiste en une seule instruction If Then Else : If CMD.ShowDialog() = Windows.Forms.DialogResult.OK
1. Ce contrôle se trouve sous l’onglet Boîtes de dialogue de la Boîte à outils.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
160
Visual Basic 2010
Si l’utilisateur clique sur le bouton OK pour quitter la boîte de dialogue Couleurs, la procédure CMD.ShowDialog() renvoie la valeur Windows.Forms.DialogResult.OK. Le code qui suit l’instruction Then est donc exécuté : TextBox1.Text = "Le code RGB de la couleur est : R=" + Str(CMD.Color.R) + " V=" „ + Str(CMD.Color.G) + " B=" + Str(CMD.Color.B)
La zone de texte TextBox1 affiche les valeurs RGB de la couleur sélectionnée par l’utilisateur. Notez la simplicité avec laquelle les trois composantes sont extraites de l’objet Color. Si l’utilisateur clique sur le bouton Annuler pour quitter la boîte de dialogue Couleurs, la condition suivant l’instruction If n’est pas vérifiée. Le code suivant l’instruction Else est donc exécuté : TextBox1.Text = "Aucune couleur n’a été sélectionnée"
Ce code affiche un message indiquant qu’aucune couleur n’a été sélectionnée dans la boîte de dialogue Couleurs.
Info
Pour initialiser la couleur d’un objet, il suffit de transmettre ses composantes Rouge, Vert et Bleu à la fonction RGB : Objet.Color = RGB(Composante Rouge, Composante Vert, Composante Bleu)
Ce projet se trouve dans le dossier Couleur après installation des sources de l’ouvrage.
La boîte de dialogue Police de caractères La boîte de dialogue Police de caractères permet de sélectionner une police et ses attributs. Elle est attachée à la méthode ShowDialog. Tout comme pour les autres boîtes de dialogue communes, il est possible de connaître le bouton sur lequel l’utilisateur a cliqué lors de la fermeture de la boîte de dialogue, en contrôlant la valeur renvoyée par la fonction ShowDialog(). Les objets manipulés par la boîte de dialogue Police de caractères sont de type Font. Voici leurs principales propriétés : Propriété
Effet
Font.Bold
Définit le style Gras
Font.Italic
Définit le style Italique
Font.Name
Définit la police
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 4
Boîtes de dialogue communes
Propriété
Effet
Font.Size
Définit la taille
Font.Strikeout
Définit le style Barré
Font.Underline
Définit le style Souligné
161
Exemple Nous allons définir un projet qui permettra à l’utilisateur de sélectionner une police, un style, une taille et des effets. Le résultat à atteindre est montré à la Figure 4.6. Figure 4.6 Utilisation de la boîte de dialogue Police de caractères pour sélectionner une police et ses attributs.
Réalisation Définissez un nouveau projet. Ajoutez le contrôle FontDialog1 dans la feuille de l’appli cation. Cliquez dessus et donnez-lui le nom CMD (propriété Name). Définissez deux boutons de commande et une zone de texte. Nommez les deux boutons Police et Quitter (propriété Caption). Définissez enfin le titre de la boîte de dialogue : Choix d’une police (propriété Caption de la boîte de dialogue). 1. Ce contrôle se trouve sous l’onglet Boîtes de dialogue de la Boîte à outils.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
162
Visual Basic 2010
La feuille du projet doit maintenant ressembler à la Figure 4.7. Figure 4.7 La boîte de dialogue du projet, en mode Création.
Vous allez à présent affecter des lignes de code aux deux boutons de commande. La procédure associée au clic sur le bouton Quitter se contente d’exécuter l’instruction End pour mettre fin au programme. La procédure associée au bouton Police est plus complexe. Double-cliquez sur le bouton Police et définissez les lignes de code suivantes : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click Dim tampon As String If CMD.ShowDialog() = Windows.Forms.DialogResult.OK Then Tampon = "Police " + CMD.Font.Name + ", " + Str(CMD.Font.Size) + " points " If CMD.Font.Bold = True Then Tampon = Tampon + "gras " If CMD.Font.Italic = True Then Tampon = Tampon + "italique " If CMD.Font.Underline = True Then Tampon = Tampon + "souligné " If CMD.Font.Strikeout = True Then Tampon = Tampon + "barré " TextBox1.Text = Tampon Else TextBox1.Text = "Vous n’avez sélectionné aucune police." End If End Sub
Après avoir défini la variable String Tampon : Dim tampon As String
la boîte de dialogue FontDialog s’affiche. Une instruction If permet de connaître le bouton cliqué par l’utilisateur lors de la fermeture de la boîte de dialogue : If CMD.ShowDialog() = Windows.Forms.DialogResult.OK Then
Si le bouton OK est cliqué, un texte indiquant les caractéristiques de la police sélectionnée est calculé dans la variable Tampon :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 4
Boîtes de dialogue communes
163
Tampon = "Police " + CMD.Font.Name + ", " + Str(CMD.Font.Size) + " points " If CMD.Font.Bold = True Then Tampon = Tampon + "gras " If CMD.Font.Italic = True Then Tampon = Tampon + "italique " If CMD.Font.Underline = True Then Tampon = Tampon + "souligné " If CMD.Font.Strikeout = True Then Tampon = Tampon + "barré "
Les éléments suivants sont extraits de l’objet CMD.Font :
∑ ∑ ∑
Nom de la police. Name. Taille des caractères, en points. Size. Attributs des caractères. Bold, Italic, Underline et Strikeout.
Le contenu de la variable Tampon apparaît dans le contrôle TextBox : TextBox1.Text = Tampon
Si l’utilisateur clique sur le bouton Annuler, un message indiquant qu’aucune police n’a été sélectionnée s’affiche dans le contrôle TextBox : Else TextBox1.Text = "Vous n’avez sélectionné aucune police."
Ce projet se trouve dans le dossier Police après installation des sources de l’ouvrage.
La boîte de dialogue Imprimer La boîte de dialogue Imprimer est utilisée pour définir les paramètres de l’impression : nom de l’imprimante, nombre de copies, numéros des pages à imprimer, etc. Si nécessaire, ces paramètres peuvent devenir les paramètres d’impression par défaut. Cette boîte est attachée à la méthode ShowDialog. Tout comme pour les autres boîtes de dialogue communes, il est possible de connaître le bouton cliqué par l’utilisateur à la fermeture de la boîte de dialogue, en contrôlant la valeur renvoyée par la fonction ShowDialog(). Plusieurs propriétés peuvent être initialisées avant d’appeler la méthode ShowDialog pour modifier l’apparence de la boîte de dialogue Imprimer : Propriété
Effet
PrinterSettings.Copies
Nombre d’exemplaires à imprimer.
PrinterSettings.PrintToFile
État de la case à cocher Imprimer dans un fichier.
AllowCurrentPage
Affichage du contrôle Page en cours.
AllowPrintToFile
Affichage du contrôle Imprimer dans un fichier.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
164
Visual Basic 2010
Propriété
Effet
AllowSelection
Affichage du contrôle Sélection.
AllowSomePages
Affichage du contrôle Pages.
PrinterSettings.MaximumPage
Le plus grand numéro de page que l’utilisateur peut entrer dans la zone de texte A.
PrinterSettings.MinimumPage
Le plus petit numéro de page que l’utilisateur peut entrer dans la zone de texte De.
PrinterSettings.FromPage
Numéro de la première page à imprimer.
PrinterSettings.ToPage
Numéro de la dernière page à imprimer.
Une fois que les propriétés de votre choix ont été renseignées, un appel à la méthode ShowDialog() affiche la boîte de dialogue Imprimer. Après la fermeture de cette boîte, vous pouvez utiliser les propriétés PrinterSettings.Copies, PrinterSettings.FromPage, PrinterSettings.ToPage, PrinterSettings.MaximumPage et PrinterSettings.MinimumPage pour connaître les paramètres sélectionnés par l’utilisateur.
Exemple Nous allons définir un projet qui permettra à l’utilisateur de modifier le paramétrage par défaut de l’impression et, éventuellement, de choisir une autre imprimante. L’objectif à atteindre est représenté à la Figure 4.8. Figure 4.8 Utilisation des boîtes de dialogue Impression et Configuration de l’impression pour modifier le paramétrage par défaut de l’imprimante.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 4
Boîtes de dialogue communes
165
Réalisation Définissez un nouveau projet. Ajoutez le contrôle PrintDialog dans la feuille de l’appli cation. Cliquez dessus et donnez-lui le nom CMD (propriété Name). Définissez deux boutons de commande et une zone de texte. Nommez les deux boutons Paramètres d’impression et Quitter (propriété Caption). Définissez enfin le titre de la boîte de dialogue : Paramètres d’impression (propriété Caption de la boîte de dialogue). La feuille du projet doit maintenant ressembler à la Figure 4.9. Figure 4.9 La boîte de dialogue du projet, en mode Création.
Ensuite, affectez des lignes de code aux deux boutons de commande. Comme dans les miniapplications précédentes, la procédure associée au clic sur le bouton Quitter se contente d’exécuter l’instruction End pour mettre fin au programme. La procédure associée au bouton Paramètres d’impression est plus complexe : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click CMD.PrinterSettings.Copies = 3 ‘Trois copies par défaut CMD.AllowCurrentPage = True ‘Bouton Tout affiché CMD.AllowPrintToFile = True ‘Option Impression dans un fichier affichée CMD.PrinterSettings.PrintToFile = False ‘Option Impression dans un fichier „ décochée par défaut CMD.AllowSelection = True ‘Bouton Sélection affiché CMD.AllowSomePages = True ‘Bouton Pages affiché If CMD.ShowDialog() = Windows.Forms.DialogResult.OK Then TextBox1.Text = "Paramètres enregistrés." Else TextBox1.Text = "Les paramètres n’ont pas été pris en compte." End If End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
166
Visual Basic 2010
Le premier bloc d’instructions définit les options de la boîte de dialogue Imprimer : CMD.PrinterSettings.Copies = 3 ‘Trois copies par défaut CMD.AllowCurrentPage = True ‘Bouton Tout affiché CMD.AllowPrintToFile = True ‘Option Impression dans un fichier affichée CMD.PrinterSettings.PrintToFile = False ‘Option Impression dans un fichier décochée „ par défaut CMD.AllowSelection = True ‘Bouton Sélection affiché CMD.AllowSomePages = True ‘Bouton Pages affiché
La boîte de dialogue Imprimer apparaît en appelant la méthode ShowDialog(). Si l’utilisateur clique sur le bouton OK, ShowDialog renvoie la valeur Windows.Forms.DialogResult. OK : If CMD.ShowDialog() = Windows.Forms.DialogResult.OK Then
Dans ce cas, un message indiquant que le paramétrage a été pris en compte s’affiche dans la zone de texte : TextBox1.Text = "Paramètres enregistrés."
Si le bouton Annuler est choisi par l’utilisateur, un message indiquant que le paramétrage n’a pas été pris en compte s’affiche dans la zone de texte : Else TextBox1.Text = "Les paramètres n’ont pas été pris en compte."
Cette application se trouve dans le dossier Imprimer après installation des sources de l’ouvrage.
La boîte de dialogue Rechercher un dossier La boîte de dialogue Rechercher un dossier est utilisée pour sélectionner un dossier sur les disques de l’ordinateur local ou sur le réseau. S’il le souhaite, l’utilisateur peut également créer un nouveau dossier et lui donner le nom de son choix. Tout comme pour les autres boîtes de dialogue communes, il est possible de connaître le bouton cliqué par l’utilisateur à la fermeture de la boîte de dialogue, en contrôlant la valeur renvoyée par la fonction ShowDialog().
Exemple Nous allons définir un projet qui permettra à l’utilisateur de désigner un dossier de son choix et, éventuellement, de créer un nouveau dossier. L’objectif à atteindre est représenté à la Figure 4.10.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 4
Boîtes de dialogue communes
167
Figure 4.10 Utilisation de la boîte de dialogue commune Rechercher un dossier.
Réalisation Définissez un nouveau projet. Ajoutez le contrôle FolderBrowserDialog dans la feuille de l’application. Cliquez dessus et donnez-lui le nom CMD (propriété Name). Définissez deux boutons de commande et une zone de texte. Nommez les deux boutons Rechercher et Quitter (propriété Caption). Définissez enfin le titre de la boîte de dialogue : Rechercher un dossier (propriété Caption de la boîte de dialogue). La feuille du projet doit maintenant ressembler à la Figure 4.11. Figure 4.11 La boîte de dialogue du projet, en mode Création.
Vous allez donner vie aux deux boutons de commande en leur affectant des lignes de code. Comme dans les mini-applications précédentes, la procédure associée au clic sur le bouton Quitter se contente d’exécuter l’instruction End pour mettre fin au programme.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
168
Visual Basic 2010
La procédure associée au bouton Rechercher est plus complexe : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click CMD.Description = "Choisissez un dossier" CMD.ShowNewFolderButton = True CMD.RootFolder = Environment.SpecialFolder.MyDocuments If CMD.ShowDialog() = Windows.Forms.DialogResult.OK Then TextBox1.Text = CMD.SelectedPath Else TextBox1.Text = "Aucun dossier n’a été sélectionné" End If End Sub
Les trois premières instructions initialisent la boîte de dialogue Rechercher un dossier : CMD.Description = "Choisissez un dossier" CMD.ShowNewFolderButton = True CMD.RootFolder = Environment.SpecialFolder.MyDocuments
La propriété Description définit le texte affiché dans la partie supérieure de la boîte de dialogue. La propriété ShowNewFolderButton indique si le bouton Créer un nouveau dossier doit être affiché (True) ou masqué (False). Enfin, la propriété RootFolder détermine le dossier affiché à la racine de l’arborescence. SpecialFolder donne accès à de nombreux dossiers spéciaux, tels que Application Data, Desktop, Favorites, History, My Documents, My Pictures, Program Files, StartMenu, etc. L’instruction suivante teste la valeur renvoyée par la fonction ShowDialog() pour connaître le bouton cliqué par l’utilisateur pour fermer la boîte de dialogue Rechercher un dossier : If CMD.ShowDialog() = Windows.Forms.DialogResult.OK Then
Si le bouton OK a été cliqué, le dossier sélectionné s’affiche dans la zone de texte TextBox1 : TextBox1.Text = CMD.SelectedPath
Dans le cas contraire, un message indiquant qu’aucun dossier n’a été sélectionné apparaît dans la zone de texte TextBox1 : Else TextBox1.Text = "Aucun dossier n’a été sélectionné"
Cette application se trouve dans le dossier Project\OuvrirDossier des sources de l’ouvrage.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
5 Un peu plus loin Par l’intermédiaire de trois exemples, ce chapitre vous montre à quel point Visual Basic 2010 facilite l’accès aux fonctionnalités avancées de Windows. Dans un premier temps, vous apprendrez à réaliser une application MDI qui manipule plusieurs fenêtres enfants. En vous servant des autres chapitres du livre et en y ajoutant quelques instructions de votre cru, vous pourrez la transformer en un bloc-notes évolué, un logiciel de traitement d’images, un navigateur web, ou tout autre application dans laquelle plusieurs fenêtres de document peuvent être ouvertes. Dans un deuxième temps, vous ferez connaissance avec le système d’affichage GDI+ et vous verrez comment utiliser certaines de ses fonctions pour afficher du texte sous une forme graphique dans la feuille d’une application Visual Basic 2010. Enfin, vous apprendrez à manipuler le presse-papiers de Windows, en utilisant les procédures et fonctions traditionnelles de l’environnement .NET, ou par l’intermédiaire de l’espace de nom My, apparu avec la version 2.0 de .NET.
Une application MDI Certaines applications Windows ne peuvent manipuler qu’une seule fenêtre à la fois. C’est le cas de l’application graphique Microsoft Paint, livrée en standard depuis la version 95 de Windows. D’autres applications, comme le célèbre Word pour Windows, autorisent
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
170
Visual Basic 2010
l’ouverture simultanée de plusieurs documents. Cette possibilité est intéressante à plus d’un titre, en particulier :
∑ ∑ ∑
Elle facilite les copier-coller entre documents. Elle permet de voir plusieurs parties d’un même document. Elle permet de construire un document en ayant un ou plusieurs autres documents sous les yeux. En utilisant Visual Basic 2010, il est très simple de définir des applications comprenant plusieurs documents. Ces applications sont dites MDI (Multiple Document Interface). Elles partagent en général un système de menus, une barre d’outils et/ou une barre d’état. Les fenêtres d’un document sont également appelées fenêtres enfants (child). La fenêtre de base, qui contient le système de menus, la barre d’outils et la barre d’état, est la fenêtre parent. Pour concevoir une application MDI, vous devez au minimum définir une feuille parent et une feuille enfant. Chaque document ouvert ou créé dans l’application utilisera la même feuille parent en arrière-plan et une feuille enfant personnelle à l’intérieur de la feuille parent. La fenêtre parent est une feuille Visual Basic traditionnelle pour laquelle la propriété IsMDIContainer a été initialisée à True. La fenêtre enfant est matérialisée par une feuille Windows Form traditionnelle.
Création d’un formulaire parent Le formulaire MDI parent est le fondement d’une application MDI. Il donne accès et contient toutes les fenêtres MDI enfants. Pour définir un formulaire MDI parent, commencez par créer une nouvelle application avec la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. L’entrée Visual Basic/Windows étant sélectionnée sous Modèles installés, choisissez le modèle Application Windows Forms, nommez le projet Bloc Notes et validez en cliquant sur OK. Dans la fenêtre des propriétés, attribuez la valeur True à la propriété IsMDIContainer. Cette simple action désigne le formulaire en cours d’édition comme un conteneur MDI de fenêtres enfants. Ajoutez un contrôle MenuStrip au formulaire et définissez le menu suivant : Élément de menu principal
Élément de menu secondaire
Fichier
Nouveau
Fichier
Quitter
Fenêtre
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 5
Un peu plus loin
171
La commande de menu Fichier/Nouveau sera utilisée pour créer des fenêtres enfants, et le menu Fenêtre, pour basculer entre les diverses fenêtres enfants ouvertes. Cliquez sur le contrôle MenuStrip dans la feuille de l’application et affectez la valeur FenêtreToolStripMenuItem à sa propriété MdiWindowListItem. Cette simple action affecte au menu Fenêtre la liste des fenêtres MDI enfants ouvertes et indique par une coche la fenêtre enfant active.
Création d’un modèle de fenêtre enfant Lancez la commande Ajouter un formulaire Windows dans le menu Projet pour ajouter un nouveau formulaire au projet. Choisissez Windows Form dans la boîte de dialogue Ajouter un nouvel élément, donnez le nom Modèle Enfant au nouveau formulaire et cliquez sur Ajouter. Faites glisser un contrôle RichTextBoxControl de la Boîte à outils jusqu’au nouveau formulaire. Dans la fenêtre des propriétés, déroulez la liste Dock et cliquez sur le rectangle central (voir Figure 5.1). Cette action affecte la valeur Fill à la propriété Dock et la valeur Top, Left à la propriété Anchor. Le contrôle RichTextBox remplira totalement la zone du formulaire MDI enfant, même si ce dernier est redimensionné. Figure 5.1 Cliquez ici pour maximiser le contrôle RichTextBox.
Déroulez le menu Fichier dans la feuille de l’application et double-cliquez sur la commande Nouveau. Cette action affiche le squelette de la procédure NouveauToolStripMenuItem_ Click(). Complétez cette procédure comme suit : Private Sub NouveauToolStripMenuItem_Click(ByVal sender As System.Object,
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
172
Visual Basic 2010
„ ByVal e As System.EventArgs) Handles NouveauToolStripMenuItem.Click Dim NewMDIChild As New Modèle_Enfant NewMDIChild.MdiParent = Me NewMDIChild.Show() End Sub
La première ligne définit l’objet fenêtre fille MDI NewMDIChild : Dim NewMDIChild As New Form2()
La deuxième instruction associe la fenêtre fille avec le conteneur mère : NewMDIChild.MDIParent = Me
Enfin, la troisième instruction affiche la fenêtre fille à l’intérieur de la fenêtre mère : NewMDIChild.Show()
Pour compléter le programme, déroulez le menu Fichier dans la feuille de l’application et double-cliquez sur la commande Quitter. Complétez la procédure QuitterToolStripMenuItem_Click() comme suit : Private Sub QuitterToolStripMenuItem_Click(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles QuitterToolStripMenuItem.Click End End Sub
Vous pouvez maintenant compiler et lancer l’application en appuyant sur la touche F5. La commande Fichier/Nouveau affiche une fenêtre fille dans la fenêtre principale de l’application. Si vous ouvrez plusieurs fenêtres avec cette commande, vous pouvez utiliser le menu Fenêtres pour basculer de l’une à l’autre (voir Figure 5.2). Figure 5.2 Deux fenêtres filles ont été ouvertes dans cette application MDI.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 5
Un peu plus loin
173
Le code de l’application se réduit aux deux procédures événementielles NouveauTool StripMenuItem_Click () et QuitterToolStripMenuItem_Click (). L’application se trouve dans le dossier Bloc Notes après installation des sources de l’ouvrage : Public Class Form1 Private Sub NouveauToolStripMenuItem_Click(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles NouveauToolStripMenuItem.Click Dim NewMDIChild As New Modèle_Enfant NewMDIChild.MdiParent = Me NewMDIChild.Show() End Sub Private Sub QuitterToolStripMenuItem_Click(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles QuitterToolStripMenuItem.Click End End Sub End Class
Polices de caractères Les polices installées relèvent de la classe FontFamily et l’affichage de texte utilise le système d’affichage GDI+. Pour mieux comprendre comment utiliser ces deux éléments, nous allons définir un petit projet dans lequel les polices installées seront accessibles à travers une liste déroulante. Lorsque l’utilisateur sélectionnera une entrée dans cette liste, un texte de corps 20 s’affichera dans la police choisie (voir Figure 5.3). Figure 5.3 Le programme Polices de caractères en mode Exécution.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
174
Visual Basic 2010
Définissez un nouveau projet avec la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows. Choisissez le modèle Application Windows Forms et validez. Ajoutez un Label, un ComboBox et un contrôle Button à la feuille du projet. Modifiez les propriétés de ces contrôles comme suit : Contrôle
Propriété
Valeur
Form1
Text
Polices de caractères
Label1
Text
Choisissez une police
Button1
Text
Quitter
Double-cliquez sur un emplacement inoccupé de la feuille et complétez la procédure Form1_Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load Dim strFonts As New Collections.ArrayList(10) Dim Font As FontFamily For Each Font In FontFamily.Families strFonts.Add(Font.Name) Next ComboBox1.DataSource = strFonts End Sub
La première instruction définit l’objet collection strFonts, dans lequel seront stockés les noms des polices installées : Dim strFonts As New Collections.ArrayList(10)
La deuxième instruction définit l’objet FontFamily Font, qui sera utilisé pour accéder à chacune des polices installées : Dim Font As FontFamily
Pour parcourir toutes les polices installées, le plus simple consiste à utiliser une instruction For Each : For Each Font In FontFamily.Families
Le nom de chacune des polices est alors ajouté à la collection strFonts : strFonts.Add(Font.Name)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 5
Un peu plus loin
175
Lorsque toutes les polices ont été parcourues, la liste déroulante est remplie en initialisant sa propriété DataSource avec la collection strFonts : Next ComboBox1.DataSource = strFonts
Pour être en mesure de faire référence aux fonctions de manipulation de texte de GDI+, vous devez inclure une instruction Imports en tête de code : Imports System.Drawing
Définissez également l’objet Graphics g, juste après la déclaration de classe Public Class Form1. Cet objet sera utilisé pour réaliser l’affichage du texte : Dim g As Graphics
Pour être en mesure d’afficher un texte dès le lancement du programme, vous allez définir la procédure Form1_Paint(). Sélectionnez l’entrée (Form1 Evénements) dans la première ������������������� la procéliste déroulante de la fenêtre de code et l’entrée Paint dans la seconde. Complétez dure Form1_Paint comme suit : Private Sub Form1_Paint(ByVal sender As Object, ByVal e As System.Windows.Forms. „ PaintEventArgs) Handles MyBase.Paint g = Me.CreateGraphics g.DrawString("Police " + ComboBox1.Text + ", 20 points", New Font(ComboBox1. „ Text, 20), Brushes.Black, New PointF(30, 100)) End Sub
La première instruction donne accès au système graphique g : g = Me.CreateGraphics
La seconde instruction utilise la procédure DrawString() pour afficher du texte dans la fenêtre : g.DrawString("Police " + ComboBox1.Text + ", 20 points", New Font(ComboBox1.Text, 20), „ Brushes.Black, New PointF(30, 100))
La procédure DrawString() existe en plusieurs déclinaisons : DrawString(str, DrawString(str, DrawString(Str, DrawString(Str, DrawString(Str, DrawString(Str,
police, police, police, police, police, police,
pinceau, pinceau, pinceau, pinceau, pinceau, pinceau,
PF) RF) PF, RF, Sx, Sx,
Format) Format) Sy) Sy, Format)
Voici la signification des arguments de cette procédure :
∑
str est la chaîne à afficher.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
176
∑ ∑ ∑
Visual Basic 2010
police est le nom de la police à utiliser. pinceau est le pinceau avec lequel les caractères doivent être peints. PF est une référence à un objet PointF qui identifie le coin supérieur gauche de la zone de tracé.
∑
RF est une référence à un objet RectangleF qui identifie la zone de tracé (coordonnées du point supérieur gauche, longueur et hauteur).
∑ ∑
Sx et Sy sont les coordonnées Single du coin supérieur gauche de la zone de tracé. Format est une référence à un objet StringFormat qui spécifie le format d’affichage
(espacement, alignement, etc.).
Dans cet exemple, la procédure DrawString() est utilisée dans sa plus simple expression. Remarquez la définition de la police et de l’objet PointF, directement dans l’appel à la procédure : g.DrawString("Police " + ComboBox1.Text + ", 20 points", New Font(ComboBox1.Text, 20), „ Brushes.Black, New PointF(30, 100))
Pour modifier l’affichage lorsque l’utilisateur sélectionne une police dans la liste déroulante, nous allons utiliser des instructions du même type. Double-cliquez sur le contrôle ComboBox1 et complétez la procédure ComboBox1_SelectedIndexChanged() comme suit : Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged g = Me.CreateGraphics g.Clear(Me.BackColor) g.DrawString("Police " + ComboBox1.Text + ", 20 points", New Font(ComboBox1. „ Text, 20), Brushes.Black, New PointF(30, 100)) End Sub
La première instruction donne accès à l’objet graphique g : g = Me.CreateGraphics
Pour ne pas interférer avec l’affichage précédent, la zone graphique de la fenêtre est effacée à l’aide de la procédure Clear(). La couleur utilisée est la couleur de fond actuelle (Me. BackColor) : g.Clear(Me.BackColor)
Enfin, un appel à la procédure DrawString() affiche le nouveau texte en utilisant la police sélectionnée : g.DrawString("Police " + ComboBox1.Text + ", 20 points", New Font(ComboBox1.Text, 20), „ Brushes.Black, New PointF(30, 100))
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 5
Un peu plus loin
177
Pour terminer cette application, double-cliquez sur le bouton de commande et ajoutez une instruction End dans la procédure Button1_Click() : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click End End Sub
Voici le listing complet de l’application. Vous trouverez les fichiers correspondants dans le dossier Polices après installation des sources de l’ouvrage. Imports System.Drawing Public Class Form1 Dim g As Graphics Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load Dim strFonts As New Collections.ArrayList(10) Dim Font As FontFamily For Each Font In FontFamily.Families strFonts.Add(Font.Name) Next ComboBox1.DataSource = strFonts End Sub Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged g = Me.CreateGraphics g.Clear(Me.BackColor) g.DrawString("Police " + ComboBox1.Text + ", 20 points", „ New Font(ComboBox1.Text, 20), Brushes.Black, New PointF(30, 100)) End Sub Private Sub Form1_Paint(ByVal sender As Object, ByVal e As System.Windows. „ Forms.PaintEventArgs) Handles MyBase.Paint g = Me.CreateGraphics g.DrawString("Police " + ComboBox1.Text + ", 20 points", „ New Font(ComboBox1.Text, 20), Brushes.Black, New PointF(30, 100)) End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. EventArgs) Handles Button1.Click End End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
178
Visual Basic 2010
Les possibilités offertes par GDI+ au niveau des polices de caractères sont très étendues. Il est par exemple possible d’effectuer des rotations ou des inclinaisons sur le texte ou encore d’utiliser un pinceau non uniforme pour dessiner les caractères. Les rotations et inclinaisons se font à l’aide de la procédure RotateTransform(). Par exemple, l’instruction suivante provoque une inclinaison de 45 degrés du texte : G.RotateTransform(45)
Pour utiliser un pinceau non uniforme, il suffit de le définir comme tel. À titre d’exemple, l’instruction suivante définit un objet Bitmap à partir du fichier c:\test\colorwir.bmp : Dim Bmap = New Bitmap("C:\\test\\colorwir.bmp")
Cet objet Bitmap est utilisé pour définir un pinceau TextureBrush B : Dim B = New TextureBrush(Bmap)
Il suffit maintenant d’utiliser ce pinceau dans la procédure DrawString() pour obtenir un texte texturé : g.DrawString(ComboBox1.Text, New Font(ComboBox1.Text, 120, FontStyle.Bold), B, „ New PointF(30, 60))
La Figure 5.4 représente l’effet obtenu dans le programme précédent lorsque la police Agency FB est sélectionnée. Figure 5.4 Un exemple de texturage à l’aide d’un fichier bitmap.
Voici le code de l’application. Les fichiers correspondants se trouvent dans le dossier Polices2 après installation des sources de l’ouvrage : Imports System.Drawing.Text
Public Class Form1 Dim g As Graphics
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 5
Un peu plus loin
179
Dim Bmap = New Bitmap("C:\\test\\colorwir.bmp") Dim B = New TextureBrush(Bmap) Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load Dim strFonts As New Collections.ArrayList(10) Dim Font As FontFamily For Each Font In FontFamily.Families strFonts.Add(Font.Name) Next ComboBox1.DataSource = strFonts End Sub Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged g = Me.CreateGraphics g.Clear(Me.BackColor) g.DrawString(ComboBox1.Text, New Font(ComboBox1.Text, 120, FontStyle. „ Bold), B, New PointF(30, 60)) End Sub Private Sub Form1_Paint(ByVal sender As Object, ByVal e As System.Windows. „ Forms.PaintEventArgs) Handles MyBase.Paint g = Me.CreateGraphics g.DrawString(ComboBox1.Text, New Font(ComboBox1.Text, 120, FontStyle. „ Bold), B, New PointF(30, 60)) End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click End End Sub End Class
Le Presse-papiers Pour accéder au presse-papiers de Windows, vous pouvez utiliser :
∑
les procédures et fonctions traditionnelles de .NET, telles que SetDataObject() et GetDataObject() ;
∑
les procédures et fonctions apparues dans la version 2.0 de .NET, relatives à l’objet My.Computer.Clipboard.
Nous allons examiner ces deux approches dans les pages suivantes.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
180
Visual Basic 2010
Accès traditionnel au presse-papiers Visual Basic 2010 possède un certain nombre de fonctions qui lui permettent de manipuler le presse-papiers de Windows :
∑ ∑
SetDataObject() place un objet dans le presse-papiers.
∑
GetDataObject().GetData("typeObjet") permet de récupérer le contenu du pressepapiers sous la forme d’un objet dont le type est spécifié dans la fonction GetData().
GetDataObject().GetDataPresent("typeObjet") permet de tester le type de l’objet
présent dans le presse-papiers.
L’application développée dans ce chapitre montre comment copier un objet bitmap dans le presse-papiers, le récupérer et l’affecter à un contrôle PictureBox. Définissez un nouveau projet de type Application Windows Forms avec la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. L’entrée Visual Basic/Windows étant sélectionnée dans le volet gauche, choisissez le modèle Application Windows Forms, nommez le projet OutilsEtat et validez en cliquant sur OK. Ajoutez un contrôle PictureBox sur la feuille du projet. Maximisez la taille de ce contrôle en donnant la valeur Fill à sa propriété Dock (pour cela, développez la liste déroulante de la propriété Dock et cliquez sur le rectangle central). Affectez une image quelconque au contrôle PictureBox par l’intermédiaire de sa propriété Image (dans cet exemple, le programme utilise les images Colorwir.bmp et Vide.bmp, qui se trouvent dans le dossier Presse papiers après installation des sources de l’ouvrage). Ajoutez un contrôle ContextMenuStrip au projet et définissez les entrées de menu suivantes : Couper, Copier, Coller, Effacer et Quitter. Renommez ces commandes à l’image de leurs noms respectifs (la propriété Name de la commande Couper est initialisée à "Couper", la propriété Nom de la commande Coller est initialisée à "Coller", etc.). Pour rendre le menu opérationnel, vous devez modifier la propriété ContextMenuStrip des objets sur lesquels vous voulez l’utiliser. Sélectionnez Form1 dans la fenêtre des propriétés et affectez la valeur ContextMenuStrip1 à la propriété ContextMenuStrip. Double-cliquez sur la commande Couper et complétez la procédure Couper_Click() comme suit : Private Sub Couper_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Couper.Click Clipboard.SetDataObject(PictureBox1.Image) PictureBox1.Image = Image.FromFile("c:\vide.bmp") End Sub
La première instruction place le contenu de l’image (Picture1.Image) dans le pressepapiers (Clipboard.SetDataObject()). La deuxième instruction affecte l’image blanche c:\vide.bmp au contrôle PictureBox1.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 5
Un peu plus loin
181
Double-cliquez sur la commande Copier et complétez la procédure Copier_Click() comme suit : Private Sub Copier_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Copier.Click Clipboard.SetDataObject(PictureBox1.Image) End Sub
Cette procédure ressemble à Couper_Click(). Mais ici, après la copie de l’image dans le presse-papiers, le contrôle PictureBox n’est pas effacé. Double-cliquez sur la commande Coller. La procédure Coller_Click() est légèrement plus complexe que les précédentes : Private Sub Coller_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Coller.Click If (Clipboard.GetDataObject().GetDataPresent("Bitmap")) Then PictureBox1.Image = (Clipboard.GetDataObject().GetData("Bitmap")) End If End Sub
L’instruction if teste le contenu du presse-papiers à l’aide de la fonction GetDataObject(). GetDataPresent("Bitmap"). If (Clipboard.GetDataObject().GetDataPresent("Bitmap")) Then
Si la valeur True est renvoyée par cette fonction, cela signifie que le contenu du presse-papiers est bien de type bitmap. Dans ce cas, la fonction GetDataObject().GetData("Bitmap") récupère le contenu du presse-papiers et l’affecte au contrôle PictureBox : PictureBox1.Image = (Clipboard.GetDataObject().GetData("Bitmap"))
Double-cliquez sur la commande Effacer et complétez la procédure Effacer_Click() comme suit : Private Sub Effacer_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Effacer.Click PictureBox1.Image = Image.FromFile("c:\vide.bmp") End Sub
Cette procédure se contente de copier l’image blanche c:\vide.bmp dans le contrôle PictureBox afin de l’effacer. Double-cliquez enfin sur la commande Quitter et ajoutez le mot End à la procédure Quitter_Click() : Private Sub Quitter_Click(ByVal sender As System.Object, ByVal e As System „ .EventArgs) Handles Quitter.Click End End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
182
Visual Basic 2010
Voici le listing complet du programme. Vous trouverez les fichiers correspondants dans le dossier Presse papiers après installation des sources de l’ouvrage. Public Class Form1 Private Sub Couper_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Couper.Click Clipboard.SetDataObject(PictureBox1.Image) PictureBox1.Image = Image.FromFile("c:\vide.bmp") End Sub Private Sub Effacer_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Effacer.Click PictureBox1.Image = Image.FromFile("c:\vide.bmp") End Sub Private Sub Copier_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Copier.Click Clipboard.SetDataObject(PictureBox1.Image) End Sub Private Sub Coller_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Coller.Click If (Clipboard.GetDataObject().GetDataPresent("Bitmap")) Then PictureBox1.Image = (Clipboard.GetDataObject().GetData("Bitmap")) End If End Sub Private Sub Quitter_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Quitter.Click End End Sub End Class
Accès au presse-papiers via .NET 4.0 Dupliquez le contenu du dossier Presse papiers dans le dossier Presse papiers 2. Ouvrez la solution Presse papiers.sln du dossier Presse papiers 2. Pour utiliser les procédures et fonction de .NET 4.0, vous allez modifier les procédures événementielles de l’application. Lancez la commande Code dans le menu Affichage (ou appuyez sur la touche F7). Modifiez la procédure Couper_Click() comme suit : Private Sub Couper_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Couper.Click
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 5
Un peu plus loin
183
My.Computer.Clipboard.SetImage(PictureBox1.Image) PictureBox1.Image = Image.FromFile("c:\vide.bmp") End Sub
La première instruction place le contenu du contrôle PictureBox dans le presse-papiers à l’aide de la procédure SetImage(). La seconde instruction copie le contenu du fichier c:\vide.bmp dans le contrôle PictureBox. Vous allez maintenant modifier la procédure Copier_Click() comme suit : Private Sub Copier_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Copier.Click My.Computer.Clipboard.SetImage(PictureBox1.Image) End Sub
L’unique instruction de cette procédure copie le contenu du contrôle PictureBox dans le presse-papiers à l’aide de la procédure SetImage(). La dernière action va consister à modifier la procédure Coller_Click() : Private Sub Coller_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Coller.Click If (My.Computer.Clipboard.ContainsImage) Then PictureBox1.Image = My.Computer.Clipboard.GetImage() End If End Sub
L’instruction If teste si le presse-papiers contient un objet graphique : If (My.Computer.Clipboard.ContainsImage) Then
Dans l’affirmative, cet objet est affecté au presse-papiers : PictureBox1.Image = My.Computer.Clipboard.GetImage()
Les procédures Effacer_Click() et Quitter_Click() ne changent pas, car elles utilisent des instructions Visual Basic traditionnelles. Voici le listing complet de l’application. Les fichiers correspondants se trouvent dans le dossier Projects\Presse papiers 2 des sources de l’ouvrage. Public Class Form1 Private Sub Couper_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Couper.Click My.Computer.Clipboard.SetImage(PictureBox1.Image) PictureBox1.Image = Image.FromFile("c:\vide.bmp") End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
184
Visual Basic 2010
Private Sub Copier_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Copier.Click My.Computer.Clipboard.SetImage(PictureBox1.Image) End Sub Private Sub Coller_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Coller.Click If (My.Computer.Clipboard.ContainsImage) Then PictureBox1.Image = My.Computer.Clipboard.GetImage() End If End Sub Private Sub Effacer_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Effacer.Click PictureBox1.Image = Image.FromFile("c:\vide.bmp") End Sub Private Sub Quitter_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Quitter.Click End End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
6 Implémenter des menus Les menus traditionnels et contextuels sont banalisés sous la forme de simples contrôles dans la Boîte à outils. Dans les pages qui suivent, nous allons créer deux applications. La première permettra de tracer des ronds et des carrés par l’intermédiaire d’un système de menus et la seconde, par l’intermédiaire d’un menu contextuel.
Système de menus traditionnel Lancez la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. L’entrée Visual Basic/Windows étant sélectionnée dans le volet gauche, choisissez le modèle Application Windows Forms, nommez le projet Menu et validez en cliquant sur OK. Insérez un contrôle MenuStrip sur la feuille de l’application. Ce contrôle est automatiquement reporté dans la partie inférieure de la fenêtre, sous la forme d’une icône intitulée MenuStrip1. Cliquez sur cette icône et définissez les entrées principales et secondaires du menu, directement sur la feuille de l’application :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
186
Visual Basic 2010
Commandes principales
Commandes secondaires
Tracer
Rond et Carré
Rond
Rouge et Bleu
Carré
Rouge et Bleu
Quitter
Application
Nous allons associer les raccourcis clavier Ctrl+R et Ctrl+C aux commandes Tracer/Rond et Tracer/Carré. Pour cela :
∑
Cliquez sur l’entrée secondaire Rond sous Tracer et affectez la valeur Ctrl+R à la propriété ShortcutKeys.
∑
Cliquez sur l’entrée secondaire Carré sous Tracer et affectez la valeur Ctrl+C à la propriété ShortcutKeys.
Pour vous aider dans la saisie des raccourcis clavier, le plus simple consiste à cliquer sur la flèche située à droite de la valeur de la propriété ShortcutKey et à utiliser la boîte de saisie affichée (voir Figure 6.1). Figure 6.1 Saisie d’un raccourci-clavier.
Le raccourci-clavier s’affiche à droite de la commande de menu, juste après sa saisie (voir Figure 6.2).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 6
Implémenter des menus
187
Figure 6.2 Les deux raccourcis clavier apparaissent en clair.
Par défaut, la commande secondaire Rond doit être validée. Cette affectation par défaut sera signalée par une coche devant la commande secondaire Rond. Cliquez sur cette commande et affectez la valeur True à la propriété Checked. Cliquez sur la commande principale Carré et affectez la valeur False à la propriété Visible pour cacher le menu Carré par défaut. Pour faciliter la compréhension du listing, vous allez redéfinir le nom des commandes de menu comme suit : Commande
Propriété Name
Tracer/Rond
TracerRond
Tracer/Carré
TracerCarré
Rond
Rond
Carré
Carré
Rond/Rouge
RondRouge
Rond/Bleu
RondBleu
Quitter/Application
QuitterApplication
Nous allons maintenant affecter du code aux commandes de menu. Double-cliquez sur la commande secondaire Tracer/Rond et complétez la procédure TracerRond_Click() comme suit : Private Sub TracerRond_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles TracerRond.Click TracerRond.Checked = True TracerCarré.Checked = False Rond.Visible = True Carré.Visible = False End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
188
Visual Basic 2010
Cette procédure affiche une coche devant la commande secondaire Tracer/Rond, supprime l’éventuelle coche devant la commande secondaire Tracer/Carré, active le menu principal Rond et cache le menu principal Carré. Double-cliquez sur la commande secondaire Tracer/Carré et complétez la procédure TracerCarré_Click() comme suit : Private Sub TracerCarré_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles TracerCarré.Click TracerRond.Checked = False TracerCarré.Checked = True Rond.Visible = False Carré.Visible = True End Sub
Cette procédure effectue des actions analogues à la précédente : suppression de la coche devant la commande secondaire Tracer/Rond, affichage d’une coche devant la commande secondaire Tracer/Carré, dissimulation de la commande principale Rond et affichage de la commande principale Carré. Construit sur GDI+, le système Windows Forms donne accès à une bibliothèque d’imagerie graphique et de texte 2-D et 3-D très fournie. Pour être en mesure d’afficher des éléments graphiques dans une feuille, vous devez définir un objet Graphics avec la fonction CreateGraphics(). Double-cliquez sur un emplacement libre de la feuille et complétez la procédure Form1_ Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load G = Me.CreateGraphics() End Sub
L’unique instruction de cette procédure définit l‘objet graphique G. Remarquez l’utilisation du mot-clé Me pour référencer l’instance de la classe en cours d’exécution. Pour compléter cette procédure, définissez l’objet G, dans les premières lignes du code : Dim G As Graphics
L’objet graphique G ayant été défini et implémenté, double-cliquez sur la commande secondaire Rond/Rouge et complétez la procédure RondRouge_Click() comme suit : Private Sub RondRouge_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs)Handles RondRouge.Click ‘ Création du rectangle dans lequel est inscrit le cercle Dim rect As New Rectangle(50, 50, 100, 100)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 6
Implémenter des menus
189
‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du cercle Dim Pen As New Pen(Color.Black, 3) G.DrawEllipse(Pen, rect) ‘ Remplissage du cercle Dim brBrush = New SolidBrush(Color.Red) G.FillEllipse(brBrush, rect) End Sub
La première ligne définit le rectangle dans lequel s’inscrit le cercle à tracer : Dim rect As New Rectangle(50, 50, 100, 100)
La deuxième instruction efface le contenu de la fenêtre afin de ne pas gêner le tracé en cours. Remarquez l’utilisation du mot-clé Me pour référencer la fenêtre en cours d’exécution : G.Clear(Me.BackColor)
Le bloc d’instructions suivant définit la couleur du crayon et trace un cercle à l’aide de la fonction DrawEllipse() : Dim Pen As New Pen(Color.Black, 3) G.DrawEllipse(Pen, rect)
Le dernier bloc d’instructions définit la couleur de remplissage brBrush et utilise la fonction FillEllipse() pour remplir le cercle : Dim brBrush = New SolidBrush(Color.Red) G.FillEllipse(brBrush, rect)
Double-cliquez sur la commande secondaire Rond/Bleu et complétez la procédure RondBleu_Click() comme suit : Private Sub RondBleu_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles RondBleu.Click ‘ Création du rectangle dans lequel est inscrit le cercle Dim rect As New Rectangle(50, 50, 100, 100) ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du cercle Dim Pen As New Pen(Color.White, 3) G.DrawEllipse(Pen, rect)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
190
Visual Basic 2010
‘ Remplissage du cercle Dim brBrush = New SolidBrush(Color.Blue) G.FillEllipse(brBrush, rect) End Sub
Comme vous pouvez le voir, le code de cette procédure est très proche de celui de RondRouge_Click(). Seules les couleurs du crayon et du remplissage changent. Nous n’y reviendrons pas. Double-cliquez sur la commande secondaire Carré/Rouge et complétez la procédure CarréRouge_Click() comme suit : Private Sub CarréRouge_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles CarréRouge.Click ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du carré Dim Pen As New Pen(Color.Black, 3) Dim rect As New Rectangle(50, 50, 100, 100) G.DrawRectangle(Pen, rect) ‘ Remplissage du carré Dim brBrush = New SolidBrush(Color.Red) G.FillRectangle(brBrush, rect) End Sub
Après avoir effacé le contenu de la fenêtre : G.Clear(Me.BackColor)
La couleur noire est affectée au crayon : Dim Pen As New Pen(Color.Black, 3)
Un objet rect de type Rectangle est alors défini et le carré rect est tracé en utilisant le crayon Pen : Dim rect As New Rectangle(50, 50, 100, 100) G.DrawRectangle(Pen, rect)
Le dernier bloc d’instructions définit la couleur de remplissage dans l’objet brBrush et utilise cet objet pour remplir le carré à l‘aide de la fonction FillRectangle() : Dim brBrush = New SolidBrush(Color.Red) G.FillRectangle(brBrush, rect)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 6
Implémenter des menus
191
Double-cliquez sur la commande secondaire Carré/Bleu et complétez la procédure CarréBleu_Click() comme suit : Private Sub CarréBleu_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles CarréBleu.Click ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du carré Dim Pen As New Pen(Color.White, 3) Dim rect As New Rectangle(50, 50, 100, 100) G.DrawRectangle(Pen, rect) ‘ Remplissage du carré Dim brBrush = New SolidBrush(Color.Blue) G.FillRectangle(brBrush, rect) End Sub
Le code de cette procédure est très proche de celui de CarréRouge_Click(). Seules les couleurs du crayon et du remplissage changent. Nous n’y reviendrons pas. Enfin, double-cliquez sur la commande secondaire Quitter/Application et ajoutez une instruction End à la procédure QuitterApplication_Click() : Private Sub QuitterApplication_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles QuitterApplication.Click End End Sub
Voici le listing complet de l’application. Le code généré par Form Designer a été masqué. Seul son en-tête apparaît en caractères italiques. Cette application se trouve dans le dossier Menu après installation des sources de l’ouvrage. Public Class Form1 Dim G As Graphics Private Sub MenuStrip1_ItemClicked(ByVal sender As System.Object, ByVal e „ As System.Windows.Forms.ToolStripItemClickedEventArgs) Handles MenuStrip1. „ ItemClicked End Sub Private Sub TracerRond_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles TracerRond.Click TracerRond.Checked = True TracerCarré.Checked = False
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
192
Visual Basic 2010
Rond.Visible = True Carré.Visible = False End Sub Private Sub TracerCarré_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles TracerCarré.Click TracerRond.Checked = False TracerCarré.Checked = True Rond.Visible = False Carré.Visible = True End Sub Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load ‘Définition de l’objet graphique G = Me.CreateGraphics() End Sub Private Sub RondRouge_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles RondRouge.Click ‘ Création du rectangle dans lequel est inscrit le cercle Dim rect As New Rectangle(50, 50, 100, 100) ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du cercle Dim Pen As New Pen(Color.Black, 3) G.DrawEllipse(Pen, rect) ‘ Remplissage du cercle Dim brBrush = New SolidBrush(Color.Red) G.FillEllipse(brBrush, rect) End Sub Private Sub RondBleu_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles RondBleu.Click ‘ Création du rectangle dans lequel est inscrit le cercle Dim rect As New Rectangle(50, 50, 100, 100) ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du cercle
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 6
Implémenter des menus
193
Dim Pen As New Pen(Color.White, 3) G.DrawEllipse(Pen, rect) ‘ Remplissage du cercle Dim brBrush = New SolidBrush(Color.Blue) G.FillEllipse(brBrush, rect) End Sub Private Sub CarréRouge_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles CarréRouge.Click ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du carré Dim Pen As New Pen(Color.Black, 3) Dim rect As New Rectangle(50, 50, 100, 100) G.DrawRectangle(Pen, rect) ‘ Remplissage du carré Dim brBrush = New SolidBrush(Color.Red) G.FillRectangle(brBrush, rect) End Sub Private Sub CarréBleu_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles CarréBleu.Click ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du carré Dim Pen As New Pen(Color.White, 3) Dim rect As New Rectangle(50, 50, 100, 100) G.DrawRectangle(Pen, rect) ‘ Remplissage du carré Dim brBrush = New SolidBrush(Color.Blue) G.FillRectangle(brBrush, rect) End Sub Private Sub QuitterApplication_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles QuitterApplication.Click End End Sub End Class
Cette application se trouve dans le dossier Menu après installation des sources de l’ouvrage.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
194
Visual Basic 2010
Menu contextuel Nous allons étendre les fonctionnalités de l’application précédente en lui ajoutant un menu contextuel. Ce menu contiendra deux entrées : Rouge et Bleu. En fonction de l’entrée sélectionnée sous le menu Tracer, un rond ou un carré bleu ou rouge apparaît dans la feuille. Pour mettre en place le menu contextuel, insérez un contrôle ContextMenuStrip sur la feuille de l’application. Ce contrôle est automatiquement reporté dans la partie inférieure de la fenêtre sous la forme d’une icône intitulée ContextMenuStrip1. Cliquez sur cette icône et définissez les deux entrées du menu : Rouge et Bleu. Pour faciliter la compréhension du code, renommez ces deux entrées (propriété Name) en Context Rouge et ContextBleu. Si vous exécutez l’application, vous verrez que le menu contextuel n’est pas actif lorsque vous cliquez du bouton droit de la souris. Pour le rendre opérationnel, vous devez modifier la propriété ContextMenuStrip du ou des objets sur lesquels vous voulez l’utiliser. Cliquez sur un endroit inoccupé de la feuille et affectez la valeur ContextMenuStrip1 à la propriété ContextMenuStrip. Pour compléter l’application, il ne reste plus qu’à définir les procédures événementielles associées aux deux entrées du menu contextuel. Ces procédures utilisent le même code que les procédures événementielles du système de menus. Pour éviter une redondance dans le code, vous allez définir les quatre procédures suivantes : Private Sub TracerRondRouge() ‘ Création du rectangle dans lequel est inscrit le cercle Dim rect As New Rectangle(50, 50, 100, 100) ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du cercle Dim Pen As New Pen(Color.Black, 3) G.DrawEllipse(Pen, rect) ‘ Remplissage du cercle Dim brBrush = New SolidBrush(Color.Red) G.FillEllipse(brBrush, rect) End Sub Private Sub TracerRondBleu() ‘ Création du rectangle dans lequel est inscrit le cercle Dim rect As New Rectangle(50, 50, 100, 100)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 6
Implémenter des menus
195
‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du cercle Dim Pen As New Pen(Color.White, 3) G.DrawEllipse(Pen, rect) ‘ Remplissage du cercle Dim brBrush = New SolidBrush(Color.Blue) G.FillEllipse(brBrush, rect) End Sub Private Sub TracerCarréRouge() ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du carré Dim Pen As New Pen(Color.Black, 3) Dim rect As New Rectangle(50, 50, 100, 100) G.DrawRectangle(Pen, rect) ‘ Remplissage du carré Dim brBrush = New SolidBrush(Color.Red) G.FillRectangle(brBrush, rect) End Sub Private Sub TracerCarréBleu() ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du carré Dim Pen As New Pen(Color.White, 3) Dim rect As New Rectangle(50, 50, 100, 100) G.DrawRectangle(Pen, rect) ‘ Remplissage du carré Dim brBrush = New SolidBrush(Color.Blue) G.FillRectangle(brBrush, rect) End Sub
Remplacez maintenant le code des procédures RondRouge_Click(), RondBleu_Click(), CarréRouge_Click() et CarréBleu_Click() par des appels aux procédures qui viennent d’être définies : Private Sub RondRouge_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles RondRouge.Click
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
196
Visual Basic 2010
TracerRondRouge() End Sub Private Sub RondBleu_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles RondBleu.Click TracerRondBleu() End Sub Private Sub CarréRouge_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles CarréRouge.Click TracerCarréRouge() End Sub Private Sub CarréBleu_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles CarréBleu.Click TracerCarréBleu() End Sub
Vous allez maintenant définir le code associé aux entrées du menu contextuel. Cliquez si nécessaire sur l’icône ContextMenu1 pour afficher le menu contextuel puis double-cliquez sur l’entrée Rouge. Complétez la procédure ContextRouge_Click() comme suit : Private Sub ContextRouge_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles ContextRouge.Click If (TracerRond.Checked = True) Then TracerRondRouge() Else TracerCarréRouge() End Sub
L’unique instruction de cette procédure affiche un rond rouge ou un carré rouge en fonction de l’état de la commande Tracer/Rond. Double-cliquez sur l’entrée Bleu du menu contextuel. Complétez la procédure ContextBleu_Click() comme suit : Private Sub ContextBleu_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles ContextBleu.Click If (TracerRond.Checked = True) Then TracerRondBleu() Else TracerCarréBleu() End Sub
Cette procédure est comparable à la précédente à ceci près qu’elle appelle TracerRondBleu() ou TracerCarréBleu() en fonction de l’entrée sélectionnée dans le menu Tracer. L’application est entièrement opérationnelle. Elle se trouve dans le dossier Menu2 après installation des sources de l’ouvrage : Public Class Form1 Dim G As Graphics
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 6
Implémenter des menus
197
Private Sub TracerRondRouge() ‘ Création du rectangle dans lequel est inscrit le cercle Dim rect As New Rectangle(50, 50, 100, 100) ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du cercle Dim Pen As New Pen(Color.Black, 3) G.DrawEllipse(Pen, rect) ‘ Remplissage du cercle Dim brBrush = New SolidBrush(Color.Red) G.FillEllipse(brBrush, rect) End Sub Private Sub TracerRondBleu() ‘ Création du rectangle dans lequel est inscrit le cercle Dim rect As New Rectangle(50, 50, 100, 100) ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du cercle Dim Pen As New Pen(Color.White, 3) G.DrawEllipse(Pen, rect) ‘ Remplissage du cercle Dim brBrush = New SolidBrush(Color.Blue) G.FillEllipse(brBrush, rect) End Sub Private Sub TracerCarréRouge() ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du carré Dim Pen As New Pen(Color.Black, 3) Dim rect As New Rectangle(50, 50, 100, 100) G.DrawRectangle(Pen, rect) ‘ Remplissage du carré
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
198
Visual Basic 2010
Dim brBrush = New SolidBrush(Color.Red) G.FillRectangle(brBrush, rect) End Sub Private Sub TracerCarréBleu() ‘ Effacement de la fenêtre G.Clear(Me.BackColor) ‘ Affichage du carré Dim Pen As New Pen(Color.White, 3) Dim rect As New Rectangle(50, 50, 100, 100) G.DrawRectangle(Pen, rect) ‘ Remplissage du carré Dim brBrush = New SolidBrush(Color.Blue) G.FillRectangle(brBrush, rect) End Sub Private Sub TracerRond_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles TracerRond.Click TracerRond.Checked = True TracerCarré.Checked = False Rond.Visible = True Carré.Visible = False End Sub Private Sub TracerCarré_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles TracerCarré.Click TracerRond.Checked = False TracerCarré.Checked = True Rond.Visible = False Carré.Visible = True End Sub Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load ‘Définition de l’objet graphique G = Me.CreateGraphics() End Sub Private Sub RondRouge_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles RondRouge.Click TracerRondRouge() End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 6
Implémenter des menus
199
Private Sub RondBleu_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles RondBleu.Click TracerRondBleu() End Sub Private Sub CarréRouge_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles CarréRouge.Click TracerCarréRouge() End Sub Private Sub CarréBleu_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles CarréBleu.Click TracerCarréBleu() End Sub Private Sub QuitterApplication_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles QuitterApplication.Click End End Sub Private Sub ContextRouge_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles ContextRouge.Click If (TracerRond.Checked = True) Then TracerRondRouge() Else TracerCarréRouge() End Sub Private Sub ContextBleu_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles ContextBleu.Click If (TracerRond.Checked = True) Then TracerRondBleu() Else TracerCarréBleu() End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
7 Barres d’outils et barres d’état Ce chapitre présente une application de dessin bitmap qui implémente une barre d’outils et une barre d’état. La barre d’outils donne accès à quatre fonctions qui permettent de dessiner à main levée, de tracer des segments de droites, des rectangles et des ellipses. La barre d’état indique en permanence l’outil actif (voir Figure 7.1). Figure 7.1 L’application de dessin, en mode Exécution.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
202
Visual Basic 2010
Cette application utilise : ∑ un contrôle ToolStrip pour implémenter la barre d’outils ; ∑ un contrôle StatusStrip pour implémenter la barre d’état ; ∑ un contrôle ImageList pour stocker les images qui doivent s’afficher dans la barre d’outils.
Le contrôle ImageList Avant d’implanter la barre d’outils dans l’application, vous devez créer les icônes qui doivent y être affichées et les stocker dans un contrôle ImageList. Utilisez une application graphique quelconque (Paint, Paint Shop Pro, PhotoShop, etc.) pour créer les icônes ou pour les capturer dans une autre application. Sauvegardez ces icônes au format BMP, GIF, JPG, PNG, ICO, EMF ou WMF. Créez un nouveau projet avec la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. L’entrée Visual Basic/Windows étant sélectionnée dans le volet gauche, choisissez le modèle Application Windows Forms, nommez le projet OutilsEtat et validez en cliquant sur OK. Insérez un contrôle ImageList sur la feuille du projet. Ce contrôle apparaît en dessous de la feuille. Cliquez dessus puis cliquez sur la propriété Images pour faire apparaître un bouton contenant trois points de suspension. Cliquez sur ce bouton. Ajoutez les quatre images du dossier OutilsEtat à l’aide du bouton Ajouter. La boîte de dialogue Éditeur de collections Images doit maintenant se présenter comme montré à la Figure 7.2. Figure 7.2 Les quatre images ont été insérées dans la collection.
Fermez la boîte de dialogue Éditeur de collections Images en cliquant sur OK. Les icônes sont maintenant prêtes à être insérées dans la barre d’outils.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 7
Barres d’outils et barres d’état
203
Mise en place de la barre d’outils Insérez un contrôle ToolStrip dans la feuille de l’application. Ce contrôle apparaît automatiquement sous la forme d’une bande horizontale dans la partie supérieure de la feuille. Cliquez sur l’icône affichée dans la partie gauche de la barre d’outils et sélectionnez Button (voir Figure 7.3). Figure 7.3 Création d’une nouvelle icône dans la barre d’outils.
Procédez de même pour ajouter trois nouvelles icônes dans la barre d’outils. La feuille de l’application doit maintenant ressembler à la Figure 7.4. Figure 7.4 Quatre icônes ont été insérées dans la barre d’outils.
Vous allez affecter les images i1.gif à i4.gif du dossier OutilsEtat à ces quatre icônes. Cliquez sur la première icône, puis sur la propriété Image dans la fenêtre des propriétés. Un bouton contenant trois points de suspension s’affiche en face de la propriété Image. Cliquez sur ce bouton. Une boîte de dialogue intitulée Sélectionner une ressource apparaît (voir Figure 7.5).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
204
Visual Basic 2010
Figure 7.5 Cette boîte de dialogue permet d’affecter une image aux icônes de la barre d’outils.
Cliquez sur le bouton Importer dans le groupe d’options Contexte de la ressource et désignez le fichier i1.gif du dossier OutilsEtat. Validez en cliquant sur le bouton OK, puis à nouveau sur le bouton OK pour fermer la boîte de dialogue Sélectionner une ressource.
Info
Les icônes peuvent également être incluses dans un fichier de ressources attaché à l’application. Pour cela, il suffit de sélectionner l’option Fichier de ressources du projet et de désigner l’icône en cliquant sur le bouton Importer.
Recommencez la manipulation qui vient d’être décrite pour affecter les images i2.gif, i3.gif et i4.gif aux trois autres icônes de la barre d’outils. Une fois fait, la feuille de l’application doit ressembler à la Figure 7.6. Figure 7.6 Les quatre icônes de la barre d’outils ont l’apparence souhaitée.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 7
Info
Barres d’outils et barres d’état
205
L’arrière-plan des images i1.gif à i4.gif a été défini comme couleur de transparence. C’est la raison pour laquelle ces images s’intègrent parfaitement dans la couleur d’arrière-plan de la barre d’outils.
Pour terminer la définition de la barre d’outils, modifiez la propriété Text des quatre icônes : Icône
Propriété Text
1
Crayon
2
Trait
3
Rectangle
4
Ellipse
Mise en place de la barre d‘état Insérez un contrôle StatusStrip dans la feuille de l’application. Ce contrôle s’affiche automatiquement sous la forme d’une bande horizontale dans la partie inférieure de la feuille. Cliquez sur le contrôle StatusStrip dans la feuille de l’application. Une icône apparaît dans la partie gauche du contrôle. Cliquez dessus et sélectionnez StatusLabel dans le menu (voir Figure 7.7). Figure 7.7 Insertion d’un contrôle texte dans la barre d’état.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
206
Visual Basic 2010
Insérez le texte Sélectionnez un outil dans la propriété Text du contrôle ToolStrip StatusLabel1 qui vient d’être créé. Tous les contrôles ont été placés dans la feuille de l’application. Vous allez maintenant mettre en place les procédures événementielles qui donneront vie à l’application.
Écriture du code Définissez les variables qui seront utilisées dans le programme en tête de code : Dim Dim Dim Dim Dim Dim
G As Graphics AncX, AncY As Single OutilEnCours As Integer pen As New pen(Color.Black) br = New SolidBrush(Color.Red) Tracé As Boolean
Double-cliquez sur une partie libre de la feuille et complétez la procédure Form1_Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load G = Me.CreateGraphics() Tracé = False End Sub
La première instruction instancie l’objet Graphics G. La deuxième instruction initialise à False la variable Tracé, qui sera utilisée par la suite pour activer (True) ou désactiver (False) le tracé. Double-cliquez sur la barre d’outils et complétez la procédure ToolStrip1_ItemClicked() comme suit : Private Sub ToolStrip1_ItemClicked(ByVal sender As System.Object, ByVal e As „ System.Windows.Forms.ToolStripItemClickedEventArgs) Handles ToolStrip1. „ ItemClicked Select Case e.ClickedItem.Text Case "Crayon" ToolStripStatusLabel1.Text = "Outil Crayon actif" OutilEnCours = 0 Case "Trait" ToolStripStatusLabel1.Text = "Outil Trait actif" OutilEnCours = 1 Case "Rectangle"
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 7
Barres d’outils et barres d’état
207
ToolStripStatusLabel1.Text = "Outil Rectangle actif" OutilEnCours = 2 Case "Ellipse" ToolStripStatusLabel1.Text = "Outil Ellipse actif" OutilEnCours = 3 End Select End Sub
La propriété e.ClickedItem.Text de l’objet e renvoie la valeur Text de l’icône cliquée. En utilisant une structure Select Case portant sur cette propriété, il est donc très simple d’effectuer les tâches correspondant à l’activation de chaque outil. Ces tâches consistent en l’affichage d’un message dans la barre d’état et en la mémorisation du bouton sur lequel on a appuyé dans la variable OutilEnCours. Pour compléter le programme, vous allez maintenant définir le code correspondant aux événements souris MouseDown, MouseMove et MouseUp. Définissez la procédure Form1_MouseDown() comme suit : Private Sub Form1_MouseDown(ByVal sender As Object, ByVal e _ As System.Windows.Forms.MouseEventArgs) Handles _ MyBase.MouseDown Tracé = True AncX = e.X AncY = e.Y End Sub
Cette procédure est activée chaque fois qu’un bouton de la souris est enfoncé. Elle initialise la variable Tracé à True pour valider l’utilisation de l’outil Crayon : Tracé = True
Elle initialise également les variables AncX et AncY avec la position actuelle de la souris : AncX = e.X AncY = e.Y
Définissez la procédure Form1_MouseMove() comme suit : Private Sub Form1_MouseMove(ByVal sender As Object, ByVal e _ As System.Windows.Forms.MouseEventArgs) Handles _ MyBase.MouseMove If (OutilEnCours = 0) And (Tracé = True) Then G.DrawLine(pen, AncX, AncY, e.X, e.Y) AncX = e.X AncY = e.Y End If End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
208
Visual Basic 2010
Cette procédure est active à chaque déplacement de la souris. Elle n’est utilisée que lorsque l’outil Crayon est actif, et uniquement si le tracé est autorisé : If (OutilEnCours = 0) And (Tracé = True) Then
Dans ce cas, une ligne droite est tracée entre le point dont les coordonnées sont mémorisées dans les variables AncX et AncY et la position courante de la souris : G.DrawLine(pen, AncX, AncY, e.X, e.Y)
Les coordonnées courantes de la souris sont alors mémorisées dans les variables AncX et AncY : AncX = e.X AncY = e.Y
Définissez enfin la procédure Form1_MouseUp() comme suit : Private Sub Form1_MouseUp(ByVal sender As Object, ByVal e _ As System.Windows.Forms.MouseEventArgs) Handles _ MyBase.MouseUp Tracé = False Select Case OutilEnCours Case 1 G.DrawLine(pen, AncX, AncY, e.X, e.Y) Case 2 G.DrawRectangle(pen, AncX, AncY, e.X - AncX, e.Y - AncY) G.FillRectangle(br, AncX, AncY, e.X - AncX, e.Y - AncY) Case 3 G.DrawEllipse(pen, AncX, AncY, e.X - AncX, e.Y - AncY) G.FillEllipse(br, AncX, AncY, e.X - AncX, e.Y - AncY) End Select End Sub
Lors du relâchement de la souris, la variable Tracé est initialisée à False pour interdire tout tracé avec le crayon. Les opérations à effectuer si un autre outil est sélectionné sont définies à l’aide d’une instruction Select Case :
∑
Si l’outil Trait est sélectionné, un trait de couleur noire (Dim pen As New pen(Color. Black)) est tracé entre les anciennes coordonnées et les coordonnées actuelles : Case 1 G.DrawLine(pen, AncX, AncY, e.X, e.Y)
∑
Si l’outil Rectangle est sélectionné, un rectangle noir est tracé (DrawRectangle) et rempli (FillRectangle) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 7
Barres d’outils et barres d’état
209
Case 2 G.DrawRectangle(pen, AncX, AncY, e.X - AncX, e.Y - AncY) G.FillRectangle(br, AncX, AncY, e.X - AncX, e.Y - AncY)
∑
Enfin, si l’outil Ellipse est sélectionné, une ellipse noire est tracée (DrawEllipse) et remplie (FillEllipse) : Case 3 G.DrawEllipse(pen, AncX, AncY, e.X - AncX, e.Y - AncY) G.FillEllipse(br, AncX, AncY, e.X - AncX, e.Y - AncY)
L’application se trouve dans le dossier OutilsEtat après installation des sources de l’ouvrage. Voici son listing complet.
Public Class Form1 Dim G As Graphics Dim AncX, AncY As Single Dim OutilEnCours As Integer Dim pen As New Pen(Color.Black) Dim br = New SolidBrush(Color.Red) Dim Tracé As Boolean Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load G = Me.CreateGraphics() Tracé = False End Sub Private Sub ToolStrip1_ItemClicked(ByVal sender As System.Object, ByVal e „ As System.Windows.Forms.ToolStripItemClickedEventArgs) Handles ToolStrip1. „ ItemClicked Select Case e.ClickedItem.Text Case "Crayon" ToolStripStatusLabel1.Text = "Outil Crayon actif" OutilEnCours = 0 Case "Trait" ToolStripStatusLabel1.Text = "Outil Trait actif" OutilEnCours = 1 Case "Rectangle" ToolStripStatusLabel1.Text = "Outil Rectangle actif" OutilEnCours = 2
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
210
Visual Basic 2010
Case "Ellipse" ToolStripStatusLabel1.Text = "Outil Ellipse actif" OutilEnCours = 3 End Select End Sub Private Sub Form1_MouseDown(ByVal sender As Object, ByVal e _ As System.Windows.Forms.MouseEventArgs) Handles _ MyBase.MouseDown Tracé = True AncX = e.X AncY = e.Y End Sub Private Sub Form1_MouseMove(ByVal sender As Object, ByVal e _ As System.Windows.Forms.MouseEventArgs) Handles _ MyBase.MouseMove If (OutilEnCours = 0) And (Tracé = True) Then G.DrawLine(pen, AncX, AncY, e.X, e.Y) AncX = e.X AncY = e.Y End If End Sub Private Sub Form1_MouseUp(ByVal sender As Object, ByVal e _ As System.Windows.Forms.MouseEventArgs) Handles _ MyBase.MouseUp Tracé = False Select Case OutilEnCours Case 1 G.DrawLine(pen, AncX, AncY, e.X, e.Y) Case 2 G.DrawRectangle(pen, AncX, AncY, e.X - AncX, e.Y - AncY) G.FillRectangle(br, AncX, AncY, e.X - AncX, e.Y - AncY) Case 3 G.DrawEllipse(pen, AncX, AncY, e.X - AncX, e.Y - AncY) G.FillEllipse(br, AncX, AncY, e.X - AncX, e.Y - AncY) End Select End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 7
Barres d’outils et barres d’état
211
Plus loin avec les contrôles ToolStrip Le contrôle ToolStrip a été introduit dans le .NET Framework 2.0. Dans la section précédente, nous l’avons utilisé pour mettre en place une barre d’outils conventionnelle. Lorsque vous avez défini les quatre icônes de la barre d’outils, vous vous êtes peut-être demandé à quoi pouvaient bien servir les différents éléments proposés dans le menu déroulant (voir Figure 7.8). Figure 7.8 Les boutons ne sont pas les seuls éléments pouvant être insérés dans un menu ToolStrip.
Vous le voyez à la Figure 7.8, les éléments de base pouvant être insérés dans un menu sont les suivants :
∑ ∑ ∑ ∑ ∑ ∑ ∑
Icône. ToolStripButton ; Texte. ToolStripLabel ; Liste déroulante. ToolStripSplitButton et ToolStripDropDownButton ; Séparateur. ToolStripSeparator ; Liste modifiable. ToolStripComboBox ; Zone de texte. ToolStripTextBox ; Barre de progression. ToolStripProgressBar.
L’implémentation de ces contrôles ne représente aucune difficulté majeure :
∑
Le texte affiché dans le contrôle Label doit être placé dans la propriété Text du contrôle ToolStripLabel.
∑
Les éléments contenus dans les contrôles ToolStripSplitButton et ToolStrip DropDownButton peuvent être insérés dans la feuille de l’application, après avoir cliqué sur le contrôle correspondant et développé sa propriété DropDownItems (voir Figure 7.9).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
212
Visual Basic 2010
Figure 7.9 Les ToolStrip(Split/ DropDown)Button peuvent contenir un ou plusieurs MenuItem, ComboBox, Separator et TextBox.
∑
Les éléments des contrôles ComboBox sont définis lors de l’édition (propriété Items) ou dans le code [procédure ToolStripCombobox1.Items.Add()].
∑
Le texte affiché dans un contrôle TextBox peut être défini lors de la conception en utilisant la propriété Text. Il peut également être saisi par l’utilisateur. La valeur entrée au clavier se trouve dans cette même propriété Text.
∑
La propriété Value d’un contrôle ProgressBar définit (et permet de connaître) la taille de la barre de progression.
∑
Pour accéder à la procédure événementielle associée à un contrôle inséré dans un Tool Strip, il suffit de double-cliquer sur ce contrôle.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
8 Manipulation d’objets graphiques Ce chapitre est dédié à la manipulation d’objets graphiques par l’intermédiaire des méthodes de l’API GDI+ (Graphical Device Interface). La première section présente les principales méthodes de cette API. Vous saurez ainsi afficher des points, tracer des droites et des courbes, choisir une couleur de tracé ou de remplissage, utiliser un stylet et une brosse. La deuxième section montre comment réaliser un économiseur d’écran. Celui-ci entrera automatiquement en action au bout d’un délai paramétrable de non-activité du clavier et de la souris. La troisième section explique comment afficher une horloge du plus bel effet. Vous apprendrez à faire bouger ses aiguilles en transformant l’heure système en coordonnées dans le plan. Enfin, la quatrième section montre comment effectuer une copie d’écran partielle ou totale. L’image récupérée apparaîtra dans un contrôle PictureBox et pourra être stockée sur le disque dur dans un fichier BMP.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
214
Visual Basic 2010
Le système d’affichage graphique GDI+ L’affichage graphique dans une feuille Visual Basic 2010 repose sur la bibliothèque de fonctions GDI+ (Graphical Device Interface +). Grâce à cette bibliothèque, la programmation graphique est indépendante de la configuration matérielle de l’ordinateur. L’élément principal de GDI+ est la classe Graphics qui fournit des méthodes permettant de tracer très simplement des primitives graphiques (points, droites, polygones, ellipses, etc.). Un objet Graphics peut représenter une image ou la surface d’un contrôle. Avant de pouvoir dessiner, vous devez définir un tel objet et l’instancier. Par exemple, pour dessiner sur un formulaire, servez-vous du code suivant : Dim g as Graphics = Me.CreateGraphics
et de celui-ci pour dessiner sur un contrôle Panel : Dim g as Graphics = panel1.CreateGraphics
Cette première étape franchie, vous pouvez dessiner sur l’objet g en utilisant les méthodes du tableau ci-après. Méthode
Effet
DrawArc
Trace un arc d’ellipse.
DrawCurve
Trace une courbe qui passe par les points spécifiés en argument.
DrawEllipse
Trace une ellipse.
DrawIcon
Affiche une icône.
DrawImage
Affiche une image.
DrawLine
Trace un trait.
DrawPie
Trace un camembert.
DrawPolygon
Trace un polygone.
DrawRectangle
Trace un rectangle.
DrawString
Affiche un texte.
Certaines de ces méthodes nécessitent la création d’objets annexes, tels que le point, le rectangle, la couleur, le stylet, la brosse, la couleur et/ou la police. Voyons comment définir et instancier ces objets.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
215
Point Pour définir un point, il suffit d’invoquer l’une des procédures Point() ou PointF() en spécifiant ses coordonnées : Dim p As New Point(X, Y)
où X et Y sont des valeurs entières qui représentent l’abscisse et l’ordonnée du point ; Dim p As New PointF(X, Y)
où X et Y sont des valeurs Single qui représentent l’abscisse et l’ordonnée du point.
Rectangle Pour définir un rectangle, il suffit d’invoquer l’une des procédures Rectangle() ou RectangleF() en indiquant les coordonnées de deux de ses côtés opposés : Dim r as New Rectangle(X1, Y1, X2, Y2)
où X1 et Y1 sont des valeurs entières qui représentent l’abscisse et l’ordonnée d’un des angles du rectangle, et X2 et Y2 des valeurs entières qui représentent l’abscisse et l’ordonnée de l’angle opposé ; Dim r as New RectangleF(X1, Y1, X2, Y2)
où X1 et Y1 sont des valeurs Single qui représentent l’abscisse et l’ordonnée d’un des angles du rectangle, et X2 et Y2 des valeurs Single qui représentent l’abscisse et l’ordonnée de l’angle opposé.
Couleur La couleur d’un objet peut être choisie parmi un grand nombre de couleurs prédéfinies : AliceBlue, AntiqueWhite, Aqua, AquaMarine, Azure, Beige, Bisque, Black, BlanchetAlmond, Blue, BlueViolet, Brown, BurlyWood, CadetBlue, Chartreuse, Chocolate, Coral, ComflowerBlue, Cornsilk, Crimson, Cyan, DarkBlue, DarkCyan, DarkGoldenrod, DarkGray, DarkGreen, DarkKhaki, DarkMagenta, DarkOliveGreen, DarkOrange, DarkOrchid, DarkRed, DarkSalmon, etc. Pour accéder à l’une de ces couleurs, il suffit d’utiliser la fonction Intellisense de Visual Studio (voir Figure 8.1).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
216
Visual Basic 2010
Figure 8.1 Il est très simple d’accéder aux couleurs prédéfinies.
Stylet Le stylet est utilisé pour dessiner des lignes, des arcs, des rectangles et des secteurs. Vous le définirez en utilisant une des trois instructions suivantes : Dim nom As New Pen(couleur) Dim nom As New Pen(couleur, épaisseur) Dim nom As New Pen(brosse, épaisseur)
où :
∑ ∑ ∑ ∑
nom est le nom du stylet ; couleur est la couleur du stylet ; épaisseur est l’épaisseur du trait, en pixels ; brosse est la brosse à utiliser.
Pour visualiser toutes les couleurs prédéfinies, nous allons créer une petite application. Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom CouleursPredefinies à l’application et validez en cliquant sur OK. Modifiez les propriétés de l’objet Form1 comme indiqué dans le tableau ci-après. Propriété
Valeur
FormBorderStyle
FixedDialog
Text
Liste alphabétique des couleurs prédéfinies de l’objet Color
BackColor
Window
Size.Width
640
Size.Height
480
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
217
Lancez la commande Concepteur du menu Affichage. Cliquez sur l’icône Événements dans la fenêtre des Propriétés et double-cliquez sur l’événement Paint. Complétez la procédure Form1_Paint() comme suit : Private Sub Form1_Paint(ByVal sender As System.Object, ByVal e As System.Windows. „ Forms.PaintEventArgs) Handles MyBase.Paint ‘Définition du Type Color Dim colorType As Type = System.Drawing.Color.AliceBlue.GetType ‘Obtention des propriétés du type Color dans un tableau Dim Couleurs() As System.Reflection.PropertyInfo = colorType.GetProperties Dim Couleur As System.Reflection.PropertyInfo Dim Col As Integer = 0 Dim Lig As Integer = 0 ‘Parcours des couleurs For Each Couleur In Couleurs Try ‘Affichage d’un rectangle rempli Dim rect As New Rectangle(Col * 125 + 15, Lig * 13 + 5, 10, 10) e.Graphics.FillRectangle(New SolidBrush(CType(Couleur.GetValue „ (colorType, Nothing), Color)), rect) e.Graphics.DrawRectangle(Pens.Black, rect) ‘Affichage du nom de la couleur Couleur e.Graphics.DrawString(Couleur.Name, Me.Font, Brushes.Black, rect. „ Left + rect.Width + 5, rect.Top) ‘Incrémentation des index de ligne et de colonne Lig = Lig + 1 If Lig >= 34 Then Lig = 0 Col = Col + 1 End If Catch ex As Exception End Try Next End Sub
Pour définir un objet représentant le type Color, il suffit d’interroger la fonction GetType sur un membre quelconque du type Color, par exemple AliceBlue : Dim colorType As Type = System.Drawing.Color.AliceBlue.GetType
L’objet colorType va nous permettre d’obtenir la liste des membres du type Color en interrogeant la fonction GetProperties : Dim Couleurs() As System.Reflection.PropertyInfo = colorType.GetProperties
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
218
Visual Basic 2010
Pour parcourir cette liste, il faut définir un objet de type System.Reflection.PropertyInfo : Dim Couleur As System.Reflection.PropertyInfo
Après avoir défini et initialisé deux variables qui indiquent la colonne et la ligne d’affichage de chacune des couleurs prédéfinies : Dim Col As Integer = 0 Dim Lig As Integer = 0
une boucle For Each parcourt les différentes couleurs du type Color : For Each Couleur In Couleurs
Un bloc Try Catch End Try réalise l’affichage : Try ... Catch ex As Exception End Try
Dans un premier temps, l’objet Rectangle rect est défini et instancié à un emplacement calculé par l’intermédiaire des variables Col et Lig : Dim rect As New Rectangle(Col * 125 + 15, Lig * 13 + 5, 10, 10)
Il s’affiche ensuite à l’aide de la procédure FillRectangle() : e.Graphics.FillRectangle(New SolidBrush(CType(Couleur.GetValue(colorType, „ Nothing), Color)), rect)
puis détouré en noir à l’aide de la procédure DrawRectangle() : e.Graphics.DrawRectangle(Pens.Black, rect)
L’instruction suivante affiche le nom de la couleur (Couleur.Name) à droite du rectangle coloré : e.Graphics.DrawString(Couleur.Name, Me.Font, Brushes.Black, rect.Left + rect. „ Width + 5, rect.Top)
Le parcours des couleurs se termine par l’incrémentation des index de ligne et de colonne. Après plusieurs essais, il est apparu qu’une fenêtre de 640 × 480 points pouvait contenir 34 lignes en utilisant la police et la taille de caractères par défaut. Il convient donc de changer de colonne quand ce nombre est atteint : Lig = Lig If Lig >= Lig = Col = End If
+ 1 34 Then 0 Col + 1
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
219
Vous pouvez exécuter cette mini-application en appuyant sur la touche de fonction F5. Une fenêtre analogue à celle montrée à la Figure 8.2 apparaît. Figure 8.2 Voici toutes les couleurs prédéfinies de l’objet Color.
Cette application se trouve dans le dossier Projects\CouleursPredefinies des sources de l’ouvrage.
Brosse La brosse est utilisée pour remplir des surfaces délimitées par un contour fermé. Le remplissage peut se faire avec :
∑
une couleur unie : Dim brosse = New SolidBrush(Couleur)
où Couleur est la couleur de remplissage, par exemple Color.AliceBlue ou Color. DarkSalmon ;
∑
un gradient (dégradé) de couleurs : Dim brosse= New LinearGradientBrush(Rectangle,Couleur1, Couleur2, Type)
où Rectangle est la zone de répétition du gradient, Couleur1 la couleur de départ du gradient, Couleur2 la couleur d’arrivée du gradient et Type le type du gradient (Horizontal ou Vertical par exemple) ;
∑
une image bitmap : Dim brosse = New TextureBrush(Image)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
220
Visual Basic 2010
où Image est l’image bitmap à utiliser ;
∑
des hachures : Dim brosse = new HatchBrush(Style, Couleur)
où Style est le style des hachures (DiagonalCross, DottedGrid ou Horizontal par exemple) et Couleur la couleur des hachures (Color.Red ou Color.Blue par exemple). Pour illustrer de façon pratique la mise en œuvre des brosses, vous allez écrire une petite application. Lancez la commande Nouveau Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom Brosse à l’application et validez. L’onglet Form1.vb (Design) étant sélectionné, cliquez sur l’icône Événements dans la fenêtre des propriétés et double-cliquez sur l’événement Paint. Il ne vous reste plus qu’à compléter la procédure Form1_Paint() comme suit : Private Sub Form1_Paint(ByVal sender As System.Object, ByVal e As System.Windows. „ Forms.PaintEventArgs) Handles MyBase.Paint ‘Affichage d’un rectangle plein Dim brosse1 = New SolidBrush(Color.Red) Dim rect1 As New Rectangle(10, 10, 190, 50) e.Graphics.FillRectangle(brosse1, rect1) e.Graphics.DrawRectangle(Pens.Black, rect1) ‘Affichage d’un rectangle avec un gradient grisé vertical Dim rect2 As New Rectangle(10, 70, 50, 50) Dim brosse2 = New System.Drawing.Drawing2D.LinearGradientBrush(rect2, Color. „ White, Color.Black, Drawing2D.LinearGradientMode.Vertical) e.Graphics.FillRectangle(brosse2, rect2) e.Graphics.DrawRectangle(Pens.Black, rect2) ‘Affichage d’un rectangle avec un gradient de couleurs horizontal Dim rect2b As New Rectangle(80, 70, 50, 50) Dim brosse2b = New System.Drawing.Drawing2D.LinearGradientBrush(rect2, „ Color.Red, Color.Blue, Drawing2D.LinearGradientMode.Horizontal) e.Graphics.FillRectangle(brosse2b, rect2b) e.Graphics.DrawRectangle(Pens.Black, rect2b) ‘Affichage d’un rectangle avec un gradient de couleurs en diagonale Dim rect2c As New Rectangle(150, 70, 50, 50) Dim brosse2c = New System.Drawing.Drawing2D.LinearGradientBrush(rect2, „ Color.Yellow, Color.Green, Drawing2D.LinearGradientMode.ForwardDiagonal)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
221
e.Graphics.FillRectangle(brosse2c, rect2c) e.Graphics.DrawRectangle(Pens.Black, rect2c) ‘Affichage d’un rectangle avec une image Dim rect3 As New Rectangle(10, 130, 190, 50) Dim brosse3 = New TextureBrush(My.Resources.colorwir) e.Graphics.FillRectangle(brosse3, rect3) e.Graphics.DrawRectangle(Pens.Black, rect3) ‘Affichage d’un rectangle hachuré verticalement Dim rect4 As New Rectangle(10, 190, 50, 50) Dim brosse4 = New System.Drawing.Drawing2D.HatchBrush(Drawing2D.HatchStyle. „ DarkVertical, Color.Azure) e.Graphics.FillRectangle(brosse4, rect4) e.Graphics.DrawRectangle(Pens.Black, rect4) ‘Affichage d’un rectangle hachuré horizontalement Dim rect5 As New Rectangle(80, 190, 50, 50) Dim brosse5 = New System.Drawing.Drawing2D.HatchBrush(Drawing2D.HatchStyle. „ DarkHorizontal, Color.Azure) e.Graphics.FillRectangle(brosse5, rect5) e.Graphics.DrawRectangle(Pens.Black, rect5) ‘Affichage d’un rectangle hachuré en diagonale Dim rect6 As New Rectangle(150, 190, 50, 50) Dim brosse6 = New System.Drawing.Drawing2D.HatchBrush(Drawing2D.HatchStyle. „ DiagonalCross, Color.Azure) e.Graphics.FillRectangle(brosse6, rect6) e.Graphics.DrawRectangle(Pens.Black, rect6) End Sub
Cette procédure est élémentaire. Elle consiste en plusieurs blocs d’instructions chargés d’afficher un rectangle rempli avec une couleur unie, une image, un gradient de couleurs ou des hachures. À titre d’exemple, examinons le bloc chargé de l’affichage d’un rectangle hachuré verticalement : Dim rect4 As New Rectangle(10, 190, 50, 50) Dim brosse4 = New System.Drawing.Drawing2D.HatchBrush(Drawing2D.HatchStyle. „ DarkVertical, Color.Azure) e.Graphics.FillRectangle(brosse4, rect4) e.Graphics.DrawRectangle(Pens.Black, rect4)
La première instruction définit le rectangle à tracer : Dim rect4 As New Rectangle(10, 190, 50, 50)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
222
Visual Basic 2010
La deuxième instruction définit la brosse à utiliser : Dim brosse4 = New System.Drawing.Drawing2D.HatchBrush(Drawing2D.HatchStyle.DarkVertical, Color.Azure)
La troisième instruction trace le rectangle défini dans la première instruction en utilisant la brosse définie dans la deuxième instruction : e.Graphics.FillRectangle(brosse4, rect4)
Enfin, la quatrième instruction détoure ce rectangle en utilisant un pinceau noir : e.Graphics.DrawRectangle(Pens.Black, rect4)
Pour simplifier, vous pouvez éviter l’écriture des préfixes System.Drawing. Drawing2D (dans la définition de l’objet) et Drawing2D (dans le premier argument). Il suffit pour cela d’insérer une clause Imports System.Drawing. Drawing2D juste avant la ligne Public Class Form1.
Info
Une fois le code saisi, appuyez sur la touche de fonction F5 pour exécuter l’application. Vous devriez obtenir une fenêtre proche de celle montrée à la Figure 8.3. Figure 8.3 Le programme Brosse, en mode Exécution.
Cette application se trouve dans le dossier Projects\Brosse des sources de l’ouvrage.
Police Les objets Font sont utilisés pour définir des textes destinés à être affichés dans des objets Graphic. Pour définir un objet Font, vous utilisez la syntaxe suivante : Dim f = New Font("Nom", Taille)
où Nom est le nom de la police à utiliser et Taille la taille (Single) des caractères, en points.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
223
Cette syntaxe admet de nombreuses surcharges. Vous pouvez en particulier préciser le style du texte : Dim f = New Font("Nom", Taille, Style)
où Nom est le nom de la police à utiliser, Taille la taille (Single) des caractères, en points, et Style le style du texte (FontStyle.Bold, FontStyle.Italic, FontStyle.Regular, FontStyle.Strikeout ou FontStyle.Underline). Pour de plus amples informations sur la manipulation des polices de caractères, reportezvous au Chapitre 5.
Mise en place d’un économiseur d’écran Lorsqu’une même image reste affichée pendant plusieurs heures à l’écran, les particules élémentaires responsables de l’affichage ont tendance à mémoriser l’information. Il en résulte une trace indélébile qui se superpose aux éléments affichés. Pour éviter ce désagrément, il suffit d’utiliser un économiseur d’écran. Son principe est simple : au bout d’une durée paramétrable de non-utilisation du clavier et de la souris, l’économiseur d’écran s’active. Il affiche une image en mouvement, de façon que les pixels changent souvent de couleur. L’affichage normal redémarre dès que le clavier ou la souris sont actionnés. Toutes les versions de Windows sont livrées avec plusieurs économiseurs d’écran. Ceux-ci étant peu paramétrables, nous allons envisager la création d’un écran de veille en Visual Basic. Vous pourrez ensuite le personnaliser à loisir. À titre d’exemple, nous allons voir comment tracer sur l’écran des droites de longueur et de couleur aléatoires tous les 1/100 seconde au bout d’un temps paramétrable.
Mise en place visuelle de l’application Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom EconomEcran à la nouvelle application. Ajoutez un contrôle Timer sur la feuille de ce projet et modifiez les propriétés de la feuille comme suit : Objet
Propriété
Valeur
Form1
BackColor
Window
Form1
FormBorderStyle
None
Form1
WindowState
Maximised
Timer1
Enabled
True
Timer1
Interval
10
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
224
Visual Basic 2010
La feuille de l’application doit maintenant ressembler à la Figure 8.4. Figure 8.4 La feuille de l’application, en mode Conception.
Définition des procédures de traitement Dans un premier temps, nous allons définir les objets utilisés par le programme : Public Class Form1 Dim g As Graphics Dim X1, Y1, X2, Y2 As Integer Dim depart As Long
L’objet g donnera accès au système d’affichage graphique. Les variables X1, Y1, X2 et Y2 permettront de calculer les coordonnées des droites aléatoires tracées sur l’écran. Enfin, la variable depart permettra de mémoriser le "top départ" depuis le lancement du programme ou le dernier mouvement de la souris. Pour faciliter la définition des couleurs de tracé aléatoires, nous allons déterminer la fonction Aleatoire() comme suit : Private Aleatoire As Random = New Random(DateTime.Now.Millisecond)
Double-cliquez sur la feuille et complétez la procédure Form1_Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load g = Me.CreateGraphics()
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
225
depart = My.Computer.Clock.TickCount Cursor.Hide() End Sub
La première instruction initialise l’objet graphique g : g = Me.CreateGraphics()
La deuxième instruction mémorise le nombre de millisecondes écoulées depuis le démarrage de l’ordinateur dans la variable depart : depart = My.Computer.Clock.TickCount
Enfin, la troisième instruction masque le pointeur de la souris : Cursor.Hide()
Basculez sur l’onglet Form1.vb (Design) dans Visual Studio. Cliquez sur l’icône Timer1, en dessous de la feuille de l’application. Affichez les événements liés au contrôle Timer1 dans la fenêtre des propriétés et double-cliquez sur la case située à droite de l’événement Tick. Cette action crée l’ossature de la procédure Timer1_Tick(), activée toutes les Interval secondes (ici 10/1 000, soit 1/100 seconde). Complétez la procédure Timer1_Tick() comme suit : Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System. EventArgs) Handles Timer1.Tick If (My.Computer.Clock.TickCount - depart) > 5000 Then Dim p As New Pen(Color.FromArgb(255, Aleatoire.Next(0, 255), Aleatoire. „ Next(0, 255), Aleatoire.Next(0, 255))) X1 = Aleatoire.Next(1, Me.Width) X2 = Aleatoire.Next(1, Me.Width) Y1 = Aleatoire.Next(1, Me.Height) Y2 = Aleatoire.Next(1, Me.Height) g.DrawLine(p, X1, Y1, X2, Y2) End If End Sub
La première ligne teste s’il s’est écoulé plus de 5 secondes depuis le démarrage de l’application : If (My.Computer.Clock.TickCount - depart) > 5000 Then
La fonction My.Computer.Clock.TickCount() renvoie le nombre de millisecondes écoulées depuis le démarrage de l’ordinateur. Il suffit d’y soustraire la valeur stockée dans la variable depart pour connaître le temps écoulé depuis le démarrage de l’application. Si ce temps est supérieur à 5 000 millisecondes (5 s), l’économiseur d’écran se met en action1. 1. Cette temporisation est extrêmement courte. Vous la repousserez à 10, 20 ou 30 min (respectivement 60 000, 120 000 ou 180 000) pour une utilisation plus conventionnelle.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
226
Visual Basic 2010
La couleur du Crayon est choisie aléatoirement à l’aide de la fonction FromArgb() à laquelle on fournit trois arguments aléatoires : FromArgb(255, Aleatoire.Next(0, 255), Aleatoire.Next(0, 255), Aleatoire.Next(0, 255))
La valeur obtenue permet de choisir une couleur aléatoire. Cette couleur est passée en argument de la fonction Pen afin de construire un nouvel objet Pen p : Dim p As New Pen(Color.FromArgb(255, Aleatoire.Next(0, 255), Aleatoire.Next(0, 255), Aleatoire.Next(0, 255)))
Il ne reste plus qu’à tirer aléatoirement les coordonnées de début et de fin de la droite que l’on souhaite tracer : X1 X2 Y1 Y2
= = = =
Aleatoire.Next(1, Aleatoire.Next(1, Aleatoire.Next(1, Aleatoire.Next(1,
Me.Width) Me.Width) Me.Height) Me.Height)
puis à communiquer ces cinq paramètres à la procédure DrawLine() : g.DrawLine(p, X1, Y1, X2, Y2)
Vous pouvez dès à présent tester cette application en appuyant sur la touche de fonction F5. Au bout de 5 s, et tous les 1/100 secondes, une nouvelle droite de longueur et de couleur aléatoires s’affiche sur l’écran. Nous allons ajouter quelques fonctions à cet économiseur d’écran. Basculez sur l’onglet Form1.vb (Design) dans Visual Studio. Cliquez sur la feuille de l’application. Affichez les événements liés au contrôle Form1 dans la fenêtre des propriétés en cliquant sur l’icône Événements, puis double-cliquez sur la case située à droite de l’événement MouseMove. Cette action crée l’ossature de la procédure Form1_MouseMove(). Complétez cette procédure comme suit : Private Sub Form1_MouseMove(ByVal sender As Object, ByVal e As System.Windows. „ Forms.MouseEventArgs) Handles Me.MouseMove depart = My.Computer.Clock.TickCount g.Clear(Color.White) End Sub
La première instruction initialise la variable depart avec le nombre de millisecondes écoulées depuis le démarrage de l’ordinateur. L’affichage des droites aléatoires sera donc stoppé pendant 5 s : depart = My.Computer.Clock.TickCount
La deuxième instruction efface le contenu de l’écran : g.Clear(Color.White)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
227
Chaque fois que vous déplacerez la souris, le décompte avant activation de l’économiseur d’écran sera donc réinitialisé et l’écran sera effacé. Basculez sur l’onglet Form1.vb (Design) dans Visual Studio. Cliquez sur la feuille de l’application. Affichez les événements liés au contrôle Form1 dans la fenêtre des propriétés en cliquant sur l’icône Événements, puis double-cliquez sur la case située à droite de l’événement KeyDown. Cette action crée l’ossature de la procédure Form1_KeyDown(). Complétez cette procédure comme suit : Private Sub Form1_KeyDown(ByVal sender As System.Object, ByVal e As System.Windows. „ Forms.KeyEventArgs) Handles MyBase.KeyDown End End Sub
Pour quitter l’application, il vous suffira donc d’appuyer sur une touche quelconque du clavier.
Exécution de l’application Vous pouvez lancer le programme en appuyant sur la touche de fonction F5 et tester son bon fonctionnement. Vérifiez en particulier les points suivants :
∑ ∑ ∑
Le tracé des droites débute au bout de 5 s. Tout mouvement de la souris réinitialise le décompte avant le tracé des droites. L’appui sur une touche du clavier met fin au programme.
Ce projet se trouve dans le dossier Projects\EconomEcran des sources de l’ouvrage. Voici son listing complet : Public Class Form1 Dim g As Graphics Dim X1, Y1, X2, Y2 As Integer Dim depart As Long Private Aleatoire As Random = New Random(DateTime.Now.Millisecond)
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load g = Me.CreateGraphics() depart = My.Computer.Clock.TickCount Cursor.Hide() End Sub Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Timer1.Tick
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
228
Visual Basic 2010
If (My.Computer.Clock.TickCount - depart) > 5000 Then Dim p As New Pen(Color.FromArgb(255, Aleatoire.Next(0, 255), „ Aleatoire.Next(0, 255), Aleatoire.Next(0, 255))) X1 = Aleatoire.Next(1, Me.Width) X2 = Aleatoire.Next(1, Me.Width) Y1 = Aleatoire.Next(1, Me.Height) Y2 = Aleatoire.Next(1, Me.Height) g.DrawLine(p, X1, Y1, X2, Y2) End If End Sub Private Sub Form1_MouseMove(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles Me.MouseMove depart = My.Computer.Clock.TickCount g.Clear(Color.White) End Sub Private Sub Form1_KeyDown(ByVal sender As System.Object, ByVal e As System. Windows.Forms.KeyEventArgs) Handles MyBase.KeyDown End End Sub End Class
Cet économiseur d’écran est certes très basique, mais toutes les fonctions nécessaires à la mise en œuvre d’une application plus évoluée ont été passées en revue. À vos claviers…
Affichage d’une horloge à aiguilles Cette section montre comment réaliser une horloge à aiguilles calée sur l’horloge système de l’ordinateur (voir Figure 8.5). Figure 8.5 L’application Horloge, en mode Exécution.
Cette application requiert un contrôle Image et un contrôle Timer. La barre de titre se limite au titre de l’application et à la case de fermeture. Toutes les minutes, l’heure système est lue et la position des aiguilles de l’horloge est mise à jour.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
229
Les commandes accessibles à l’utilisateur sont très limitées : la fenêtre de l’application peut être déplacée à l’aide de la technique habituelle et fermée d’un clic sur la case de fermeture.
Avant de commencer Le contrôle Timer permet d’exécuter une ou plusieurs instructions à intervalles réguliers. Il n’est jamais visible en mode Exécution, mais sa présence est obligatoire dans la feuille si vous voulez exécuter un code à intervalles réguliers. La durée de l’intervalle est choisie à l’aide de la propriété Interval ou de l’instruction Timer1.Interval = période. Dans cet exemple, le timer a pour nom Timer1 et la valeur période définit la période d’activation de la procédure Timer1_Tick() en millisecondes. Si nécessaire, vous pouvez placer plusieurs timers sur une feuille. Dans ce cas, Visual Basic leur donnera les noms Timer2, Timer3, etc. Pour définir la période du Timer3, vous utiliserez sa propriété Interval ou l’instruction Timer3.Interval = période. La procédure Timer3_Tick() sera exécutée répétitivement en respectant un intervalle période entre chaque exécution. Sachez enfin que la propriété Enabled règle l’état (actif ou en veille) d’un contrôle Timer. La valeur True rend le contrôle actif, et la valeur False le plonge dans un profond sommeil.
Mise en place visuelle de l’application Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom HorlogeAiguilles au projet et validez. Insérez un contrôle Timer dans l’application. Pour éviter de devoir faire référence à une image externe au programme, nous allons l’inclure dans les ressources de l’application. Lancez la commande Propriétés de HorlogeAiguilles dans le menu Projet. Cette commande affiche l’onglet HorlogeAiguilles dans l’EDI. Cliquez sur l’onglet Ressources. Lancez la commande Ajouter un fichier existant dans le menu Ajouter une ressource et désignez le fichier horloge.bmp (ce fichier se trouve dans le dossier Projects\HorlogeAiguilles des sources de l’ouvrage). La partie centrale de l’environnement de développement doit à présent ressembler à la Figure 8.6. Affectez la valeur Horloge à la propriété Text du contrôle Form1 pour afficher le mot Horloge dans sa barre de titre. Affectez la valeur FixedToolWindow à la propriété FormBorderStyle du contrôle Form1 de façon à réduire la barre de titre de l’application à une simple case de fermeture de dimensions réduites. La feuille de l’application doit maintenant ressembler à la Figure 8.7.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
230
Visual Basic 2010
Figure 8.6 Le fichier horloge.bmp a été ajouté aux ressources de l’application.
Figure 8.7 La feuille de l’application propose une barre de titre réduite.
Pour que l’horloge puisse fonctionner, vous devez paramétrer le contrôle Timer. Affectez les valeurs :
∑ ∑
True à la propriété Enabled pour activer le contrôle. 60 000 à la propriété Interval pour demander l’exécution de la procédure de traitement
du timer toutes les 60 000 millisecondes (en d’autres termes… toutes les minutes). Cette procédure effectuera la mise à jour des aiguilles sur l’horloge.
Il est temps de donner vie à l’horloge en écrivant quelques lignes de code.
Définition des procédures de traitement Affichez la fenêtre de code en sélectionnant l’onglet Form1.vb et définissez la constante pi à la suite de la déclaration Public : Public Class Form1 Const pi = 3.1415926536
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
231
Cette constante sera utilisée pour effectuer des calculs trigonométriques sur la position des aiguilles. Complétez cette définition en déclarant les variables nécessaires au programme : Dim Dim Dim Dim
x, y As Integer g As Graphics p As New Pen(Color.Black, 1) mybmp As New Bitmap(My.Resources.horloge)
Les entiers x et y serviront à calculer les coordonnées des aiguilles. L’objet Graphics g permettra d’afficher l’horloge et les aiguilles dans la feuille. L’objet Pen p sera utilisé pour définir la couleur (Color.Black) et l’"épaisseur" (1) des aiguilles de l’horloge. Enfin, l’objet Bitmap mybmp permettra de manipuler l’image horloge, placée dans les ressources de l’application dans la section précédente. Vous allez maintenant définir la procédure qui affichera les aiguilles sur l’horloge. Entrez les instructions suivantes : Sub Affiche() ‘Effacement des aiguilles g.DrawImage(mybmp, 1, 1) ‘Lecture de l’heure système et mémorisation dans les variables Heures et Minutes Dim h As Integer = System.DateTime.Now.Hour Dim m As Integer = System.DateTime.Now.Minute ‘Affichage des heures x = Math.Round(Math.Sin(2 * pi * (h Mod 12) / 12) * 9) y = Math.Round(Math.Cos(2 * pi * (h Mod 12) / 12) * 9) g.DrawLine(p, 28, 28, 28 + x, 28 - y) ‘Affichage des minutes x = Math.Round(Math.Sin(2 * pi * m / 60) * 12) y = Math.Round(Math.Cos(2 * pi * m / 60) * 12) g.DrawLine(p, 28, 28, 28 + x, 28 - y) End Sub
La première instruction affiche à nouveau l’image de l’horloge. C’est un moyen très pratique pour effacer les aiguilles de leur position précédente : g.DrawImage(mybmp, 1, 1)
Le bloc d’instructions suivant lit l’heure système (heures et minutes) à l’aide de la fonction System.DateTime.Now : Dim h As Integer = System.DateTime.Now.Hour Dim m As Integer = System.DateTime.Now.Minute
Les instructions suivantes affichent les aiguilles sur l’horloge.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
232
Visual Basic 2010
ition Défin
Quelques rappels de trigonométrie. Pour afficher les aiguilles sur l’horloge, nous utiliserons les fonctions trigonométriques Cos (cosinus) et Sin (sinus). Le cosinus nous permettra de connaître la projection sur l’axe horizontal (abscisse), et le sinus, la projection sur l’axe vertical (ordonnée).
La variable h a été initialisée par la fonction System.DateTime.Now.Hour. Elle contient la valeur horaire de l’heure système, entre 0 et 23. Pour connaître ses projections sur les axes X et Y, il suffit d’utiliser les fonctions Cos(2*pi*h) et Sin(2*pi*h). Remarquez l’utilisation de l’opérateur Mod pour limiter les valeurs horaires à l’intervalle [0.. 12]. Remarquez aussi le facteur multiplicatif (ici 9) qui détermine la taille de l’aiguille : x = Math.Round(Math.Sin(2 * pi * (h Mod 12) / 12) * 9) y = Math.Round(Math.Cos(2 * pi * (h Mod 12) / 12) * 9)
Pour afficher l’aiguille des heures, nous utilisons l’instruction GDI+ DrawLine. Ses arguments sont les suivants :
∑ ∑ ∑
la couleur du tracé (p) ; le point de départ du tracé (28, 28) ; le point de fin du tracé (28 + x, 28 – y). g.DrawLine(p, 28, 28, 28 + x, 28 - y)
La même technique permet de calculer les coordonnées de l’aiguille des minutes : x = Math.Round(Math.Sin(2 * pi * m / 60) * 12) y = Math.Round(Math.Cos(2 * pi * m / 60) * 12)
puis de l’afficher sur l’image : g.DrawLine(p, 28, 28, 28 + x, 28 - y)
La procédure Affiche doit être appelée au lancement de l’application, puis toutes les minutes. Pour cela, vous allez définir et compléter les procédures Form1_Paint() et Timer1_Tick(). Sélectionnez l’objet Form1 dans la boîte de dialogue des Propriétés, cliquez sur l’icône Événements, puis double-cliquez sur l’événement Paint pour générer le squelette de la procédure Form1_Paint(). Complétez cette procédure comme suit : Private Sub Form1_Paint(ByVal sender As System.Object, ByVal e As System.Windows. „ Forms.PaintEventArgs) Handles MyBase.Paint g = Me.CreateGraphics() Affiche() End Sub
La première instruction initialise l’objet Graphics g et la seconde appelle la procédure Affiche() pour afficher l’heure système.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
233
Double-cliquez maintenant sur le contrôle Timer et complétez la procédure Timer1_Tick() comme suit : Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Timer1.Tick Affiche() End Sub
Difficile de faire plus simple ! Toutes les minutes, cette procédure est activée. Elle appelle la procédure Affiche(), responsable de l’affichage des aiguilles sur l’horloge. Pour terminer, vous allez définir la procédure Form1_Load() afin de redimensionner la fenêtre de l’application. Sélectionnez l’objet Form1 dans la boîte de dialogue des Propriétés, cliquez sur l’icône Événements, puis double-cliquez sur l’événement Load pour générer le squelette de la procédure Form1_Load(). Complétez cette procédure comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load Me.Width = 64 Me.Height = 82 End Sub
Exécution de l’application Le programme peut être exécuté : appuyez sur la touche de fonction F5. Si nécessaire, vous pouvez repositionner la fenêtre en la faisant glisser à un endroit quelconque de l’écran. Avouez que cette "horloge maison" est plus agréable qu’une simple horloge numérique... Voici le listing complet du programme : Public Class Form1 Const pi = 3.1415926536 Dim x, y As Integer Dim g As Graphics Dim p As New Pen(Color.Black, 1) Dim mybmp As New Bitmap(My.Resources.horloge) Sub Affiche() ‘Effacement des aiguilles g.DrawImage(mybmp, 1, 1) ‘Lecture de l’heure système et mémorisation dans les variables Heures et „ Minutes Dim h As Integer = System.DateTime.Now.Hour Dim m As Integer = System.DateTime.Now.Minute
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
234
Visual Basic 2010
‘Affichage des heures x = Math.Round(Math.Sin(2 * pi * (h Mod 12) / 12) * 9) y = Math.Round(Math.Cos(2 * pi * (h Mod 12) / 12) * 9) g.DrawLine(p, 28, 28, 28 + x, 28 - y) ‘Affichage des minutes x = Math.Round(Math.Sin(2 * pi * m / 60) * 12) y = Math.Round(Math.Cos(2 * pi * m / 60) * 12) g.DrawLine(p, 28, 28, 28 + x, 28 - y) End Sub Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Timer1.Tick Affiche() End Sub Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load Me.Width = 64 Me.Height = 82 End Sub Private Sub Form1_Paint(ByVal sender As System.Object, ByVal e As System. Windows.Forms.PaintEventArgs) Handles MyBase.Paint g = Me.CreateGraphics() Affiche() End Sub End Class
Ce projet se trouve dans le dossier Projects\HorlogeAiguilles des sources de l’ouvrage.
La capture d’écran programmée Cette section vous montre comment effectuer une copie d’écran partielle ou totale en utilisant une petite application Visual Basic 2010. L’image récupérée apparaît dans un contrôle PictureBox et peut être stockée sur le disque dur dans un fichier BMP.
Définition de l’application Créez une nouvelle application. Ajoutez deux contrôles Button, deux contrôles RadioButton, quatre contrôles Label, quatre contrôles TextBox et un contrôle PictureBox à la feuille. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau ci-après :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
Contrôle
Propriété
Valeur
Form1
Text
Capture d’écran
Button1
Text
Capture
Button2
Text
Sauvegarde disque
RadioButton1
Text
Tout l’écran
RadioButton1
Checked
True
RadioButton2
Text
Personnalisé
Label1
Text
X début
Label2
Text
Y début
Label3
Text
Largeur
Label4
Text
Hauteur
TextBox1
Text
0
TextBox2
Text
0
TextBox3
Text
TextBox4
Text
PictureBox1
Dock
235
Bottom
Modifiez la taille et la disposition des contrôles pour obtenir une feuille semblable à la Figure 8.8. Figure 8.8 La feuille de l’application Capture d’écran, en mode Édition.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
236
Visual Basic 2010
Voici le code associé à l’application. Ce projet se trouve dans le dossier Projects\Copie Ecran des sources de l’ouvrage. Public Class Form1 Private Declare Function BitBlt Lib "gdi32.dll" (ByVal hdcDest As IntPtr, ByVal nXDest As Integer, _ ByVal nYDest As Integer, _ ByVal nWidth As Integer, _ ByVal nHeight As Integer, _ ByVal hdcSrc As IntPtr, _ ByVal nXSrc As Integer, _ ByVal nYSrc As Integer, _ ByVal dwRop As System.Int32) As Boolean Private Declare Function GetDesktopWindow Lib "user32" () As IntPtr Dim Image Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click ‘Définition des variables qui délimitent la zone à capturer Dim xDeb, xFin, yDeb, yFin As Integer ‘Création d’un objet Graphics qui pointe sur l’écran Dim g1 As Graphics = Graphics.FromHwnd(GetDesktopWindow) If RadioButton1.Checked Then xDeb = 0 yDeb = 0 xFin = My.Computer.Screen.WorkingArea.Width yFin = My.Computer.Screen.WorkingArea.Height Else xDeb = Val(TextBox1.Text) yDeb = Val(TextBox2.Text) xFin = Val(TextBox3.Text) yFin = Val(TextBox4.Text) End If ‘Création d’un bitmap de même taille que la zone à capturer Image = New Bitmap(xFin - xDeb + 1, yFin - yDeb + 1, g1) Dim g2 As Graphics = Graphics.FromImage(Image) ‘ Création du contexte de périphérique (Device Context) de la fiche Dim dc1 As IntPtr = g1.GetHdc ‘ Création du contexte de périphérique (Device Context) de l’image bitmap Dim dc2 As IntPtr = g2.GetHdc
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
237
‘Copie d’écran (Bit Blast) dans l’image bitmap BitBlt(dc2, 0, 0, xFin - xDeb + 1, yFin - yDeb + 1, dc1, xDeb, yDeb, 13369376) ‘ Affichage de la capture PictureBox1.Image = Image ‘Libération des contextes de périphériques g1.ReleaseHdc(dc1) g2.ReleaseHdc(dc2) End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click ‘Sauvegarde de la copie d’écran sur le disque dur Image.Save("c:\data\image.bmp") End Sub End Class
Le premier bloc de code définit le gabarit de la fonction BitBlt() et l’interface avec la bibliothèque gdi32.dll : Private Declare Function BitBlt Lib "gdi32.dll" ( … ) As Boolean
Cette fonction copie la totalité ou une partie de l’écran dans un conteneur image. Examinons les arguments transmis à cette fonction : Argument
Définition
hdcDest
Objet Graphics où l’image doit être copiée
nXDest
Abscisse du coin supérieur gauche où l’image sera copiée
nYDest
Ordonnée du coin supérieur gauche où l’image sera copiée
nWidth
Largeur de l’image
nHeight
Hauteur de l’image
hdcSrc
Objet Graphics d’où l’image doit être copiée
nXSrc
Abscisse du coin supérieur gauche de l’image source
nYSrc
Ordonnée du coin supérieur gauche de l’image source
dwRop
Méthode utilisée pour copier l’image
L’argument dwRop indique la méthode de copie de l’image. Vous pouvez utiliser une des constantes du tableau suivant :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
238
Visual Basic 2010
Constante
Valeur
Définition
SRCAND
&H8800C6
Combine la source et la destination à l’aide de l’opérateur AND.
SRCCOPY
&HCC0020
Copie de l’image source dans l’image de destination.
SRCERASE
&H440328
Applique un opérateur AND entre la source et l’inverse de la destination.
SRCINVERT
&H660046
Combinaison source/destination à l’aide de l’opérateur XOR.
SRCPAINT
&HEE0086
Combinaison source/destination à l’aide de l’opérateur OR.
NOTSRCCOPY
&H330008
Inverse la source et la copie dans la destination.
NOTSRCERASE
&H1100A6
Combinaison source/destination à l’aide de l’opérateur OR puis inverse le résultat.
MERGEPAINT
&HBB0226
Applique un opérateur OR entre l’inverse de la source et la estination. d
DSTINVERT
&H550009
Inverse la destination (sans tenir compte de la source).
BLACKNESS
&H42
Affecte la couleur noire à la destination.
WHITENESS
&HFF0062
Affecte la couleur blanche à la destination.
Le code se poursuit par la déclaration de la fonction GetDesktopWindow() : Private Declare Function GetDesktopWindow Lib "user32" () As IntPtr
Cette fonction fait partie de la bibliothèque user32.dll. Nous l’utiliserons pour obtenir le handle du Bureau de Windows. Les déclarations se terminent par la définition de la variable Image qui contiendra la capture d’écran : Dim Image
Double-cliquez sur le bouton Capture et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click ‘Définition des variables qui délimitent la zone à capturer Dim xDeb, xFin, yDeb, yFin As Integer ‘Création d’un objet Graphics qui pointe sur l’écran Dim g1 As Graphics = Graphics.FromHwnd(GetDesktopWindow) If RadioButton1.Checked Then xDeb = 0
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 8
Manipulation d’objets graphiques
239
yDeb = 0 xFin = My.Computer.Screen.WorkingArea.Width yFin = My.Computer.Screen.WorkingArea.Height Else xDeb yDeb xFin yFin End If
= = = =
Val(TextBox1.Text) Val(TextBox2.Text) Val(TextBox3.Text) Val(TextBox4.Text)
‘Création d’un bitmap de même taille que la zone à capturer Image = New Bitmap(xFin - xDeb + 1, yFin - yDeb + 1, g1) Dim g2 As Graphics = Graphics.FromImage(Image) ‘ Création du contexte de périphérique (Device Context) de la fiche Dim dc1 As IntPtr = g1.GetHdc ‘ Création du contexte de périphérique (Device Context) de l’image bitmap Dim dc2 As IntPtr = g2.GetHdc ‘Copie d’écran (Bit Blast) dans l’image bitmap BitBlt(dc2, 0, 0, xFin - xDeb + 1, yFin - yDeb + 1, dc1, xDeb, yDeb, &HCC0020) ‘ Affichage de la capture PictureBox1.Image = Image ‘Libération des contextes de périphériques g1.ReleaseHdc(dc1) g2.ReleaseHdc(dc2) End Sub
La procédure débute par la définition des variables qui contiendront les coordonnées de la zone à capturer : Dim xDeb, xFin, yDeb, yFin As Integer
La fonction GetDesktopWindow() est alors sollicitée pour obtenir le handle du Bureau de Windows. L’objet graphique associé est stocké dans l’objet Graphics g1 : Dim g1 As Graphics = Graphics.FromHwnd(GetDesktopWindow)
Si l’utilisateur sélectionne le premier bouton radio, cela signifie qu’il souhaite réaliser une copie de la totalité de l’écran. Les variables xDeb, yDeb, xFin et yFin sont initialisées en conséquence : If RadioButton1.Checked Then xDeb = 0 yDeb = 0 xFin = My.Computer.Screen.WorkingArea.Width yFin = My.Computer.Screen.WorkingArea.Height
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
240
Visual Basic 2010
Dans le cas contraire, la zone à capturer est lue dans les contrôles TextBox1 à TextBox4 : Else xDeb yDeb xFin yFin End If
= = = =
Val(TextBox1.Text) Val(TextBox2.Text) Val(TextBox3.Text) Val(TextBox4.Text)
L’instruction suivante crée une image bitmap de mêmes dimensions que la zone de capture : Image = New Bitmap(xFin - xDeb + 1, yFin - yDeb + 1, g1)
L’objet Graphics g2 est alors initialisé avec cette image : Dim g2 As Graphics = Graphics.FromImage(Image)
Pour pouvoir appeler la fonction BitBlt, les contextes de périphériques des objets g1 et g2 sont obtenus par la fonction GetHdc() et stockés dans les variables InPtr dc1 et dc2 : Dim dc1 As IntPtr = g1.GetHdc Dim dc2 As IntPtr = g2.GetHdc
La copie d’écran peut alors être effectuée : BitBlt(dc2, 0, 0, xFin - xDeb + 1, yFin - yDeb + 1, dc1, xDeb, yDeb, &HCC0020)
Après l’exécution de cette instruction, l’image source est placée dans l’objet Bitmap Image (contexte de périphérique dc2 de l’objet Graphics g2). Pour l’afficher dans la fenêtre de l’application, il suffit d’affecter le contrôle Image à la propriété Image du contrôle PictureBox1 : PictureBox1.Image = Image
Pour terminer, les contextes de périphériques créés dans les lignes précédentes sont libérés : g1.ReleaseHdc(dc1) g2.ReleaseHdc(dc2)
Double-cliquez sur le bouton Sauvegarde disque et complétez la procédure Button2_ Click() comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button2.Click ‘Sauvegarde de la copie d’écran sur le disque dur Image.Save("c:\data\image.bmp") End Sub
L’unique instruction de cette procédure sauvegarde le contenu de l’objet Image dans le fichier C:\data\image.bmp : Image.Save("c:\data\image.bmp")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
9 Fichiers et dossiers Visual Basic manipule trois types de fichiers :
∑
Les fichiers à accès séquentiel. Ils ne contiennent que du texte. Lors de leur ouverture, vous devez préciser le mode d’accès : en lecture (input), en écriture (output) ou en ajout (append).
∑
Les fichiers à accès direct. Ils sont constitués d’un ou de plusieurs enregistrements de longueur fixe. Ils sont simultanément accessibles en lecture et en écriture.
∑
Les fichiers binaires. Tous les fichiers qui n’entrent pas dans les deux précédentes catégories peuvent être ouverts comme fichiers binaires. Ils sont simultanément accessibles en lecture et en écriture.
Nous allons examiner le fonctionnement des fichiers séquentiels et des fichiers à accès direct. Les fichiers binaires sont très proches des fichiers à accès direct, si ce n’est qu’ils manipulent des données de longueur quelconque. Dans un second temps, nous vous montrerons comment copier, déplacer et supprimer des fichiers et des dossiers.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
242
Visual Basic 2010
Fichiers à accès séquentiel Les fonctions et procédures dédiées à la manipulation des fichiers texte sont les suivantes : FileOpen(), FileClose(), InputString(), LineInput() et Print(). La procédure FileOpen() est généralement utilisée avec trois arguments : FileOpen(identificateur, nom, mode)
où :
∑ ∑ ∑
identificateur est un numéro associé au fichier. nom est le nom du fichier à ouvrir. mode est le mode d’ouverture, Append, Binary, Input, Output ou Random.
La procédure FileClose() ne demande qu’un argument, le numéro du fichier qui doit être fermé : FileClose(identificateur)
La fonction InputString() demande deux arguments : Resultat = InputString(identificateur, longueur)
où :
∑ ∑
identificateur est un numéro associé au fichier. longueur correspond au nombre de caractères à lire dans le fichier.
La fonction Input() ne demande qu’un seul argument, le numéro du fichier dans lequel la ligne doit être lue : Resultat = InputString(identificateur)
La procédure Print() demande deux arguments : Print(identificateur,valeur)
où :
∑ ∑
identificateur est un numéro associé au fichier. valeur correspond à la valeur à écrire dans le fichier.
Pour vous montrer comment utiliser ces instructions, nous allons réaliser un miniprojet permettant d’afficher et de mémoriser des notes textuelles. Définissez un nouveau projet de type Application Windows Forms avec la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 9
Fichiers et dossiers
243
Windows Forms dans le volet central. Donnez le nom Mémo au projet et validez en cliquant sur OK. Ajoutez un contrôle TextBox et deux contrôles Button à la feuille du projet. Modifiez les propriétés de ces contrôles comme suit : Contrôle
Propriété
Valeur
TextBox1
Text
TextBox1
Multiline
True
TextBox1
(Name)
Mémo
Button1
Text
Effacer
Button2
Text
Quitter
Double-cliquez sur un emplacement inoccupé de la feuille et complétez la procédure Form1_Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load tout = "" Try FileOpen(1, "c:\memo.txt", OpenMode.Input) While Not EOF(1) texte = LineInput(1) tout = tout + texte + Chr(13) + Chr(10) End While Mémo.Text = tout Catch Finally FileClose(1) End Try End Sub
Complétez cette procédure en définissant les variables tout et texte : Dim tout as String Dim texte as String
La procédure Form_Load est essentiellement composée d’une instruction Try Catch Finally. L’instruction Try est utilisée pour ouvrir le fichier c:\memo.txt en lecture. Si ce fichier n’existe pas, une erreur est générée et les instructions situées sous l’instruction Catch sont exécutées. Ici, aucune action n’est effectuée en cas d’erreur. Si le fichier c:\memo.txt existe
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
244
Visual Basic 2010
(c’est le cas s’il ne s’agit pas de la première exécution du programme), son contenu est lu ligne par ligne à l’aide d’une boucle While : While Not EOF(1) texte = LineInput(1)
Après chaque lecture, un passage à la ligne est ajouté à la ligne en mémoire : tout = tout + texte + Chr(13) + Chr(10) End While
Lorsque tout le fichier a été lu, le contrôle Mémo est initialisé en conséquence : Mémo.Text = tout
Puis le fichier est fermé à l’aide du bloc Finally : Finally FileClose(1)
Définissez les variables texte utilisées dans cette procédure en ajoutant la ligne ci-après en tête de listing : Dim tout, texte As String
Pour terminer le projet, il reste encore à donner vie aux deux boutons de commande. Le bouton Effacer est d’une grande simplicité. Il se contente d’effacer le texte affiché dans le contrôle Mémo. Double-cliquez sur le bouton Effacer et complétez la procédure Button1_ Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click Mémo.Text = "" End Sub
Le code affecté au bouton Quitter est légèrement plus complexe qu’à l’habitude. En effet, il est nécessaire de sauvegarder le texte du contrôle Mémo dans le fichier c:\memo.txt. Double-cliquez sur le bouton Quitter et complétez la procédure Button2_Click() comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button2.Click Try FileOpen(1, "c:\memo.txt", OpenMode.Output) Print(1, Mémo.Text) Catch Finally
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 9
Fichiers et dossiers
245
FileClose(1) End Try End End Sub
Ici encore, nous utiliserons une instruction Try Catch Finally pour accéder au fichier texte. Le code inscrit sous l’instruction Try tente d’ouvrir le fichier c:\memo.txt en écriture et d’y stocker le contenu du contrôle Mémo : Try FileOpen(1, "c:\memo.txt", OpenMode.Output) Print(1, Mémo.Text)
Comme le bloc Catch est laissé vide, aucune action ne se produira si le fichier c:\memo. txt ne peut être ouvert en écriture. Comme dans la procédure Form1_Load(), le fichier est clôturé à l’aide du bloc Finally : Finally FileClose(1)
Voici le code complet de l’application. Ce code se trouve dans le dossier Mémo après installation des sources de l’ouvrage. Public Class Form1 Dim tout, texte As String Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs)Handles MyBase.Load tout = "" Try FileOpen(1, "c:\memo.txt", OpenMode.Input) While Not EOF(1) texte = LineInput(1) tout = tout + texte + Chr(13) + Chr(10) End While Mémo.Text = tout Catch Finally FileClose(1) End Try End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
246
Visual Basic 2010
EventArgs) Handles Button2.Click Try FileOpen(1, "c:\memo.txt", OpenMode.Output) Print(1, Mémo.Text) Catch Finally FileClose(1) End Try End End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click Mémo.Text = "" End Sub End Class
Fichiers à accès direct Les fichiers à accès direct contiennent des données organisées dans des enregistrements de longueur fixe. Par exemple, dans un carnet d’adresses, la déclaration d’un enregistrement peut se faire avec l’instruction Public Structure ci-après : Public Structure Struct Dim Nom As String Dim Prénom As String Dim Adresse As String Dim Téléphone As String Dim Fax As String End Structure
Struct est le nom de la structure d’enregistrement à utiliser. Dans cet exemple, cette structure est composée de cinq champs de chaîne de longueur déterminée : Nom, Prénom, Adresse, Téléphone et Fax.
Pour utiliser la structure Enreg, il suffira de définir une variable de ce type avec l’instruction suivante : Dim Enreg As Struct
Enreg est une variable de type Struct. Pour accéder à une des variables de ce type, il faudra utiliser une instruction à point. Par exemple, Enreg.Fax représente la donnée Fax de
l’enregistrement.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 9
Fichiers et dossiers
247
Pour ouvrir un fichier à accès direct, vous utiliserez une instruction FileOpen() en indiquant la longueur de chaque enregistrement. Par exemple : FileOpen(1, "C:\carnet.adr", OpenMode.Random, , , 295)
Cette instruction suppose que la longueur d’un enregistrement est de 295 octets. Pour lire un enregistrement dans un fichier à accès direct, vous utiliserez l’instruction FileGet(). À titre d’exemple, l’instruction suivante lit le premier enregistrement du fichier : FileGet(1, Enreg, 1)
Les données lues peuvent être utilisées avec des instructions à point, comme Enreg.Nom ou encore Enreg.Adresse. Enfin, pour écrire un enregistrement dans un fichier à accès direct, vous utiliserez l’instruction FilePut(), selon la même syntaxe que pour l’instruction FileGet(). Bien entendu, vous devez avoir initialisé les variables de l’enregistrement avant d’utiliser l’instruction FilePut(). Nous allons illustrer l’utilisation des fichiers à accès direct en créant un carnet d’adresses élémentaire. Ce carnet pourra être consulté et complété. Définissez un nouveau projet de type Application Windows Forms avec la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Donnez le nom Carnet au projet et validez en cliquant sur OK. Ajoutez cinq contrôles TextBox, cinq Label et cinq contrôles Button à la feuille du projet. Modifiez les propriétés de ces contrôles comme suit : Contrôle
Propriété
Valeur
Label1
Text
Nom
Label2
Text
Prénom
Label3
Text
Adresse
Label4
Text
Téléphone
Label5
Text
Fax
TextBox1
Text
TextBox2
Text
TextBox3
Text
TextBox4
Text
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
248
Visual Basic 2010
Contrôle
Propriété
Valeur
TextBox5
Text
TextBox1
Name
Nom
TextBox2
Name
Prénom
TextBox3
Name
Adresse
TextBox4
Name
Téléphone
TextBox5
Name
Fax
TextBox3
MultiLine
True
Button1
Text
Quitter
Button2
Text
Button5
Text
>>
Form1
Text
Carnet d’adresses
Modifiez la position et la dimension des contrôles pour obtenir quelque chose comme à la Figure 9.1. Figure 9.1 La fenêtre de l’application Carnet d’adresses, en mode Édition.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 9
Fichiers et dossiers
249
Définissez la structure et les variables utilisées par le programme dans les premières lignes : Public Structure Struct Dim Nom As String Dim Prénom As String Dim Adresse As String Dim Téléphone As String Dim Fax As String End Structure Dim Enreg As Struct Dim Numéro As Integer
Le premier bloc d’instructions définit la structure des enregistrements du carnet d’adresses. La variable Enreg, de type Struct, sera utilisée pour lire et écrire dans le fichier à accès direct. Enfin, la variable Numéro sera utilisée pour pointer l’enregistrement auquel accéder, en lecture ou en écriture. Définissez maintenant les procédures Lit() et Ecrit(), qui seront utilisées par le programme pour lire et écrire un enregistrement dans le carnet d’adresses : Private Sub Lit(ByVal N As Integer) FileGet(1, Enreg, Numéro) Nom.Text = Enreg.Nom Prénom.Text = Enreg.Nom Adresse.Text = Enreg.Adresse Téléphone.Text = Enreg.Téléphone Fax.Text = Enreg.Fax End Sub Private Sub Ecrit(ByVal N As Integer) Enreg.Nom = Nom.Text Enreg.Nom = Prénom.Text Enreg.Adresse = Adresse.Text Enreg.Téléphone = Téléphone.Text Enreg.Fax = Fax.Text FilePut(1, Enreg, Numéro) End Sub
La procédure Lit() utilise l’instruction FileGet() pour lire l’enregistrement Numéro dans le fichier. Le résultat est stocké dans la variable Struct Enreg : FileGet(1, Enreg, Numéro)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
250
Visual Basic 2010
Les données lues apparaissent ensuite dans les zones de texte de la feuille : Nom.Text = Enreg.Nom Prénom.Text = Enreg.Nom Adresse.Text = Enreg.Adresse Téléphone.Text = Enreg.Téléphone Fax.Text = Enreg.Fax
La procédure Ecrit() effectue l’action inverse. Après avoir initialisé la variable Struct Enreg avec le contenu des zones de texte : Enreg.Nom = Nom.Text Enreg.Nom = Prénom.Text Enreg.Adresse = Adresse.Text Enreg.Téléphone = Téléphone.Text Enreg.Fax = Fax.Text
La variable Struct Enreg est sauvegardée dans le carnet d’adresses, à l’enregistrement Enreg : FilePut(1, Enreg, Numéro)
Double-cliquez sur un emplacement inoccupé de la feuille et complétez la procédure Form1_Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load Try FileOpen(1, "C:\carnet.adr", OpenMode.Random, , , 295) Numéro = 1 ‘Enregistrement en cours = 1 Lit(Numéro) Finally End Try End Sub
Au lancement de l’application, une instruction Try ouvre le fichier c:\carnet.adr en lecture/ écriture. Les enregistrements de ce fichier ont une longueur de 295 caractères, en accord avec la longueur de la structure Struct : Try FileOpen(1, "C:\carnet.adr", OpenMode.Random, , , 295)
L’enregistrement numéro 1 est alors lu et affiché dans la feuille : Numéro = 1 ‘Enregistrement en cours = 1 Lit(Numéro)
Pour terminer l’application, il ne reste plus qu’à associer du code aux cinq boutons de commande.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 9
Fichiers et dossiers
251
Double-cliquez sur le quatrième bouton (prochain enregistrement) et complétez la procédure Button4_Click() comme suit : Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button4.Click If Nom.Text "" Then Ecrit(Numéro) Numéro = Numéro + 1 Lit(Numéro) End Sub
Si le champ Nom n’est pas vide, l’enregistrement Numéro est écrit dans le carnet : If Nom.Text "" Then Ecrit(Numéro)
L’enregistrement suivant est alors lu et affiché : Numéro = Numéro + 1 Lit(Numéro)
Double-cliquez sur le troisième bouton de commande. La procédure permettant de visua liser l’enregistrement précédent est très proche de la précédente : Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button3.Click If Nom.Text "" Then Ecrit(Numéro) If Numéro > 1 Then Numéro = Numéro - 1 Lit(Numéro) End Sub
Si le champ Nom n’est pas vide, l’enregistrement Numéro est écrit dans le carnet : If Nom.Text "" Then Ecrit(Numéro)
S’il existe, l’enregistrement précédent est alors lu et affiché : If Numéro > 1 Then Numéro = Numéro - 1 Lit(Numéro)
Les procédures liées aux boutons premier et dernier enregistrement sont du même acabit. Double-cliquez sur le deuxième bouton et complétez la procédure Button2_Click() comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click If Nom.Text "" Then Ecrit(Numéro) Numéro = 1 Lit(Numéro) End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
252
Visual Basic 2010
Si l’enregistrement courant n’est pas vierge, il est mémorisé dans le carnet : If Nom.Text "" Then Ecrit(Numéro)
Puis le premier enregistrement de données apparaît : Numéro = 1 Lit(Numéro)
Double-cliquez sur le cinquième bouton et complétez la procédure Button5_Click() : Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button5.Click If Nom.Text "" Then Ecrit(Numéro) Numéro = FileLen("c:\carnet.adr") / 295 Lit(Numéro) End Sub
Si l’enregistrement courant n’est pas vierge, il est mémorisé dans le carnet : If Nom.Text "" Then Ecrit(Numéro)
Pour connaître le numéro du dernier enregistrement, il suffit de diviser la longueur du fichier par la taille d’un enregistrement : Numéro = FileLen("c:\carnet.adr") / 295
Cet enregistrement apparaît à l’aide de la procédure Lit() : Lit(Numéro)
Voici le listing complet de ce projet. Vous le trouverez dans le dossier Carnet après installation des sources de l’ouvrage. Public Class Form1 Public Structure Struct Dim Nom As String Dim Prénom As String Dim Adresse As String Dim Téléphone As String Dim Fax As String End Structure Dim Enreg As Struct Dim Numéro As Integer Private Sub Lit(ByVal N As Integer)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 9
Fichiers et dossiers
253
FileGet(1, Enreg, Numéro) Nom.Text = Enreg.Nom Prénom.Text = Enreg.Prénom Adresse.Text = Enreg.Adresse Téléphone.Text = Enreg.Téléphone Fax.Text = Enreg.Fax End Sub Private Sub Ecrit(ByVal N As Integer) Enreg.Nom = Nom.Text Enreg.Prénom = Prénom.Text Enreg.Adresse = Adresse.Text Enreg.Téléphone = Téléphone.Text Enreg.Fax = Fax.Text FilePut(1, Enreg, Numéro) End Sub Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load Try FileOpen(1, "C:\carnet.adr", OpenMode.Random, , , 295) Numéro = 1 ‘Enregistrement en cours = 1 Lit(Numéro) Finally End Try End Sub Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button4.Click If Nom.Text "" Then Ecrit(Numéro) Numéro = Numéro + 1 Lit(Numéro) End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button3.Click If Nom.Text "" Then Ecrit(Numéro) If Numéro > 1 Then Numéro = Numéro - 1 Lit(Numéro) End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
254
Visual Basic 2010
If Nom.Text "" Then Ecrit(Numéro) Numéro = 1 Lit(Numéro) End Sub Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button5.Click If Nom.Text "" Then Ecrit(Numéro) Numéro = FileLen("c:\carnet.adr") / 295 Lit(Numéro) End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click If Nom.Text "" Then Ecrit(Numéro) FileClose(1) End End Sub End Class
Manipulation de dossiers et de fichiers Les fonctions habituelles permettant de manipuler dossiers et fichiers sont disponibles dans Visual Basic 2010. Pour pouvoir les utiliser, il suffit de préciser la classe à laquelle elles appartiennent en début de listing : Imports System.IO
Le tableau suivant donne un aperçu des principales fonctions disponibles. Fonction
Effet
File.Copy (source, destination)
Copie le fichier source sur le fichier de destination
File.Delete (source)
Supprime le fichier spécifié
Directory.CreateDirectory (Chemin)
Crée le dossier spécifié
Directory.Delete (Chemin)
Supprime le dossier spécifié
Pour illustrer ces quatre fonctions, nous allons développer une application qui copie un fichier existant dans un nouveau dossier, puis qui supprime la copie et le dossier créés. Lancez la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. L’entrée Visual Basic/Windows étant sélectionnée
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 9
Fichiers et dossiers
255
dans la boîte de dialogue Nouveau projet, cliquez sur l’icône Application Windows Forms dans le volet central, donnez le nom Ouvrir au projet et cliquez sur OK. Insérez deux Label, deux TextBox et un Button dans la feuille. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant : Contrôle
Propriété
Valeur
Label1
Text
Fichier source
Label2
Text
Fichier de destination
TextBox1
Text
TextBox2
Text
TextBox1
Name
Source
TextBox2
Name
Destin
Button1
Text
Copier puis Effacer
Form1
Text
Copie de fichiers
Les procédures de manipulation de fichiers et de dossiers utilisent la classe System.IO. Vous devez donc indiquer la clause Imports suivante en début de programme : Imports System.IO
Double-cliquez sur le bouton de commande et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click Dim résultat As Boolean If Dir("c:\Nouveau dossier\" + Destin.Text) "" Then résultat = MsgBox("Le fichier destination " + Destin.Text + " existe. „ Voulez-vous l’écraser ?", MsgBoxStyle.OKCancel) If résultat = False Then Exit Sub End If End If Directory.CreateDirectory("c:\Nouveau dossier\") MsgBox("Le dossier ‘Nouveau dossier’ a été créé", MsgBoxStyle.Information) File.Copy(Source.Text, Destin.Text) MsgBox("Le fichier a été copié", MsgBoxStyle.Information)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
256
Visual Basic 2010
File.Delete(Destin.Text) MsgBox("Le fichier a été effacé", MsgBoxStyle.Information) Directory.Delete("c:\Nouveau dossier") MsgBox("Le dossier ‘Nouveau dossier’ a été supprimé", MsgBoxStyle.Information) End Sub
Le premier bloc d’instructions teste si le fichier spécifié dans la zone de texte Destination est déjà présent sur le disque. Si tel est le cas, une boîte de message s’affiche. Remarquez l’utilisation de la fonction Dir() pour tester l’existence d’un fichier : Dim résultat As Boolean If Dir("c:\Nouveau dossier\" + Destin.Text) "" Then résultat = MsgBox("Le fichier destination " + Destin.Text + " existe. „ Voulez-vous l’écraser ?", MsgBoxStyle.OKCancel)
Si l’utilisateur indique qu’il ne souhaite pas écraser le fichier existant, le programme prend fin : If résultat = False Then Exit Sub End If
Le bloc d’instructions suivant crée le dossier c:\Nouveau dossier à l’aide de la fonction CreateDirectory() et informe l’utilisateur que ce dossier a été créé : Directory.CreateDirectory("c:\Nouveau dossier\") MsgBox("Le dossier ‘Nouveau dossier’ a été créé", MsgBoxStyle.Information)
Le fichier spécifié est alors copié dans le dossier c:\Nouveau dossier. Lorsque la copie est terminée, une boîte de message en informe l’utilisateur : File.Copy(Source.Text, Destin.Text) MsgBox("Le fichier a été copié", MsgBoxStyle.Information)
Le fichier copié est ensuite supprimé à l’aide de la fonction File.Delete() : File.Delete(Destin.Text) MsgBox("Le fichier a été effacé", MsgBoxStyle.Information)
Et le dossier c:\Nouveau est supprimé : Directory.Delete("c:\Nouveau dossier") MsgBox("Le dossier ‘Nouveau dossier’ a été supprimé", MsgBoxStyle.Information)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 9
Fichiers et dossiers
257
Voici le listing complet du programme. Le projet correspondant se trouve dans le dossier Projects\CopieDeFichiers des sources de l’ouvrage après leur installation. Imports System.IO Public Class Form1 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click Dim résultat As Boolean If Dir("c:\Nouveau dossier\" + Destin.Text) "" Then résultat = MsgBox("Le fichier destination " + Destin.Text + " existe. „ Voulez-vous l’écraser ?", MsgBoxStyle.OKCancel) If résultat = False Then Exit Sub End If End If Directory.CreateDirectory("c:\Nouveau dossier\") MsgBox("Le dossier ‘Nouveau dossier’ a été créé", MsgBoxStyle.Information) File.Copy(Source.Text, Destin.Text) MsgBox("Le fichier a été copié", MsgBoxStyle.Information) File.Delete(Destin.Text) MsgBox("Le fichier a été effacé", MsgBoxStyle.Information) Directory.Delete("c:\Nouveau dossier") MsgBox("Le dossier ‘Nouveau dossier’ a été supprimé", MsgBoxStyle.Information) End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
10 Jouer des sons WAV Visual Basic 2010 est en mesure de jouer des fichiers audio WAV par l’intermédiaire d’une nouvelle méthode apparue dans la version 2.0 du Framework .NET : My.Computer.Audio. Play(). Ce chapitre va vous montrer comment l’utiliser.
Mise en place de l’application Nous allons réaliser un nouveau projet contenant :
∑ ∑
un contrôle Treeview pour sélectionner le fichier .WAV à jouer ; un contrôle Button pour jouer le son sélectionné.
La Figure 10.1 représente le projet en cours d’exécution.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
260
Visual Basic 2010
Figure 10.1 Un fichier .WAV est prêt à être joué.
Définissez un nouveau projet de type Application Windows Forms à l’aide de la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. L’entrée Visual Basic/Windows étant sélectionnée dans la zone Types de projets, choisissez le modèle Application Windows Forms, nommez le projet Player et validez en cliquant sur OK. Ajoutez un contrôle Treeview, un contrôle ImageList et un contrôle Button dans la feuille de ce projet. Les informations affichées dans un contrôle Treeview sont précédées d’une icône qui indique leur type. Lorsque ce contrôle est utilisé pour afficher le contenu d’une unité de disque, les icônes peuvent être de trois types : dossier fermé, dossier ouvert ou document. Pour faciliter leur manipulation, les trois types d’icônes vont être stockés dans le contrôle ImageList. Cliquez sur l’icône ImageList1, juste en dessous de la feuille de l’application. Cliquez sur le bouton contenant trois points de suspension dans la propriété Images. Cette action affiche la boîte de dialogue Éditeur de collections Images. Cliquez sur Ajouter, rendez-vous dans le dossier Projects\Player des sources de l’ouvrage et ajoutez les icônes folder_closed.bmp, folder_open.bmp et document.bmp. La fenêtre de l’Éditeur de collections Image doit maintenant ressembler à la Figure 10.2. Figure 10.2 Trois icônes ont été ajoutées au contrôle ImageList.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 10
Jouer des sons WAV
261
Modifiez les propriétés des contrôles de l’application comme suit : Contrôle
Propriété
Valeur
Form1
Text
Player WAV
TreeView1
Anchor
Top, Left
TreeView1
Dock
Top
Treeview1
ImageList
ImageList1
Button1
Text
Jouer
Alimentation du contrôle TreeView Nous allons maintenant écrire quelques lignes de code afin de rendre le contrôle Treeview opérationnel. Double-cliquez sur un emplacement inoccupé de la feuille et complétez la procédure Form1_Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load Dim oNode As New System.Windows.Forms.TreeNode() Try oNode.ImageIndex = 0 ‘ Closed folder oNode.SelectedImageIndex = 0 oNode.Text = "C:" TreeView1.Nodes.Add(oNode) oNode.Nodes.Add("") Catch ex As Exception MsgBox("Cannot create initial node:" & ex.ToString) End End Try End Sub
La première ligne de cette procédure définit l’objet oNode de type System.Windows.Forms. TreeNode : Dim oNode As New System.Windows.Forms.TreeNode()
Pour pouvoir utiliser un objet de ce type, ajoutez la déclaration Imports suivante en tête de listing : Imports System.io
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
262
Visual Basic 2010
L’objet oNode sera utilisé pour créer le nœud initial sur la racine du disque C:. Cette création se fait à l’intérieur d’une instruction Try : Try oNode.ImageIndex = 0 ‘Dossier fermé oNode.SelectedImageIndex = 0 oNode.Text = "C:"
Les deux premières lignes définissent le type d’image à afficher en face de l’entrée correspondant à la racine du disque C:. La propriété Text correspond au texte affiché à la suite de l’icône. Le nœud principal est alors ajouté à la structure Treeview à l’aide des deux instructions suivantes : TreeView1.Nodes.Add(oNode) oNode.Nodes.Add("")
Si une erreur se produit, un message apparaît à l’aide d’une instruction MsgBox : Catch ex As Exception MsgBox("Cannot create initial node:" & ex.ToString) End End Try
L’affichage dans l’arborescence Treeview doit être modifié chaque fois que l’utilisateur déplie ou replie un nœud. Pour cela, nous définirons une procédure événementielle pour l’événement BeforeExpand. Affichez la fenêtre de code. Sélectionnez Treeview1 dans la première liste déroulante et BeforeExpand dans la deuxième liste déroulante. Complétez la procédure TreeView1_BeforeExpand() comme suit : Private Sub TreeView1_BeforeExpand(ByVal sender As Object, ByVal e As System. „ Windows.Forms.TreeViewCancelEventArgs) Handles TreeView1.BeforeExpand If e.Node.ImageIndex = 2 Then Exit Sub Try If e.Node.GetNodeCount(False) = 1 And e.Node.Nodes(0).Text = "" Then e.Node.Nodes(0).Remove() AfficheFils(e.Node) End If Catch ex As Exception MsgBox("Unable to expand " & e.Node.FullPath & ":" & ex.ToString) End Try If e.Node.GetNodeCount(False) > 0 Then e.Node.ImageIndex = 1 e.Node.SelectedImageIndex = 1 End If End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 10
Jouer des sons WAV
263
Si l’utilisateur clique sur une entrée d’index (2), c’est-à-dire un document et non un dossier ouvert (1) ou fermé (0), aucun traitement ne doit être effectué : If e.Node.ImageIndex = 2 Then Exit Sub
Dans le cas contraire, si le nombre de nœuds enfants du nœud courant est égal à 1 et si le texte associé au premier nœud fils est vide : Try If e.Node.GetNodeCount(False) = 1 And e.Node.Nodes(0).Text = ""
ce nœud est supprimé : e.Node.Nodes(0).Remove()
Et la procédure AfficheFils() est appelée pour afficher tous les nœuds fils du nœud courant : AfficheFils(e.Node)
Si une erreur se produit, un message apparaît à l’aide de la procédure MsgBox() : Catch ex As Exception MsgBox("Unable to expand " & e.Node.FullPath & ":" & ex.ToString) End Try
Si le nœud qui vient d’être ouvert contient un ou plusieurs nœuds fils : If e.Node.GetNodeCount(False) > 0 Then
l’icône d’index 1 s’affiche : e.Node.ImageIndex = 1 e.Node.SelectedImageIndex = 1
Voyons maintenant comment décrire les entrées du nœud courant à l’aide de la procédure AfficheFils() : Private Sub AfficheFils(ByVal oParent As System.Windows.Forms.TreeNode) Dim oFS As New DirectoryInfo(oParent.FullPath & "\") Dim oDir As DirectoryInfo Dim oFile As FileInfo Try For Each oDir In oFS.GetDirectories() Dim oNode As New System.Windows.Forms.TreeNode() oNode.Text = oDir.Name oNode.ImageIndex = 0 oNode.SelectedImageIndex = 0
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
264
Visual Basic 2010
oParent.Nodes.Add(oNode) oNode.Nodes.Add("") Next chemin = oParent.FullPath + "\" Catch ex As Exception MsgBox("Cannot list folders of " & oParent.FullPath & ":" & ex.ToString) End Try Try For Each oFile In oFS.GetFiles() Dim oNode As New System.Windows.Forms.TreeNode() oNode.Text = oFile.Name oNode.ImageIndex = 2 oNode.SelectedImageIndex = 2 oParent.Nodes.Add(oNode) Next Catch ex As Exception MsgBox("Cannot list files in " & oParent.FullPath & ":" & ex.ToString) End Try End Sub
Les premières lignes définissent les objets qui seront utilisés dans la procédure : Dim oFS As New DirectoryInfo(oParent.FullPath & "\") Dim oDir As DirectoryInfo Dim oFile As FileInfo
oFS est un objet DirectoryInfo qui pointe sur le nœud actuel. oDir est un objet Directory Info qui sera utilisé pour décrire les entrées du nœud actuel. Enfin, iFile est un objet de type FileInfo qui sera utilisé pour décrire les entrées terminales du nœud courant.
Une instruction For Each décrit les dossiers du nœud courant : Try For Each oDir In oFS.GetDirectories()
Les données correspondant aux entrées décrites seront stockées dans l’objet TreeNode oNode : Dim oNode As New System.Windows.Forms.TreeNode()
Le nom de l’entrée et l’image correspondante (dossier fermé) sont stockés dans l’objet oNode : oNode.Text = oDir.Name oNode.ImageIndex = 0
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 10
Jouer des sons WAV
265
Puis le nœud est ajouté à la structure TreeView : oNode.SelectedImageIndex = 0 oParent.Nodes.Add(oNode) oNode.Nodes.Add("")
Le chemin du nœud courant est mémorisé dans la variable chemin : chemin = oParent.FullPath + "\"
Si une erreur se produit, un message d’erreur apparaît à l’aide de la procédure MsgBox() : Catch ex As Exception MsgBox("Impossible de créer le dossier " & oParent.FullPath & ":" & ex.ToString) End Try
Une nouvelle instruction For Each décrit alors tous les fichiers présents dans le nœud qui vient d’être déplié : Try For Each oFile In oFS.GetFiles()
Les données correspondant aux entrées décrites seront stockées dans l’objet TreeNode oNode : Dim oNode As New System.Windows.Forms.TreeNode()
Le nom de l’entrée et l’image correspondante (fichier) sont stockés dans l’objet oNode : oNode.Text = oFile.Name oNode.ImageIndex = 2
Puis le fichier est ajouté à la structure TreeView : oNode.SelectedImageIndex = 2 oParent.Nodes.Add(oNode)
Si une erreur se produit, un message d’erreur apparaît à l’aide de la procédure MsgBox() : Catch ex As Exception MsgBox("Impossible d’afficher les fichiers dans le dossier " & oParent.FullPath & ":" & ex.ToString) End Try
Le contrôle TreeView est maintenant entièrement opérationnel. Vous pouvez lancer le programme en appuyant sur la touche F5 et tester son fonctionnement. Nous allons maintenant jouer le son sélectionné par l’utilisateur en mettant en œuvre la procédure My.Computer.Audio.Play().
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
266
Visual Basic 2010
Utilisation du contrôle TreeView Lorsque l’utilisateur sélectionne un fichier dans le contrôle Treeview, un événement AfterSelect est généré. Nous allons utiliser cet événement pour mémoriser le nom du fichier sélectionné dans un objet String. Basculez dans la fenêtre de code. Sélectionnez l’objet TreeView1 et l’événement AfterSelect puis complétez la procédure TreeView1_After Select() comme suit : Private Sub TreeView1_AfterSelect(ByVal sender As Object, ByVal e As System. Windows.Forms.TreeViewEventArgs) Handles TreeView1.AfterSelect selection = chemin + e.Node.Text End Sub
L’unique instruction de cette procédure mémorise le chemin complet du fichier sélectionné par l’utilisateur dans la variable selection. Pour terminer le programme, nous allons définir la procédure événementielle liée au clic sur le bouton de commande.
Exécution du fichier audio Double-cliquez sur le bouton de commande et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click My.Computer.Audio.Play(selection) End Sub
L’unique instruction de cette procédure utilise la procédure My.Computer.Audio.Play() pour jouer le son WAV sélectionné par l’utilisateur : Voici le listing complet de l’application. Vous trouverez les fichiers correspondants dans le dossier Player après installation des sources de l’ouvrage. Imports System.io Public Class Form1 Dim chemin, selection As String Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load Dim oNode As New System.Windows.Forms.TreeNode()
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 10
Jouer des sons WAV
267
Try oNode.ImageIndex = 0 oNode.SelectedImageIndex = 0 oNode.Text = "C:" TreeView1.Nodes.Add(oNode) oNode.Nodes.Add("") Catch ex As Exception MsgBox("Impossible de créer le noeud initial:" & ex.ToString) End End Try End Sub Private Dim Dim Dim
Sub AfficheFils(ByVal oParent As System.Windows.Forms.TreeNode) oFS As New DirectoryInfo(oParent.FullPath & "\") oDir As DirectoryInfo oFile As FileInfo
Try For Each oDir In oFS.GetDirectories() Dim oNode As New System.Windows.Forms.TreeNode() oNode.Text = oDir.Name oNode.ImageIndex = 0 oNode.SelectedImageIndex = 0 oParent.Nodes.Add(oNode) oNode.Nodes.Add("") Next chemin = oParent.FullPath + "\" Catch ex As Exception MsgBox("Impossible de lister l’arborescence de " & oParent.FullPath „ & ":" & ex.ToString) End Try Try For Each oFile In oFS.GetFiles() Dim oNode As New System.Windows.Forms.TreeNode() oNode.Text = oFile.Name oNode.ImageIndex = 2 oNode.SelectedImageIndex = 2 oParent.Nodes.Add(oNode) Next Catch ex As Exception MsgBox("Impossible de lister les fichiers dans " & oParent.FullPath „ & ":" & ex.ToString) End Try End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
268
Visual Basic 2010
Private Sub TreeView1_AfterSelect(ByVal sender As Object, ByVal e As System. „ Windows.Forms.TreeViewEventArgs) Handles TreeView1.AfterSelect selection = chemin + e.Node.Text End Sub Private Sub TreeView1_BeforeExpand(ByVal sender As Object, ByVal e As „ System.Windows.Forms.TreeViewCancelEventArgs) Handles TreeView1.BeforeExpand If e.Node.ImageIndex = 2 Then Exit Sub Try If e.Node.GetNodeCount(False) = 1 And e.Node.Nodes(0).Text = "" Then ‘e.Node.Nodes(0).Remove() AfficheFils(e.Node) End If Catch ex As Exception MsgBox("Impossible de développer " & e.Node.FullPath & ":" & ex.ToString) End Try If e.Node.GetNodeCount(False) > 0 Then e.Node.ImageIndex = 1 e.Node.SelectedImageIndex = 1 End If End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click My.Computer.Audio.Play(selection) End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
11 Manipuler des données tabulaires Ce chapitre propose deux projets qui ont un rapport avec la manipulation de données numériques. Le premier reproduit les fonctions élémentaires d’un tableur. Le second projet complète le premier en montrant comment représenter graphiquement des tableaux de données.
Minitableur Cette application montre comment manipuler des données tabulaires en utilisant le contrôle DataGridView. Les données initialement affichées dans ce contrôle sont issues du fichier texte DATA.TXT, qui doit se trouver dans le dossier C:\test à l’exécution de l’application. Vous pouvez modifier les données, ajouter de nouvelles données et calculer la somme de plusieurs cellules, comme vous le feriez dans un tableur. La grille contient 29 colonnes et
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
270
Visual Basic 2010
autant de lignes que vous le souhaitez. Les barres de défilement permettent de déplacer la fenêtre de visualisation dans l’ensemble des cellules du tableau. Lancez la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom Tableur au projet et validez en cliquant sur OK. Développez l’onglet Données de la Boîte à outils et double-cliquez sur le contrôle DataGridView. Ajoutez deux boutons de commande et une zone de texte. Modifiez les propriétés de ces contrôles comme suit : Contrôle
Propriété
Valeur
Button1
Name
Quitter
Button1
Text
Quitter
Button2
Name
Somme
Button2
Text
Somme
TextBox
Name
SommeSel
DataGridView1
Dock
Top
Form1
Text
Minitableur
Redimensionnez ces contrôles et modifiez leur agencement pour obtenir un effet visuel proche de la Figure 11.1. Figure 11.1 Disposition des contrôles sur la feuille.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 11
Manipuler des données tabulaires
271
Les données qui vont être intégrées dans le tableau proviennent d’un fichier texte dont voici le contenu : 1800 1900 1940 1983 Amsterdam 201000 511000 794000 994062 Londres 959000 6581000 8700000 6754500 Madrid 160000 540000 1048000 3188297 Moscou 250000 1039000 4137000 8546000 New York 79000 3437000 7455000 7086096 Paris 547000 2714000 2725000 2176243 Pékin 700000 1000000 1556000 9230687
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
272
Visual Basic 2010
Chaque ligne du fichier texte correspond à une cellule du tableau. Les lignes du tableau contiennent cinq cellules. Le tableau est donc organisé comme suit : 1800
1900
1940
1983
Amsterdam
201000
511000
794000
994062
Londres
959000
6581000
8700000
6754500
Madrid
160000
540000
1048000
3188297
Moscou
250000
1039000
4137000
8546000
New York
79000
3437000
7455000
7086096
Paris
547000
2714000
2725000
2176243
Pékin
700000
1000000
1556000
9230687
Double-cliquez sur un endroit inoccupé de la feuille et complétez la procédure Form_Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load Dim i As Integer Dim s1, s2, s3, s4, s5 As String DataGridView1.ColumnCount = 30 For i = 0 To 29 DataGridView1.Columns(i).Name = Str(i) Next Try FileOpen(1, "c:\test\data.txt", OpenMode.Input) Do s1 = LineInput(1) s2 = LineInput(1) s3 = LineInput(1) s4 = LineInput(1) s5 = LineInput(1) DataGridView1.Rows.Add(New String() {s1, s2, s3, s4, s5}) Loop Until EOF(1) Catch Finally FileClose(1) End Try End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 11
Manipuler des données tabulaires
273
Le premier bloc d’instructions définit les variables utilisées par l’application : Dim i As Integer Dim s1, s2, s3, s4, s5 As String
Le nombre de colonnes du contrôle DataGridView est ensuite fixé à 30 et les colonnes sont nommées : DataGridView1.ColumnCount = 30 For i = 0 To 29 DataGridView1.Columns(i).Name = Str(i) Next
Enfin, le dernier bloc d’instructions utilise le fichier c:\test\data.txt pour afficher les données dans le contrôle AxMSFlexGrid1. L’ouverture et la lecture du fichier se font à l’intérieur d’une instruction Try : Try FileOpen(1, "c:\test\data.txt", OpenMode.Input)
Dans un premier temps, les cinq données à afficher sur une ligne sont lues : Do s1 s2 s3 s4 s5
= = = = =
LineInput(1) LineInput(1) LineInput(1) LineInput(1) LineInput(1)
Elles sont ensuite stockées dans le contrôle DataGridView : DataGridView1.Rows.Add(New String() {s1, s2, s3, s4, s5})
Le processus prend fin lorsque la fin du fichier est atteinte : Loop Until EOF(1)
Le fichier c:\test\data.txt est alors fermé : Catch Finally FileClose(1) End Try
Vous pouvez exécuter l’application en appuyant sur la touche F5. Les données sont lues et apparaissent dans la grille, mais les boutons de commande et la zone de texte sont encore inopérationnels.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
274
Visual Basic 2010
Basculez sur la fenêtre de code. Sélectionnez DataGridView1 dans la première liste déroulante et Click dans la seconde. Complétez la procédure DataGridView1_Click() comme suit : Private Sub DataGridView1_Click(ByVal sender As Object, ByVal e As System.EventArgs) „ Handles DataGridView1.Click SommeSel.Text = DataGridView1.CurrentCell.Value SommeSel.Focus() End Sub
La première instruction copie la cellule sélectionnée (ou la première cellule du bloc sélectionné) dans la zone de texte : SommeSel.Text = DataGridView1.CurrentCell.Value
La seconde instruction donne le focus à la zone de texte : SommeSel.Focus()
Toujours dans la fenêtre de code, sélectionnez SommeSel dans la première liste déroulante et KeyDown dans la seconde. Complétez la procédure SommeSel_KeyDown() comme suit : Private Sub SommeSel_KeyDown(ByVal sender As Object, ByVal e As System.Windows. „ Forms.KeyEventArgs) Handles SommeSel.KeyDown DataGridView1.CurrentCell.Value = SommeSel.Text End Sub
L’unique instruction de cette procédure copie le contenu de la zone de texte dans la cellule courante du contrôle DataGridView. Double-cliquez sur le bouton Somme et ajoutez les instructions suivantes à la procédure Somme_Click() : Private Sub Somme_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Somme.Click Dim lig, col, som As Integer Dim i As Integer Dim selectedcellcount As Integer = DataGridView1.GetCellCount(DataGridViewElementStates.Selected) If selectedcellcount > 0 Then som = 0 For i = 0 To selectedcellcount - 1 lig = DataGridView1.SelectedCells(i).RowIndex col = DataGridView1.SelectedCells(i).ColumnIndex som = som + DataGridView1.SelectedCells(i).FormattedValue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 11
Manipuler des données tabulaires
275
Next SommeSel.Text = Str(som) End If End Sub
Les deux premières lignes définissent les variables qui permettront d’accéder aux cellules sélectionnées : Dim lig, col, som As Integer Dim i As Integer
La variable entière SelectedCellCount est alors définie et initialisée avec la valeur renvoyée par la fonction GetCellCount() : Dim selectedcellcount As Integer = DataGridView1.GetCellCount(DataGridView„ ElementStates.Selected)
Si au moins une cellule est sélectionnée : If selectedcellcount > 0 Then
la somme des cellules sélectionnées doit être calculée. Pour cela, la variable résultat som est initialisée à zéro et les SelectedCellCount cellules sélectionnées sont parcourues : som = 0 For i = 0 To selectedcellcount - 1
Les index de ligne et de colonne sont calculés dans les variables lig et col à l’aide des propriétés RowIndex et ColumnIndex des objets SelectedCell(i) : lig = DataGridView1.SelectedCells(i).RowIndex col = DataGridView1.SelectedCells(i).ColumnIndex
Puis le résultat est incrémenté de la valeur contenue dans la cellule pointée : som = som + DataGridView1.SelectedCells(i).FormattedValue
Pour terminer cette application, double-cliquez sur le bouton Quitter et ajoutez le mot End à la procédure Quitter_Click() : Private Sub Quitter_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Quitter.Click End End Sub
Le programme est entièrement opérationnel. Vous pouvez modifier une ou plusieurs cellules, sélectionner une zone rectangulaire contenant des données numériques et en calculer la somme.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
276
Visual Basic 2010
Voici le listing complet du programme. Les fichiers correspondants se trouvent dans le dossier Tableur après installation des sources de l’ouvrage. Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load Dim i As Integer Dim s1, s2, s3, s4, s5 As String DataGridView1.ColumnCount = 30 For i = 0 To 29 DataGridView1.Columns(i).Name = Str(i) Next Try FileOpen(1, "c:\test\data.txt", OpenMode.Input) Do s1 = LineInput(1) s2 = LineInput(1) s3 = LineInput(1) s4 = LineInput(1) s5 = LineInput(1) DataGridView1.Rows.Add(New String() {s1, s2, s3, s4, s5}) Loop Until EOF(1) Catch Finally FileClose(1) End Try End Sub Private Sub DataGridView1_Click(ByVal sender As Object, ByVal e As System. „ EventArgs) Handles DataGridView1.Click SommeSel.Text = DataGridView1.CurrentCell.Value SommeSel.Focus() End Sub Private Sub SommeSel_KeyDown(ByVal sender As Object, ByVal e As
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 11
Manipuler des données tabulaires
277
System.Windows.Forms.KeyEventArgs) Handles SommeSel.KeyDown DataGridView1.CurrentCell.Value = SommeSel.Text End Sub Private Sub Somme_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Somme.Click Dim lig, col, som As Integer Dim i As Integer Dim selectedcellcount As Integer = DataGridView1.GetCellCount(DataGridViewElementStates.Selected) If selectedcellcount > 0 Then som = 0 For i = 0 To selectedcellcount - 1 lig = DataGridView1.SelectedCells(i).RowIndex col = DataGridView1.SelectedCells(i).ColumnIndex som = som + DataGridView1.SelectedCells(i).FormattedValue Next SommeSel.Text = Str(som) End If End Sub Private Sub Quitter_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Quitter.Click End End Sub End Class
Minigrapheur Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom Grapheur au projet et validez en cliquant sur OK. Pour mettre en place ce projet, nous allons utiliser deux contrôles liés à l’application Microsoft Office 2003 : AxSpreadSheet et AxChartSpace.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
278
Visual Basic 2010
Ces contrôles n’étant pas disponibles par défaut dans la Boîte à outils, lancez la commande Ajouter une référence du menu Projets. Sous l’onglet COM, sélectionnez Microsoft Office Web Components 11.0 (voir Figure 11.2). Figure 11.2 Ajout des contrôles COM AxSpreadSheet et AxChartSpace.
Info
Si Office XP est installé sur votre ordinateur, sélectionnez Microsoft Office Web Components 10.0 pour installer la version 10 de ce composant. Si Office 2007 ou 2010 est installé sur votre ordinateur, le composant OWC n’est plus disponible. Vous pouvez cependant le télécharger à l’adresse www. microsoft.com/downloads/details.aspx?FamilyId=7287252C-402E-4F7297A5-E0FD290D4B76&displaylang=fr. Installez ce composant et sélectionnez Microsoft Office Web Components 11.0 dans la boîte de dialogue Ajouter une référence pour le rendre accessible à l’application.
Pour rendre accessibles les contrôles AxSpreadSheet et AxChartSpace dans la Boîte à outils, lancez la commande Choisir des éléments de boîte à outils dans le menu Outils, sélectionnez l’onglet Composants web dans la boîte de dialogue Choisir des éléments de boîte à outils, cochez les cases Microsoft Office Chart 11.0 et Microsoft Office Spread sheet 11.0 (voir Figure 11.3). Les contrôles AxSpreadSheet et AxChartSpace sont maintenant disponibles sous l’onglet Général de la Boîte à outils (voir Figure 11.4).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 11
Manipuler des données tabulaires
279
Figure 11.3 Ajout des contrôles à la Boîte à outils.
Figure 11.4 Les deux contrôles ont été ajoutés à la Boîte à outils.
L’onglet Général de la Boîte à outils étant développé, double-cliquez sur Microsoft Office Spreadsheet 11.0, puis sur Microsoft Office Chart 11.0 (avec Office XP, il vous suffit de double-cliquer sur la version 10 de ces deux contrôles). Agrandissez la feuille de l’application, puis redimensionnez et repositionnez ces deux contrôles pour obtenir l’agencement de la Figure 11.5.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
280
Visual Basic 2010
Figure 11.5 La feuille de l’application Tableur, en mode Édition.
Exécutez l’application en appuyant sur la touche F5. Vous pouvez constater que le tableur est entièrement opérationnel, mais que l’objet Chart n’affiche aucun graphique (voir Figure 11.6). Figure 11.6 La feuille de l’application, en mode Exécution.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 11
Manipuler des données tabulaires
281
Nous allons donner vie à ces deux contrôles en insérant les données du fichier Data.txt (voir section précédente) dans le contrôle Spreadsheet et en représentant ces données dans le contrôle Chart. Double-cliquez sur une endroit inoccupé de la feuille et complétez la procédure Form_ Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load ‘Lecture des données dans le fichier texte Data.txt i = 0 Try FileOpen(1, "c:\test\data.txt", OpenMode.Input) Do i = i + 1 s1 = LineInput(1) s2 = LineInput(1) s3 = LineInput(1) s4 = LineInput(1) s5 = LineInput(1) Dim a As Object() = {s1, s2, s3, s4, s5} s = "A" + Chr(48 + i) + ":E" + Chr(48 + i) With AxSpreadsheet1.ActiveSheet .Range(s).Value = a End With Loop Until EOF(1) Catch Finally FileClose(1) End Try ‘Liaison du graphique à la feuille de calcul AxChartSpace1.DataSource = AxSpreadsheet1.GetOcx() Dim oChart As OWC11.ChChart, oSer As OWC11.ChSeries oChart = AxChartSpace1.Charts.Add() oChart.HasLegend = True oSer = oChart.SeriesCollection.Add oSer.SetData(OWC11.ChartDimensionsEnum.chDimSeriesNames, 0, "B1") oSer.SetData(OWC11.ChartDimensionsEnum.chDimCategories, 0, "A2:A8") oSer.SetData(OWC11.ChartDimensionsEnum.chDimValues, 0, "B2:B8")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
282
Visual Basic 2010
oSer = oChart.SeriesCollection.Add oSer.SetData(OWC11.ChartDimensionsEnum.chDimSeriesNames, 0, "C1") oSer.SetData(OWC11.ChartDimensionsEnum.chDimCategories, 0, "A2:A8") oSer.SetData(OWC11.ChartDimensionsEnum.chDimValues, 0, "C2:C8") oSer = oChart.SeriesCollection.Add oSer.SetData(OWC11.ChartDimensionsEnum.chDimSeriesNames, 0, "D1") oSer.SetData(OWC11.ChartDimensionsEnum.chDimCategories, 0, "A2:A8") oSer.SetData(OWC11.ChartDimensionsEnum.chDimValues, 0, "D2:D8") oSer = oChart.SeriesCollection.Add oSer.SetData(OWC11.ChartDimensionsEnum.chDimSeriesNames, 0, "E1") oSer.SetData(OWC11.ChartDimensionsEnum.chDimCategories, 0, "A2:A8") oSer.SetData(OWC11.ChartDimensionsEnum.chDimValues, 0, "E2:E8") End Sub
Le premier bloc d’instructions lit le contenu du fichier c:\test\data.txt. La lecture se fait à l’intérieur d’une structure Try : Try FileOpen(1, "c:\test\data.txt", OpenMode.Input)
Une boucle Do Loop lit les données cinq par cinq : Do i = i + 1 s1 = LineInput(1) s2 = LineInput(1) s3 = LineInput(1) s4 = LineInput(1) s5 = LineInput(1)
Ces données sont stockées dans la collection S : Dim a As Object() = {s1, s2, s3, s4, s5} s = "A" + Chr(48 + i) + ":E" + Chr(48 + i)
Puis elles sont copiées dans le contrôle Spreadsheet1 : With AxSpreadsheet1.ActiveSheet .Range(s).Value = a End With
La lecture se poursuit jusqu’à la fin du fichier : Loop Until EOF(1)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 11
Manipuler des données tabulaires
283
Le fichier est alors fermé : Catch Finally FileClose(1) End Try
L’instruction suivante relie la feuille de calcul et le graphique : AxChartSpace1.DataSource = AxSpreadsheet1.GetOcx()
Après avoir défini les objets OWC11.ChChart oChart et OWC11.ChSeries oSer : Dim oChart As OWC11.ChChart, oSer As OWC11.ChSeries
un nouveau graphisme est initialisé : oChart = AxChartSpace1.Charts.Add()
Puis la propriété HasLegend de l’objet oChart est mise à True pour indiquer que le graphisme contient une légende : oChart.HasLegend = True
Les quatre blocs d’instructions relient une série de données avec une plage de cellules de la feuille de calcul. Dans un premier temps, la procédure SeriesCollection.Add() est invoquée pour ajouter une nouvelle série de données : oSer = oChart.SeriesCollection.Add
Pour définir la nouvelle série, il faut spécifier :
∑
le nom de la série : oSer.SetData(OWC11.ChartDimensionsEnum.chDimSeriesNames, 0, "B1")
∑
les cellules contenant les noms des catégories : oSer.SetData(OWC11.ChartDimensionsEnum.chDimCategories, 0, "A2:A8")
∑
les cellules contenant les données numériques de la série à représenter : oSer.SetData(OWC11.ChartDimensionsEnum.chDimValues, 0, "B2:B8")
Pour que ce code soit en mesure de fonctionner, vous devez ajouter une clause Imports en début de programme : Imports OWC11 = Microsoft.Office.Interop.Owc11
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
284
Visual Basic 2010
et déclarer les variables String et Integer utilisées à la suite de la ligne Public Class Form1 : Dim s, s1, s2, s3, s4, s5 As String Dim i As Integer
Appuyez sur la touche F5 pour exécuter le programme. La feuille de calcul et la représentation graphique apparaissent dès l’ouverture de la fenêtre (voir Figure 11.7). Figure 11.7 Quelques lignes de code ont suffi pour rendre cette application opérationnelle.
Info
La plage de cellules A1:E8 et la représentation graphique étant liées, vous pouvez modifier les données numériques et voir leur impact dans le graphique.
Voici le listing complet de l’application. Vous trouverez les fichiers complémentaires dans le dossier Grapheur après installation des sources de l’ouvrage. Imports OWC11 = Microsoft.Office.Interop.Owc11 Public Class Form1 Dim s, s1, s2, s3, s4, s5 As String Dim i As Integer
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 11
Manipuler des données tabulaires
285
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. EventArgs) Handles MyBase.Load ‘Lecture des données dans le fichier texte Data.txt i = 0 Try FileOpen(1, "c:\test\data.txt", OpenMode.Input) Do i = i + 1 s1 = LineInput(1) s2 = LineInput(1) s3 = LineInput(1) s4 = LineInput(1) s5 = LineInput(1) Dim a As Object() = {s1, s2, s3, s4, s5} s = "A" + Chr(48 + i) + ":E" + Chr(48 + i) With AxSpreadsheet1.ActiveSheet .Range(s).Value = a End With Loop Until EOF(1) Catch Finally FileClose(1) End Try ‘Liaison du graphique à la feuille de calcul AxChartSpace1.DataSource = AxSpreadsheet1.GetOcx() Dim oChart As OWC11.ChChart, oSer As OWC11.ChSeries oChart = AxChartSpace1.Charts.Add() oChart.HasLegend = True oSer = oChart.SeriesCollection.Add oSer.SetData(OWC11.ChartDimensionsEnum.chDimSeriesNames, 0, "B1") oSer.SetData(OWC11.ChartDimensionsEnum.chDimCategories, 0, "A2:A8") oSer.SetData(OWC11.ChartDimensionsEnum.chDimValues, 0, "B2:B8") oSer = oChart.SeriesCollection.Add oSer.SetData(OWC11.ChartDimensionsEnum.chDimSeriesNames, 0, "C1") oSer.SetData(OWC11.ChartDimensionsEnum.chDimCategories, 0, "A2:A8") oSer.SetData(OWC11.ChartDimensionsEnum.chDimValues, 0, "C2:C8")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
286
Visual Basic 2010
oSer = oChart.SeriesCollection.Add oSer.SetData(OWC11.ChartDimensionsEnum.chDimSeriesNames, 0, "D1") oSer.SetData(OWC11.ChartDimensionsEnum.chDimCategories, 0, "A2:A8") oSer.SetData(OWC11.ChartDimensionsEnum.chDimValues, 0, "D2:D8") oSer = oChart.SeriesCollection.Add oSer.SetData(OWC11.ChartDimensionsEnum.chDimSeriesNames, 0, "E1") oSer.SetData(OWC11.ChartDimensionsEnum.chDimCategories, 0, "A2:A8") oSer.SetData(OWC11.ChartDimensionsEnum.chDimValues, 0, "E2:E8") End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
12 Bases de données ADO.NET est le successeur d’ADO (ActiveX Data Objects). Ses fonctionnalités permettent d’accéder simplement à des bases de données locales ou distantes. À travers un ensemble de procédures et de fonctions, il est possible de visualiser, de modifier et de supprimer les données contenues dans une base de données, que celle-ci se trouve sur l’ordinateur local ou sur un ordinateur distant. Pour illustrer le fonctionnement d’ADO.NET, nous allons prendre deux exemples. Le premier permettra d’accéder à une base de données locale Microsoft Access. Le second sera une copie conforme du premier, à ceci près que les données se trouveront sur un serveur distant.
Accès à une base de données locale Lancez la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Nommez le projet db et validez en cliquant sur OK. Ajoutez un contrôle DataGridView et quatre boutons de commande
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
288
Visual Basic 2010
à la feuille du projet et modifiez les propriétés de ces objets comme indiqué dans le tableau suivant : Contrôle
Propriété
Valeur
Form1
Text
Accès à une base locale
Button1
Text
Bibliothèque
Button1
Name
Bibliothèque
Button2
Text
Tous
Button2
Name
Tous
Button3
Text
Mise à jour
Button3
Name
MiseAJour
Button4
Text
Quitter
Button4
Name
Quitter
Pour terminer la mise en forme de l’application, cliquez sur le contrôle DataGridView et affectez la valeur Top à sa propriété Dock. Pour cela, développez cette propriété en déroulant la liste Dock et cliquez sur le rectangle supérieur (voir Figure 12.1). Figure 12.1 Affectation de la valeur Top à la propriété Dock du contrôle DataGridView1.
La feuille de l’application devrait maintenant avoir l’allure de la Figure 12.2.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
289
Figure 12.2 L’application db mise en forme, en mode Édition.
Cette application utilise les bibliothèques System.Data et System.Data.OleDB. Ajoutez les deux instructions ci-après en tête de listing : Imports System.Data Imports System.Data.OleDb
Définissez les objets utilisés par l’application à la suite du code généré par Windows Form Designer : Dim Dim Dim Dim Dim
Connexion As String ConnexionOLE As OleDBConnection = New oledbConnection() da As OleDbDataAdapter ds As DataSet dv As DataView
Dim cb As OleDbCommandBuilder
L’exemple choisi repose sur une base de données Access librement téléchargeable sur la page http://www.info-3000.com/access/bestofgestion/index.php. Cette base contient plusieurs tables de données. Nous allons nous intéresser à l’une d’entre elles, qui a pour nom "Catégories". Pour afficher l’ensemble des enregistrements qui la composent, nous allons définir la procédure AfficheTous() : Public Sub AfficheTous() Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion ConnexionOLE.Open() da = New OleDbDataAdapter("Select * from T_TravailObjet", ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
290
Visual Basic 2010
dv = ds.Tables("mytable").DefaultView ConnexionOLE.Close() DataGridView1.DataSource = dv dv.AllowEdit = True End Sub
La première ligne initialise la chaîne Connexion avec une valeur qui indique le type (Provider) et le nom (Data Source) de la base de données à laquelle accéder : Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\bestofgestion97.mdb"
Info
Remarquez le séparateur ";" entre les deux paramètres de la chaîne Connexion. Si nécessaire, vous utiliserez ce même séparateur pour préciser le nom d’utilisateur (User ID) et le mot de passe (password).
Cette chaîne est passée à l’objet OleDBConnexion ConnexionOLE pour établir la connexion avec la base de données : ConnexionOLE.ConnectionString = Connexion
Puis un objet OleDbDataAdapter est utilisé pour accéder à la table T_TravailObjet de la base : da = New OleDbDataAdapter("Select * from T_TravailObjet", ConnexionOLE)
Les données de la table T_TravailObjet sont placées dans un objet DataSet. Ce dernier est rempli à l’aide de la méthode Fill() : ds = New DataSet() da.Fill(ds, "mytable")
Pour que l’objet DataSet puisse être édité par l’application, il est nécessaire de le copier dans un objet DataView : dv = ds.Tables("mytable").DefaultView
Il suffit maintenant de l’associer au contrôle DataGridView et de valider son édition : DataGridView1.DataSource = dv dv.AllowEdit = True
Pour que tous les enregistrements de la table Catégories soient visualisés dans le contrôle DataGrid dès l’exécution de l’application, il suffit d’invoquer la procédure AfficheTous() dans Form1_Load(). Double-cliquez sur un emplacement inoccupé de la feuille et complétez la procédure Form1_Load() comme suit :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
291
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load AfficheTous() End Sub
La fenêtre de l’application se présente alors comme montré à la Figure 12.3. Figure 12.3 Affichage de tous les enregistrements de la table T_TravailObjet.
Nous allons maintenant associer du code aux quatre boutons de commande de la feuille. Le bouton Bibliothèque va limiter l’affichage aux enregistrements dont le champ LibelleObjet vaut "bibliothèque". Double-cliquez sur le premier bouton et complétez la procédure Bibliothèque_Click() comme suit : Private Sub Bibliothèque_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Condiments.Click Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion da = New OleDbDataAdapter("Select * from T_TravailObjet where [LibelleObjet] =‘bibliothèque’", ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") dv = ds.Tables("mytable").DefaultView DataGrid1.DataSource = dv dv.AllowEdit = True End Sub
Cette procédure est très proche de AfficheTous(), à ceci près que la commande d’initialisation de l’objet OleDbDataAdapter utilise une clause where pour que seuls les enregistrements dont le champ Nom de catégorie vaut Condiments soient sélectionnés : da = New OleDbDataAdapter("Select * from T_TravailObjet where [LibelleObjet] „ =‘bibliothèque’", ConnexionOLE)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
292
Visual Basic 2010
Double-cliquez sur le bouton Tous. La procédure Tous_Click() est identique à la procédure Form1_Load(). Elle se contente d’invoquer AfficheTous() afin d’afficher tous les enregistrements de la table Catégories : Private Sub Tous_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Tous.Click AfficheTous() End Sub
Les champs de données de la table peuvent être modifiés. Mais, attention, si vous refermez l’application, ils ne seront pas automatiquement sauvegardés dans la base de données ! Pour cela, vous devrez appeler la méthode Update(). Cette action sera effectuée en appuyant sur le bouton Mise à jour. Double-cliquez sur ce bouton et complétez la procédure MiseAJour_Click() comme suit : Private Sub MiseAJour_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MiseAJour.Click Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion cb = New OleDbCommandBuilder(da) da.Update(ds, "mytable") End Sub
Après avoir spécifié la base de données à utiliser : Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion
l’objet OleDbCommandBuilder cb est créé a partir de l’objet OleDbDataAdapter da : cb = New OleDbCommandBuilder(da)
Il suffit maintenant d’utiliser la méthode Update() pour mettre à jour la table avec le contenu de l’objet OleDbDataAdapter : da.Update(ds, "mytable")
Pour terminer, double-cliquez sur le bouton Quitter et ajoutez une instruction End dans la procédure Quitter_Click() : Private Sub Quitter_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Quitter.Click End End Sub
Voici le listing complet de l’application. Les fichiers correspondants se trouvent dans le dossier db après installation des sources de l’ouvrage.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
293
Imports System.Data Imports System.Data.OleDb Public Class Form1 Dim Connexion As String Dim ConnexionOLE As OleDbConnection Dim da As OleDbDataAdapter Dim ds As DataSet Dim dv As DataView Dim cb As OleDbCommandBuilder Public Sub AfficheTous() Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE = New OleDbConnection ConnexionOLE.ConnectionString = Connexion da = New OleDbDataAdapter("Select * from T_TravailObjet", ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") dv = ds.Tables("mytable").DefaultView DataGridView1.DataSource = dv dv.AllowEdit = True End Sub
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load AfficheTous() End Sub Private Sub Bibliothèque_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles Bibliothèque.Click Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion da = New OleDbDataAdapter("Select * from T_TravailObjet where [LibelleObjet] „ =‘bibliothèque’", ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") dv = ds.Tables("mytable").DefaultView DataGridView1.DataSource = dv dv.AllowEdit = True End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
294
Visual Basic 2010
Private Sub Tous_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Tous.Click AfficheTous() End Sub Private Sub MiseAjour_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles MiseAjour.Click Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion cb = New OleDbCommandBuilder(da) da.Update(ds, "mytable") End Sub Private Sub Quitter_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Quitter.Click End End Sub End Class
Accès à une base de données distante Dans cette section, nous allons vous montrer comment créer une application capable d’exploiter des données contenues dans une base de données distante. Cette base a pour nom BestOfGestion.mdb. Elle est librement téléchargeable sur la page www.info-3000.com/ access/bestofgestion/index.php. La technique utilisée relève des services web. Pour tous renseignements complémentaires, consultez le Chapitre 25.
Définition du service web Lancez la commande Nouveau/Site web du menu Fichier. Sélectionnez .NET Framework 3.5 dans la liste déroulante Frameworks. Sélectionnez le modèle Service web ASP.NET, donnez le nom Service1 au nouveau service web et validez en cliquant sur OK. Ajoutez les clauses Imports suivantes en tête de listing : Imports System.Data Imports System.Data.OleDb
La clause (devant le mot-clé Public) indique que la classe Service1 sera utilisée comme service web :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
295
_ _ _ Public Class Service Inherits System.Web.Services.WebService
Lorsque, par la suite, le service sera implanté sur un serveur web, vous devrez préciser son nom de domaine à la suite du mot-clé NameSpace.
Info
Définissez les variables utilisées par le service web : Dim Dim Dim Dim
Connexion As String ConnexionOLE As OleDbConnection = New OleDbConnection() da As OleDbDataAdapter ds As DataSet
Supprimez la fonction HelloWorld(), générée automatiquement par Visual Studio, et remplacez-la par la fonction AfficheTous() suivante : Public Function AfficheTous() As DataSet Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ c:\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion da = New OleDbDataAdapter("Select * from T_TravailObjet", ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") Return ds End Function
Cette fonction sera exploitée sur le Web (). Elle ne demande aucun argument ; mais renvoie un DataSet : Public Function AfficheTous() As DataSet
Les deux lignes suivantes établissent une connexion avec la base de données. Ici, il s’agit de la base Access c:\bestofgestion97.mdb : Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion
Tous les enregistrements de la table T_TravailObjet sont sélectionnés et placés dans l’objet OleDbDataAdapter da : da = New OleDbDataAdapter("Select * from T_TravailObjet", ConnexionOLE)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
296
Visual Basic 2010
Puis le DataSet ds est rempli avec l’objet da : ds = New DataSet() da.Fill(ds, "mytable")
Enfin, l’objet DataSet ds est retourné par la fonction : Return ds
Voici le code complet de la classe Service1 : Imports System.Web Imports System.Web.Services Imports System.Web.Services.Protocols Imports System.Data Imports System.Data.OleDb
_ _ _ Public Class Service Inherits System.Web.Services.WebService Dim Connexion As String Dim ConnexionOLE As OleDbConnection = New OleDbConnection() Dim da As OleDbDataAdapter Dim ds As DataSet Public Function AfficheTous() As DataSet Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ c:\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion da = New OleDbDataAdapter("Select * from T_TravailObjet", ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") Return ds End Function End Class
Appuyez sur la touche F5. La fonction AfficheTous() peut être testée (voir Figure 12.4).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
297
Figure 12.4 Cette page permet de tester la fonction AfficheTous.
Cliquez sur le lien AfficheTous puis sur le bouton Appeler. Le résultat de la fonction AfficheTous() apparaît sous une forme XML (voir Figure 12.5). Figure 12.5 Résultat de la fonction fficheTous(). A
Dans la barre de notification, une icône indique que le service web est en cours d’exécution et précise le port utilisé (voir Figure 12.6).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
298
Visual Basic 2010
Figure 12.6 Dans cet exemple, le service web est accessible sur le port 53946.
Ne terminez pas l’exécution du service. Nous en aurons besoin dans la section suivante.
Utilisation du service web Vous allez maintenant définir un projet qui exploite le service web défini dans la section précédente. Ouvrez une nouvelle instance de Visual Studio et lancez la commande Nouveau > Site web du menu Fichier. Choisissez .NET Framework 3.5 dans la première liste déroulante et sélectionnez le modèle Site web ASP.NET. Donnez le nom TestBDDistante à l’application et validez (cette application se trouve dans le dossier Projects\TestBDDistante des sources de l’ouvrage). Cliquez du bouton droit sur l’entrée C:\…\TestBDDistante dans l’Explorateur de solutions et choisissez Ajouter une référence web dans le menu surgissant. Saisissez l’adresse correspondant au service web en cours de débogage dans la zone URL (voir Figure 12.6).
Info
Pour connaître le port utilisé par le service en cours de débogage, il suffit de pointer l’icône Serveur de développement ASP.NET dans la barre de notification (voir Figure 12.7).
Figure 12.7 L’icône Serveur de développement ASP.NET indique le port utilisé par le service web.
Cliquez sur le bouton Aller à. La boîte de dialogue Ajouter une référence web se présente comme montré à la Figure 12.8.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
299
Figure 12.8 Le service Service1 est sur le point d’être intégré au projet web.
Cliquez sur Ajouter une référence. Le service web Service1 est maintenant référencé dans le projet. Vous pouvez donc utiliser sa méthode AfficheTous() (voir Figure 12.9). Figure 12.9 Le service web Service1 est référencé dans le projet.
Ajoutez un contrôle GridView sur la page de l’application (ce contrôle se trouve sous l’onglet Données de la Boîte à outils). La fenêtre de conception se présente comme montré à la Figure 12.10.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
300
Visual Basic 2010
Figure 12.10 Le contrôle GridView a été placé sur la feuille.
Pour rendre ce contrôle opérationnel, vous devez l’initialiser. Déroulez la liste Choisir la source de données et sélectionnez l’entrée . Une boîte de dialogue intitulée Assistant Configuration de source de données s’affiche (voir Figure 12.11). Figure 12.11 Cet assistant va vous aider à associer la fonction fficheTous() au contrôle A GridView.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
301
Sélectionnez Objet dans la zone À partir d’où l’application obtiendra-t-elle les données, puis validez en cliquant sur OK. L’assistant vous demande alors de choisir un "métier" par l’intermédiaire duquel vous pourrez mettre à jour les données de la table (voir Figure 12.12). Figure 12.12 Choix du métier localhost. Service.
Choisissez localhost.Service et cliquez sur Suivant. Vous devez maintenant choisir la méthode qui permettra de remplir l’objet GridView. Déroulez la liste et choisissez la méthode AfficheTous() (voir Figure 12.13). Figure 12.13 La méthode AfficheTous() va permettre de remplir le GridView.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
302
Visual Basic 2010
Cliquez sur Terminer. Vous pouvez vérifier que la méthode AfficheTous() du service web Service1 est bien exécutée en cliquant sur le bouton Démarrer le débogage. Une boîte de dialogue vous informe que le débogage ne peut pas être réalisé (voir Figure 12.14). Sélectionnez l’option Modifier le fichier web.config pour activer le débogage et validez en cliquant sur OK. Figure 12.14 Vous devez activer le débogage.
Au bout de quelques secondes, l’Explorateur web affiche le contenu de la table renvoyée par la méthode AfficheTous() (voir Figure 12.15). Figure 12.15 La communication avec le service web a renvoyé les données escomptées.
Utilisation plus complète du service web Nous allons maintenant améliorer le service web et l’application qui l’utilise pour adresser des commandes SQL à la base de données bestofgestion97.mdb.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
303
Ouvrez le service web Service1. Ajoutez la méthode AfficheBiblio() pour ne sélectionner que les condiments dans la table Catégories : Public Function AfficheBiblio() As DataSet Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion da = New OleDbDataAdapter("Select * from T_TravailObjet where [LibelleObjet] „ =‘bibliothèque’", ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") Return ds End Function
Cette méthode est très proche de AfficheTous(), à ceci près que l’instruction de sélection des enregistrements dans la table T_TravailObjet est plus restrictive. Seuls les enregis trements dont le champ LibelleObjet a pour valeur bibliothèque sont sélectionnés : da = New OleDbDataAdapter("Select * from T_TravailObjet where [LibelleObjet]=‘bibliothèque’", ConnexionOLE)
Définissez maintenant la méthode AfficheSQL(). Elle permettra à l’utilisateur d’interroger la base de données en entrant une requête SQL de son choix : Public Function AfficheSQL(ByVal st As String) As DataSet Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion da = New OleDbDataAdapter(st, ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") Return ds End Function
Remarquez la définition de la fonction AfficheSQL(). Celle-ci admet un argument String et retourne un DataSet : Public Function AfficheSQL(ByVal st As String) As DataSet
La chaîne st passée en argument de la fonction est utilisée pour sélectionner les enregis trements dans l’objet da : da = New OleDbDataAdapter(st, ConnexionOLE)
Voici le code complet du service web Service1. Ce code, ainsi que les fichiers complémentaires au projet, se trouvent dans le dossier Service1 après installation des sources de l’ouvrage.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
304
Visual Basic 2010
Imports Imports Imports Imports Imports
System.Web System.Web.Services System.Web.Services.Protocols System.Data System.Data.OleDb
_ _ _ Public Class Service Inherits System.Web.Services.WebService Dim Dim Dim Dim
Connexion As String ConnexionOLE As OleDbConnection = New OleDbConnection() da As OleDbDataAdapter ds As DataSet
Public Function AfficheTous() As DataSet Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ c:\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion da = New OleDbDataAdapter("Select * from T_TravailObjet", ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") Return ds End Function Public Function AfficheBiblio() As DataSet Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion da = New OleDbDataAdapter("Select * from T_TravailObjet where [LibelleObjet] „ =‘bibliothèque’", ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") Return ds End Function Public Function AfficheSQL(ByVal st As String) As DataSet Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ C:\\bestofgestion97.mdb" ConnexionOLE.ConnectionString = Connexion
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
305
da = New OleDbDataAdapter(st, ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") Return ds End Function End Class
Cliquez sur le bouton Démarrer le débogage pour lancer le service web. Une icône dans la barre de notification indique que le service web est actif (voir Figure 12.16) et une page web signale que trois méthodes sont accessibles dans le service (voir Figure 12.17). Figure 12.16 Dans cet exemple, le service web est accessible sur le port 1202. Figure 12.17 Les trois méthodes du service web.
Vous allez maintenant définir une application qui utilise les trois méthodes du service web précédent. Ouvrez une nouvelle instance de Visual Studio et lancez la commande Nouveau/Site web du menu Fichier. Choisissez .NET Framework 3.5 dans la première liste déroulante, sélectionnez le modèle Site Web ASP.NET, donnez le nom TestBDDistante2 à l’application et validez. Une fois que l’interface de l’application a été créée par Visual Studio.NET, cliquez du bouton droit sur l’entrée C:\…\TestBDDistante2 dans l’Explorateur de solutions et sélectionnez Ajouter une référence web dans le menu surgissant. Entrez l’adresse correspondant
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
306
Visual Basic 2010
au service web local créé précédemment dans la zone URL de la boîte de dialogue Ajouter une référence web et validez en cliquant sur Aller à. Quelques instants plus tard, les méthodes AfficheBiblio(), AfficheSQL() et AfficheTous() proposées par le service sont référencées dans la boîte de dialogue Ajouter une référence web (voir Figure 12.18). Figure 12.18 Service1 donne accès à trois méthodes.
Cliquez sur Ajouter une référence. L’Explorateur de solutions laisse apparaître le nouveau service (voir Figure 12.19). Figure 12.19 Le nouveau service est bien référencé dans l’application.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
307
En utilisant l’onglet Standard de la Boîte à outils, ajoutez trois boutons de commande et une zone de texte à la feuille de l’application. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant : Contrôle
Propriété
Valeur
Button1
Text
Affiche tous
Button2
Text
Affiche bibliothèques
Button3
Text
Exécute SQL
TextBox1
Text
Sélectionnez l’onglet Données dans la Boîte à outils et déposez un contrôle GridView sur la feuille de l’application. Une boîte de dialogue vous invite à définir la source des données à afficher. Appuyez sur la touche Échap du clavier : la définition de ce contrôle se fera dans le code. La fenêtre de conception doit à présent avoir l’allure de la Figure 12.20. Figure 12.20 La feuille de l’application, en mode Édition.
Double-cliquez sur une partie non occupée de la feuille de l’application et complétez la procédure Page_Load() comme suit :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
308
Visual Basic 2010
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) „ Handles Me.Load Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheTous GridView1.DataSource = ds GridView1.DataBind() End Sub
La première instruction donne accès au service web Service au travers de l’objet objds : Dim objds As New localhost.Service
Après avoir défini un objet DataSet ds, cet objet est initialisé grâce à la fonction AfficheTous du service web : Dim ds As DataSet ds = objds.AfficheTous
Il suffit maintenant de remplir le GridView de la feuille avec le DataSet ds : GridView1.DataSource = ds.Tables(0).DefaultView GridView1.DataBind()
Pour pouvoir définir l’objet DataSet ds, vous devez insérer une instruction Imports au début du code : Imports System.Data
Il ne reste plus qu’à donner vie aux boutons de commande et à la zone de texte pour terminer l’application. Fermez la fenêtre du navigateur pour revenir à l’environnement de développement. Double-cliquez sur le premier bouton de commande et complétez la procédure Button1_ Click() comme suit : Protected Sub Button1_Click(ByVal sender As Object, ByVal e As System.EventArgs) „ Handles Button1.Click Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheTous GridView1.DataSource = ds GridView1.DataBind() End Sub
Les instructions de cette procédure sont les mêmes que celles exécutées au démarrage de l’application. Elles affichent donc la totalité des enregistrements de la table.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
309
Double-cliquez sur le deuxième bouton de commande et complétez la procédure Button2_ Click() comme suit : Protected Sub Button2_Click(ByVal sender As Object, ByVal e As System.EventArgs) „ Handles Button2.Click Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheBiblio GridView1.DataSource = ds.Tables(0).DefaultView GridView1.DataBind() End Sub
Cette procédure est analogue à Button1_Click(), à ceci près que le DataSet est initialisé avec la fonction web AfficheBiblio() : ds = objds.AfficheBiblio
Enfin, double-cliquez sur le troisième bouton de commande et complétez la procédure Button3_Click() comme suit : Protected Sub Button3_Click(ByVal sender As Object, ByVal e As System.EventArgs) „ Handles Button3.Click Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSQL(TextBox1.Text) GridView1.DataSource = ds.Tables(0).DefaultView GridView1.DataBind() End Sub
Cette procédure est analogue aux deux précédentes, mais elle remplit le contrôle DataSet ds en interrogeant la fonction AfficheSQL() (l’argument fourni à la fonction AfficheSQL() est le contenu du TextBox) : ds = objds.AfficheSQL(TextBox1.Text)
Voici le listing complet de l’application. Vous le trouverez, ainsi que les fichiers complémentaires, dans le dossier TestBDDistante2. Imports System.Data Partial Class _Default Inherits System.Web.UI.Page Protected Sub Button1_Click(ByVal sender As Object, ByVal e As System. „ EventArgs) Handles Button1.Click Dim objds As New localhost.Service
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
310
Visual Basic 2010
Dim ds As DataSet ds = objds.AfficheTous GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) „ Handles Me.Load Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheTous GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub Button2_Click(ByVal sender As Object, ByVal e As System. „ EventArgs) Handles Button2.Click Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheBiblio GridView1.DataSource = ds.Tables(0).DefaultView GridView1.DataBind() End Sub Protected Sub Button3_Click(ByVal sender As Object, ByVal e As System. „ EventArgs) Handles Button3.Click Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSQL(TextBox1.Text) GridView1.DataSource = ds.Tables(0).DefaultView GridView1.DataBind() End Sub End Class
Appuyez sur la touche F5 pour exécuter l’application. Les Figures 12.21, 12.22 et 12.23 représentent le formulaire web après avoir appuyé (respectivement) sur les boutons Affiche tous, Affiche Bibliothèques et Exécute SQL. Dans le dernier cas, la requête SQL exécutée était la suivante : select * from T_TravailObjet where [IdTravail]=29
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
311
Figure 12.21 Tous les enregistrements de la table Catégories s’affichent.
Figure 12.22 Seuls les enregistrements dont le champ LibelleObjet vaut «bibliothèque» s’affichent.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
312
Visual Basic 2010
Figure 12.23 Seuls les enregistrements correspondant à la requête SQL apparaissent.
Accès à une base de données via LINQ Les bases de données ADO.NET, SQL Server et SQL Server Express peuvent être accédées par l’intermédiaire de requêtes LINQ. Voici, à titre d’exemple une requête permettant de sélectionner des enregistrements dans une table d’une base de données ADO.Net : Dim objets As DataTable = ds.Tables("T_TravailObjet") Dim query = _ From objet In objets.AsEnumerable() _ Where objet.Field(Of String)("LibelleObjet") = "bibliothèque" _ Select New With { _ .IDTravailObjet = objet.Field(Of Integer)("IDTravailObjet"), _ .IDTravail = objet.Field(Of Integer)("IDTravail"), _ .Nombre = objet.Field(Of Integer)("Nombre") }
Cette requête crée un iEnumerable contenant les données IDTravailObjet, IDTravail et Nombre. Ces données proviennent des champs IDTravailObjet, IDTravail et Nombre de la table T_TravailObjet. Seuls les enregistrements dont le champ LibelleObjet vaut "Bibliothèque" sont sélectionnés par la requête.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 12
Bases de données
313
Vous vous reporterez à la section intitulée "LINQ to DataSet", au Chapitre 27 pour avoir des informations complémentaire sur l’interrogation de bases de données ADO.NET. Dans cet autre exemple, la table interrogée est de type SQL Server : Dim query = From orde In db.Orders Order By orde.CustomerID Select orde.CustomerID, orde.OrderID
La requête LINQ extrait les champs CustomerID et OrderID de la table Orders et les classe par ordre croissant sur le champ CustomerID. Pour avoir des informations complémentaires concernant le requêtage LINQ des bases de données SQL Server et SQL Server Express, vous consulterez la section intitulée "LINQ to SQL" au Chapitre 27.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
13 Traitements multitâches/ multicœurs Il y a quelques années, on mesurait la puissance de calcul brut d’un ordinateur à la fréquence de son microprocesseur. Aujourd’hui, cette fréquence se situe la plupart du temps autour des 3 GHz. En l’état actuel de la technologie, cette barrière a du mal à être franchie, essentiellement pour des raisons de dissipation thermique. Pour augmenter la puissance de calcul, les fondeurs ont eu l’idée de loger plusieurs puces (ou cœurs) dans un même chip. Cette solution, fort prometteuse, n’est encore qu’assez mal utilisée par les éditeurs de logiciels qui, bien souvent, se contentent d’utiliser des instructions traditionnelles, de type monocœur. Heureusement, avec Visual Basic 2010, la mise en place d’un traitement multitâches/ multicœurs est un vrai jeu d’enfant. Cette facilité de mise en œuvre découle de plusieurs techniques :
∑
Le composant BackgroundWorker : grâce à lui, un traitement consommateur de temps machine peut être implémenté dans un thread qui s’exécutera en tâche de fond. Cela évite de "geler" la machine si un long calcul doit être effectué, et le programme donne une impression de fluidité à ses utilisateurs.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
316
Visual Basic 2010
∑
Le .NET Framework 4 fournit de nouvelles bibliothèques de classes. En particulier, la classe Parallel qui permet de répartir l’exécution de boucles For et For Each sur les différents cœurs disponibles.
∑
Le concept de tâches, lié à la classe Task, permet de gérer finement l’exécution de code par les différents cœurs disponibles.
Deux applications illustrent le composant BackgroundWorker sont développées dans ce chapitre. La première montre comment effectuer un calcul "lourd" en tâche de fond. La seconde propose deux techniques pour exécuter une application externe : en tâche de fond ou en tâche principale. Deux applications illustrent l’utilisation de l’instruction Parallel.For et montrent sa supériorité par rapport à une classique structure For Next. Enfin, une application montre comment affecter l’exécution de blocs de code à certains cœurs du processeur utilisé. Les instructions de cette application n’ont aucune incidence sur un processeur doté d’un seul cœur.
Exécution d’un calcul en tâche de fond Cette première application va calculer une factorielle en tâche de fond. Lancez commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom Multitâche au projet et cliquez sur OK. Ajoutez deux Label, un TextBox, deux Button, un ProgressBar et un Background Worker (ce contrôle se trouve sous l’onglet Composants de la Boîte à outils) pour obtenir l’effet visuel de la Figure 13.1. Figure 13.1 Agencement de l’application de traitement multitâche.
Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Traitements multitâches/multicœurs
317
Contrôle
Propriété
Valeur
Form1
Text
Traitement multitâche
Label1
Text
Entrez un nombre
TextBox1
Text
20
Button1
Text
Calculer
Button2
Text
Arrêter
Label2
Text
Entrez un nombre et cliquez sur Calculer
BackgroundWorker1
Name
bgw
BackgroundWorker1
WorkerReportsProgress
True
Double-cliquez sur le bouton Calculer et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click If CInt(TextBox1.Text) > 20 Or CInt(TextBox1.Text) < 1 Then MsgBox("Le nombre doit être compris entre 1 et 20") Else Label2.Text = "Calcul en cours..." Button1.Enabled = False bgw.RunWorkerAsync(CInt(TextBox1.Text)) End If End Sub
La première instruction teste la valeur entrée par l’utilisateur dans la zone de texte. Pour éviter un dépassement dans le calcul de la factorielle, cette valeur doit être comprise entre 1 et 20. Dans le cas contraire, un message d’erreur apparaît : If CInt(TextBox1.Text) > 20 Or CInt(TextBox1.Text) < 1 Then MsgBox("Le nombre doit être compris entre 1 et 20")
Si la valeur entrée est comprise entre 1 et 20, trois actions sont effectuées. Dans un premier temps, un message s’affiche dans la fenêtre par l’intermédiaire du contrôle Label2 : Else Label2.Text = "Calcul en cours..."
Dans un deuxième temps, le bouton Calculer est désactivé pour éviter que l’utilisateur n’appuie dessus avant la fin du calcul : Button1.Enabled = False
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
318
Visual Basic 2010
Enfin, dans un troisième temps, le processus asynchrone démarre : bgw.RunWorkerAsync(CInt(TextBox1.Text))
Cette dernière instruction génère un événement Dowork rattaché à l’objet Background Worker bgw. Nous allons donc définir la procédure événementielle bgw_Dowork(). Cliquez sur l’icône bgw (en dessous de la fenêtre de l’application), affichez les événements dans la fenêtre des propriétés et double-cliquez sur la propriété DoWork pour accéder à la procédure bgw_DoWork(). Complétez cette procédure comme suit : Private Sub bgw_DoWork(ByVal sender As System.Object, ByVal e As System. „ ComponentModel.DoWorkEventArgs) Handles bgw.DoWork Dim worker As BackgroundWorker = CType(sender, BackgroundWorker) e.Result = factorielle(e.Argument, worker, e) End Sub
La première instruction récupère l’objet BackgroundWorker à l’origine de cet événement : Dim worker As BackgroundWorker = CType(sender, BackgroundWorker)
La seconde instruction appelle la fonction Factorielle() et stocke la valeur renvoyée dans la propriété Result de l’objet DoWorkEventArgs : e.Result = factorielle(e.Argument, worker, e)
L’étape suivante consiste à définir la fonction Factorielle() : Function factorielle(ByVal n As Integer, ByVal worker As BackgroundWorker, „ ByVal e As DoWorkEventArgs) As Long Dim i As Long Dim percentcomplete As Integer resultat = 1 For i = 1 To n resultat = i * resultat percentcomplete = CSng(i) / CSng(n) * 100 worker.ReportProgress(percentcomplete) System.Threading.Thread.Sleep(150) Next (i) Return resultat End Function
Après avoir déclaré l’index de la boucle de calcul, la variable représentant l’état d’avancement dans le calcul et la variable dans laquelle le résultat va être stocké : Dim i As Long Dim percentcomplete As Integer resultat = 1
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Traitements multitâches/multicœurs
319
le calcul récursif de la factorielle prend place : For i = 1 To n resultat = i * resultat percentcomplete = CSng(i) / CSng(n) * 100 worker.ReportProgress(percentcomplete) System.Threading.Thread.Sleep(150) Next (i)
Remarquez les deux dernières instructions de la boucle :
∑
worker.ReportProgress(percentcomplete) affiche l’état d’avancement du calcul. Cette instruction va déclencher l’événement ProgressChanged de l’objet BackgroundWorker.
∑
System.Threading.Thread.Sleep(150) introduit une pause de 150 millisecondes entre chacune des étapes du calcul. Cela évite un avancement trop rapide de la barre de progression.
L’étape suivante consiste à définir la procédure événementielle bgw_ProgressChanged(). Cliquez sur l’icône bgw (en dessous de la fenêtre de l’application), affichez les événements dans la fenêtre des propriétés et double-cliquez sur la propriété ProgressChanged pour accéder à la procédure bgw_ProgressChanged(). Complétez cette procédure comme suit : Private Sub bgw_ProgressChanged(ByVal sender As System.Object, ByVal e As „ System.ComponentModel.ProgressChangedEventArgs) Handles bgw.ProgressChanged Me.ProgressBar1.Value = e. Private Sub bgw_ProgressChanged(ByVal sender „ As System.Object, ByVal e As System.ComponentModel.ProgressChangedEventArgs) „ Handles bgw.ProgressChanged Me.ProgressBar1.Value = e.ProgressPercentage End Sub End Sub
L’unique instruction de cette procédure met à jour la barre de progression en utilisant la variable ProgressPercentage. Nous allons maintenant définir la procédure à exécuter en fin de calcul. Cliquez sur l’icône bgw (en dessous de la fenêtre de l’application), affichez les événements dans la fenêtre des propriétés et double-cliquez sur la propriété RunWorkerCompleted pour accéder à la procédure bgw_ RunWorkerCompleted(). Complétez cette procédure comme suit : Private Sub bgw_RunWorkerCompleted(ByVal sender As System.Object, ByVal e As „ System.ComponentModel.RunWorkerCompletedEventArgs) Handles bgw.RunWorkerCompleted Button1.Enabled = True Label2.Text = "Factorielle(" + TextBox1.Text + ") = " + Str(resultat) End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
320
Visual Basic 2010
Cette procédure active à nouveau le bouton Calculer et affiche le résultat du calcul dans le contrôle Label2. Pour terminer, double-cliquez sur le bouton Arrêter et ajoutez une instruction End dans la procédure Button2_Click : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button2.Click End End Sub
L’application est maintenant totalement opérationnelle. Vous pouvez l’exécuter en appuyant sur la touche F5. Entrez un nombre compris entre 1 et 20 dans la zone de texte et cliquez sur le bouton Calculer. Vous pouvez voir l’avancement de la barre de progression – en ayant bien en tête que les calculs sont effectués dans un thread autre que celui de l’application (voir Figure 13.2). Figure 13.2 L’application Traitement multitâche en cours d’exécution.
Voici le code complet de l’application. Vous trouverez les fichiers correspondants dans le dossier multitâche. Imports System.ComponentModel Public Class Form1 Dim longueur As Integer = 0 Dim resultat As Long = 0 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click If CInt(TextBox1.Text) > 20 Or CInt(TextBox1.Text) < 1 Then MsgBox("Le nombre doit être compris entre 1 et 20") Else Label2.Text = "Calcul en cours..." Button1.Enabled = False
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Traitements multitâches/multicœurs
321
bgw.RunWorkerAsync(CInt(TextBox1.Text)) End If End Sub Private Sub bgw_DoWork(ByVal sender As System.Object, ByVal e As System. „ ComponentModel.DoWorkEventArgs) Handles bgw.DoWork Dim worker As BackgroundWorker = CType(sender, BackgroundWorker) e.Result = factorielle(e.Argument, worker, e) End Sub Function factorielle(ByVal n As Integer, ByVal worker As BackgroundWorker, „ ByVal e As DoWorkEventArgs) As Long Dim i As Long Dim percentcomplete As Integer resultat = 1 For i = 1 To n resultat = i * resultat percentcomplete = CSng(i) / CSng(n) * 100 worker.ReportProgress(percentcomplete) System.Threading.Thread.Sleep(150) Next (i) Return resultat End Function Private Sub bgw_ProgressChanged(ByVal sender As System.Object, ByVal e As „ System.ComponentModel.ProgressChangedEventArgs) Handles bgw.ProgressChanged Me.ProgressBar1.Value = e.ProgressPercentage End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click End End Sub Private Sub bgw_RunWorkerCompleted(ByVal sender As System.Object, ByVal „ e As System.ComponentModel.RunWorkerCompletedEventArgs) Handles bgw. „ RunWorkerCompleted Button1.Enabled = True Label2.Text = "Factorielle(" + TextBox1.Text + ") = " + Str(resultat) End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
322
Visual Basic 2010
Exécution d’une application externe Il est parfois utile d’appeler une application exécutable dans un projet Visual Basic. La technique à utiliser diffère selon que vous vouliez lancer l’application en tant que processus ou attendre sa fermeture pour reprendre le contrôle. Définissez un nouveau projet fondé sur le modèle Application Windows Forms et donnezlui le nom LanceBN. Insérez un TextBox et deux Button sur la feuille du projet. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant : Contrôle
Propriété
Valeur
Form1
Text
Lanceur d’applications
TextBox1
Text
Notepad.exe
Button1
Text
Lancer
Button2
Text
Lancer et attendre
Modifiez l’emplacement et les dimensions de ces contrôles de sorte que la feuille de l’application ressemble à la Figure 13.3. Figure 13.3 La feuille de l’application, en mode Édition.
Double-cliquez sur le bouton Lancer et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click Process.Start(TextBox1.Text) MessageBox.Show("L’application a été lancée", "Information") End Sub
La classe Process permet de démarrer des applications en tant que processus, donc sans bloquer le programme qui les active. Consultez la documentation en ligne pour connaître les nombreuses méthodes de cette classe.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Traitements multitâches/multicœurs
323
La première instruction lance le processus dont le nom est spécifié dans la zone de texte TextBox1 : Process.Start(TextBox1.Text)
La seconde instruction affiche une boîte de message indiquant que l’application a été lancée. Étant donné que le lancement d’un processus ne bloque pas l’ordinateur, cette boîte de message apparaît immédiatement : MessageBox.Show("L’application a été lancée", "Information")
Double-cliquez sur le bouton Lancer et attendre, et complétez la procédure Button2_ Click() comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button2.Click Shell(TextBox1.Text, AppWinStyle.NormalFocus, True) MessageBox.Show("L’application vient d’être fermée", "Information") End Sub
La première instruction utilise la procédure Shell() pour lancer l’application spécifiée dans la zone de texte : Shell(TextBox1.Text, AppWinStyle.NormalFocus, True)
Le premier argument de la procédure précise le nom de l’application à lancer. Ce nom doit être un chemin complet si l’application ne se trouve pas dans le dossier d’installation de Windows ou dans le dossier système. Le deuxième argument indique l’état de l’application. Il peut être égal à l’une des valeurs suivantes :
∑ ∑ ∑ ∑ ∑ ∑
AppWinStyle.Hide. Fenêtre cachée ayant le focus. AppWinStyle.NormalFocus. Fenêtre normale ayant le focus. AppWinStyle.MinimizedFocus. Fenêtre minimisée dans la barre des tâches ayant le
focus. AppWinStyle.MaximizedFocus. Fenêtre ouverte et maximisée. AppWinStyle.NormalNoFocus. Fenêtre normale n’ayant pas le focus. AppWinStyle.MinimizedNoFocus. Fenêtre minimisée dans la barre des tâches n’ayant
pas le focus.
Enfin, le troisième argument indique si le programme parent Visual Basic doit attendre (True) ou ne pas attendre (False) la fin de l’application lancée pour poursuivre son exécution. Si ce paramètre n’est pas spécifié, la fin de l’application n’est pas attendue.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
324
Visual Basic 2010
La deuxième instruction affiche un message qui précise que l’application vient d’être fermée. Ce message ne s’affiche qu’après la fermeture de l’application, car le troisième paramètre de la fonction Shell() vaut True : MessageBox.Show("L’application vient d’être fermée", "Information")
Lorsque l’instruction Shell ne contient que deux paramètres, l’application est lancée et le contrôle est immédiatement redonné à l’instruction suivante. Ce comportement fait ressembler la procédure Shell() au démarrage d’un processus. Cependant, les possibilités des processus sont bien plus nombreuses. Pour en savoir plus à ce sujet, consultez la documentation de Visual Basic.
Info
Voici le listing complet de l’application. Le projet se trouve dans le dossier LanceBN après installation des sources de l’ouvrage. Public Class Form1 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click Process.Start(TextBox1.Text) MessageBox.Show("L’application a été lancée", "Information") End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click Shell(TextBox1.Text, AppWinStyle.NormalFocus, True) MessageBox.Show("L’application vient d’être fermée", "Information") End Sub End
Parallélisation des boucles La classe Parallel du .NET Framework 4 permet de répartir l’exécution de boucles For et For Each sur les différents cœurs disponibles. Pour illustrer cette classe, nous allons développer une application console qui calcule un million de racines carrées, dans un premier temps à l’aide d’une boucle For Next conventionnelle, puis à l’aide d’une boucle P arallel. For. Les temps de calcul s’afficheront à la suite des deux variantes du code. Lancez la commande Nouveau/Projet dans le menu Fichier. Sélectionnez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Traitements multitâches/multicœurs
325
gauche. Cliquez sur Application console, donnez le nom ParallelFor1 à l’application et validez en cliquant sur OK. Complétez le code avec les instructions suivantes (cette application se trouve dans le dossier Projects\ParallelFor1 des sources de l’ouvrage après leur installation). Imports System.Threading Imports System.Threading.Tasks Module Module1 Function Calcul(ByVal i As Integer, ByVal result As String) As Boolean result = "Racine carrée : " + Math.Sqrt(i).ToString() Return True End Function Sub Main() Dim result As String Dim debut As TimeSpan Console.WriteLine("Début du calcul simple thread") debut = DateTime.Now.TimeOfDay For i = 0 To 10000000 Calcul(i,result) Next Console.WriteLine("Fin du calcul simple thread") Console.WriteLine(DateTime.Now.TimeOfDay - debut) Console.WriteLine() Console.WriteLine("Début du calcul multithread") debut = DateTime.Now.TimeOfDay Parallel.For(0, 10000000, Function(i) Calcul(i, result)) Console.WriteLine("Fin du calcul multithread") Console.WriteLine(DateTime.Now.TimeOfDay - debut) Console.ReadKey() End Sub End Module
Examinons le code. Après avoir déclaré les deux espaces de noms nécessaires à l’exécution multithreads : Imports System.Threading Imports System.Threading.Tasks
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
326
Visual Basic 2010
Le bloc de code suivant définit la fonction Calcul(), responsable du calcul des 1 million de racines carrées : Function Calcul(ByVal i As Integer, ByVal result As String) As Boolean result = "Racine carrée : " + Math.Sqrt(i).ToString() Return True End Function
La procédure Main() se décompose en quatre blocs. Le premier bloc définit les variables utilisées dans la procédure : Dim result As String Dim debut As TimeSpan
Le deuxième bloc effectue une boucle For Next traditionnelle qui appelle la fonction Calcul() 1 million de fois. Après avoir affiché un message pour indiquer le début du calcul : Console.WriteLine("Début du calcul simple thread")
L’heure système est mémorisée dans la variable debut : debut = DateTime.Now.TimeOfDay
Puis le calcul est lancé : For i = 0 To 10000000 Calcul(i,result) Next
Lorsque la boucle For Next est terminée, une instruction WriteLine indique la fin du calcul : Console.WriteLine("Fin du calcul simple thread")
Et une autre affiche le temps nécessaire pour effectuer le calcul : Console.WriteLine(DateTime.Now.TimeOfDay - debut)
Le troisième bloc d’instructions effectue le même calcul en mode multithreads. Après avoir indiqué le début du calcul et mémorisé l’heure système : Console.WriteLine("Début du calcul multithread") debut = DateTime.Now.TimeOfDay
La fonction Calcul() est appelée un million de fois : Parallel.For(0, 10000000, Function(i) Calcul(i, result))
Remarquez la syntaxe particulière de cette instruction. Les deux premiers paramètres font référence aux valeurs minimale et maximale de l’index. Le troisième paramètre spécifie la fonction à exécuter et les paramètres qui doivent lui être passés.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Traitements multitâches/multicœurs
327
Lorsque l’exécution de l’instruction Parallel.For est terminée, un message apparaît dans la console, accompagné du temps de calcul : Console.WriteLine("Fin du calcul multithread") Console.WriteLine(DateTime.Now.TimeOfDay - debut)
La dernière instruction attend que l’utilisateur appuie sur une touche du clavier pour mettre fin au programme : Console.ReadKey()
La Figure 13.4 représente le résultat de ce programme exécuté sur un AMD Phenom 9850 cadencé à 2,5 GHz, doté de 3 Go de RAM DDR2 et fonctionnant sous Windows 7 32 bits. Figure 13.4 Le traitement parallèle est effectivement plus rapide sur un multicœur.
Les Figures 13.5 et 13.6 représentent les deux phases d’exécution du programme. Figure 13.5 Le deuxième cœur est utilisé pour effectuer le calcul.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
328
Visual Basic 2010
Figure 13.6 Les quatre cœurs effectuent le calcul, améliorant ainsi les performances.
Voici un deuxième exemple qui met en évidence la supériorité de la programmation parallèle lorsqu’il est exécuté sur un ordinateur muni de plusieurs cœurs. Ce code est issu de la librairie en ligne MSDN, page http://msdn.microsoft.com/en-us/library/dd460713. aspx. Il consiste en la multiplication de matrices de 180 colonnes et 2 000 lignes. Vous trouverez plusieurs autres exemples de programmation parallèle sur cette page. N’hésitez pas à vous y reporter. Lancez la commande Nouveau/Projet dans le menu Fichier. Sélectionnez .NET Framework 4 dans la liste déroulante Framework, cliquez sur Application console, donnez le nom ParallelFor2 à l’application et validez en cliquant sur OK. Complétez le code avec les instructions suivantes (cette application se trouve dans le dossier Projects\ParallelFor2 des sources de l’ouvrage après leur installation) : Imports System.Threading.Tasks Module Module1 Sub MultiplyMatricesSequential(ByVal matA As Double(,), ByVal matB As Double(,), „ ByVal result As Double(,)) Dim matACols As Integer = matA.GetLength(1) Dim matBCols As Integer = matB.GetLength(1) Dim matARows As Integer = matA.GetLength(0) For i As Integer = 0 To matARows - 1 For j As Integer = 0 To matBCols - 1
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Traitements multitâches/multicœurs
329
For k As Integer = 0 To matACols - 1 result(i, j) += matA(i, k) * matB(k, j) Next Next Next End Sub
Private Sub MultiplyMatricesParallel(ByVal matA As Double(,), ByVal matB „ As Double(,), ByVal result As Double(,)) Dim matACols As Integer = matA.GetLength(1) Dim matBCols As Integer = matB.GetLength(1) Dim matARows As Integer = matA.GetLength(0) ‘ Multiplication de matrices ‘ Parallélisation de la boucle externe Parallel.For(0, matARows, Sub(i) For j As Integer = 0 To matBCols - 1 ‘ Utilisation d’une variable temporaire pour améliorer les performances du traitement parallèle Dim temp As Double = 0 For k As Integer = 0 To matACols - 1 temp += matA(i, k) * matB(k, j) Next result(i, j) += temp Next End Sub) End Sub Sub Main() ‘ Définition des matrices. Utiliser des valeurs de lignes et de colonnes plus élevées pour mettre en évidence la supériorité du traitement parallèle Dim colCount As Integer = 180 Dim rowCount As Integer = 2000 Dim colCount2 As Integer = 270 Dim m1 As Double(,) = InitializeMatrix(rowCount, colCount) Dim m2 As Double(,) = InitializeMatrix(colCount, colCount2) Dim result As Double(,) = New Double(rowCount - 1, colCount2 - 1) {} ‘ Traitement séquentiel Console.WriteLine("Exécution de la boucle séquentielle ...") Dim stopwatch As New Stopwatch() stopwatch.Start()
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
330
Visual Basic 2010
MultiplyMatricesSequential(m1, m2, result) stopwatch.[Stop]() Console.WriteLine("Temps nécessaire pour exécuter la boucle séquentielle en „ millisecondes : {0}", stopwatch.ElapsedMilliseconds) ‘ RAZ tu timer et de la matrice des résultats stopwatch.Reset() result = New Double(rowCount - 1, colCount2 - 1) {} ‘ Traitement parallèle Console.WriteLine() Console.WriteLine("Exécution de la boucle parallèle ...") stopwatch.Start() MultiplyMatricesParallel(m1, m2, result) stopwatch.[Stop]() Console.WriteLine("Temps nécessaire pour exécuter la boucle séquentielle en „ millisecondes : {0}", stopwatch.ElapsedMilliseconds) ‘ Attente d’une action de l’utilisateur pour fermer l’application Console.WriteLine() Console.WriteLine("Appuyez sur une touche pour fermer l’application.") Console.ReadKey() End Sub Function InitializeMatrix(ByVal rows As Integer, ByVal cols As Integer) As Double(,) Dim matrix As Double(,) = New Double(rows - 1, cols - 1) {} Dim r As New Random() For i As Integer = 0 To rows - 1 For j As Integer = 0 To cols - 1 matrix(i, j) = r.[Next](100) Next Next Return matrix End Function End Module
À titre d’exemple, la Figure 13.7 représente le résultat de l’exécution de ce code sur un ordinateur à base d’AMD Phenom 9850 cadencé à 2,5 GHz, doté de 4 Go de RAM DDR2 et fonctionnant sous Windows 7 32 bits.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Traitements multitâches/multicœurs
331
Figure 13.7 L’exécution multicœur montre clairement sa supériorité.
Examinons le code. Les premières lignes de la procédure Main() définissent les variables utilisées dans le code : Dim Dim Dim Dim Dim Dim
colCount As Integer = 180 rowCount As Integer = 2000 colCount2 As Integer = 270 m1 As Double(,) = InitializeMatrix(rowCount, colCount) m2 As Double(,) = InitializeMatrix(colCount, colCount2) result As Double(,) = New Double(rowCount - 1, colCount2 - 1) {}
Les matrices m1 et m2 sont initialisées à l’aide de la procédure InitializeMatrix(), que nous décrirons un peu plus bas. Le bloc d’instructions suivant lance le calcul séquentiel : Console.WriteLine("Exécution de la boucle séquentielle ...") Dim stopwatch As New Stopwatch() stopwatch.Start() MultiplyMatricesSequential(m1, m2, result) stopwatch.[Stop]() Console.WriteLine("Temps nécessaire pour exécuter la boucle séquentielle en „ millisecondes : {0}", stopwatch.ElapsedMilliseconds)
Remarquez l’utilisation de l’objet stopwatch de type StopWatch, des méthodes Start() et Stop() et de la propriété ElapsedMilliseconds pour obtenir le temps nécessaire au calcul. Le code responsable de la multiplication des matrices se trouve dans la procédure MultiplyMatricesSequential(). Le bloc d’instructions suivant lance le calcul parallèle : Console.WriteLine() Console.WriteLine("Exécution de la boucle parallèle ...")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
332
Visual Basic 2010
stopwatch.Start() MultiplyMatricesParallel(m1, m2, result) stopwatch.[Stop]() Console.WriteLine("Temps nécessaire pour exécuter la boucle séquentielle en „ millisecondes : {0}", stopwatch.ElapsedMilliseconds)
Le code responsable de la multiplication des matrices se trouve dans la procédure MultiplyMatricesParallel(). Ici aussi, le temps de calcul est obtenu à l’aide de l’objet StopWatch stopwatch, manipulé par les procédures Start() et Stop() et interrogé par la propriété ElapsedMilliseconds. La procédure InitializeMatrix() est responsable de l’initialisation des matrices m1 et m2. Elle se contente d’insérer des nombres aléatoires dans chaque cellule de la matrice : Function InitializeMatrix(ByVal rows As Integer, ByVal cols As Integer) As Double(,) Dim matrix As Double(,) = New Double(rows - 1, cols - 1) {} Dim r As New Random() For i As Integer = 0 To rows - 1 For j As Integer = 0 To cols - 1 matrix(i, j) = r.[Next](100) Next Next Return matrix End Function
La procédure MultiplyMatricesSequential() effectue la multiplication des matrices passées en argument à l’aide de trois boucles For Next imbriquées : Sub MultiplyMatricesSequential(ByVal matA As Double(,), ByVal matB As Double(,), „ ByVal result As Double(,)) Dim matACols As Integer = matA.GetLength(1) Dim matBCols As Integer = matB.GetLength(1) Dim matARows As Integer = matA.GetLength(0) For i As Integer = 0 To matARows - 1 For j As Integer = 0 To matBCols - 1 For k As Integer = 0 To matACols - 1 result(i, j) += matA(i, k) * matB(k, j) Next Next Next End Sub
Enfin, la procédure MultiplyMatricesParallel() utilise une technique similaire, à ceci près que la boucle la plus extérieure est exécutée dans une instruction Parallel.For :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Traitements multitâches/multicœurs
333
Private Sub MultiplyMatricesParallel(ByVal matA As Double(,), ByVal matB As Double(,), ByVal result As Double(,)) Dim matACols As Integer = matA.GetLength(1) Dim matBCols As Integer = matB.GetLength(1) Dim matARows As Integer = matA.GetLength(0) ‘ Multiplication de matrices ‘ Parallélisation de la boucle externe Parallel.For(0, matARows, Sub(i) For j As Integer = 0 To matBCols - 1 ‘ Utilisation d’une variable temporaire pour améliorer „ les performances du traitement parallèle Dim temp As Double = 0 For k As Integer = 0 To matACols - 1 temp += matA(i, k) * matB(k, j) Next result(i, j) += temp Next End Sub) End Sub
Utilisation de plusieurs cœurs à l’aide de tâches Une autre technique permet de maîtriser la gestion des cœurs. Reposant sur la définition de tâches via la TPL (Task Parallel Library), elle permet d’exécuter des traitements en parallèle sur les différents cœurs de la machine cible. De façon automatique et sans qu’aucune recompilation ne soit nécessaire, le runtime .NET 4 détermine le nombre de cœurs disponibles sur la machine cible et les gère transparente à travers le scheduler de la TPL. Les tâches peuvent être exécutées dans l’ordre voulu, et il est possible d’attendre la fin de l’exécution d’une tâche ou de toutes les tâches lancées. D’autre part, une tâche peut (ou non) retourner un résultat. Ces prouesses résident dans l’utilisation de l’espace de nom System.Threading.Tasks. Dans cette section, vous allez voir à quel point il est simple de créer de nouvelles tâches à l’aide de la méthode Task.Factory.StartNew() appliquée sur des objets Task de classe Task, et d’attendre la fin de leur exécution avec la méthode Task.WaitAll(). Lancez la commande Nouveau/Projet dans le menu Fichier. Sélectionnez .NET Framework 4 dans la liste déroulante Framework, cliquez sur Application console, donnez le nom taches à l’application et validez en cliquant sur OK. Complétez le code avec les instructions suivantes (cette application se trouve dans le dossier Projects\Taches des sources de l’ouvrage après leur installation) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
334
Visual Basic 2010
Imports System.Threading Imports System.Threading.Tasks Module Module1 Function Racine(ByVal a As Integer, ByRef ret As Double) As Boolean ret = Math.Sqrt(a) Return True End Function Sub Main() Dim Tasks(1) As Task Dim res1 As Integer = 0 Dim res2 As Integer = 0 Tasks(0) = Task.Factory.StartNew(Function() Racine(1233, res1)) Tasks(1) = Task.Factory.StartNew(Function() Racine(541, res2)) Task.WaitAll(Tasks) ‘attente de la fin des tâches Console.WriteLine("Les deux racines ont été calculées avec deux cœurs „ différents.") Console.ReadKey() End Sub End Module
Ce code calcule deux racines carrées en utilisant deux cœurs différents (bien entendu à condition que la machine cible soit dotée d’un processeur multicœur). Examinons le code. La procédure Main() commence par définir le tableau Tasks, composé de deux cellules de type Task, puis définit et initialise à 0 les variables Integer res1 et res2, dans lesquelles seront stockées les résultats des racines carrées : Dim Tasks(1) As Task Dim res1 As Integer = 0 Dim res2 As Integer = 0
Les deux instructions suivantes affectent aux cellules du tableau Tasks le calcul des racines carrées de 1233 et de 541. Cette affectation se fait via la création d’une nouvelle tâche (Task.Factory.StartNew()) qui exécute la fonction Racine() : Tasks(0) = Task.Factory.StartNew(Function() Racine(1233, res1)) Tasks(1) = Task.Factory.StartNew(Function() Racine(541, res2))
L’instruction suivante attend que les deux tâches aient entièrement été exécutées : Task.WaitAll(Tasks)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 13
Info
Traitements multitâches/multicœurs
335
La procédure WaitAll() est très utile. En effet, elle permet de s’assurer que l’exécution des tâches est terminée et que leur résultat (si résultat il y a) peut être récupéré. Parfois, il n’est pas possible de lancer toutes les tâches en parallèle, car l’exécution de certaines d’entre elles est conditionnée par le résultat d’une autre. Dans ce cas, vous utiliserez la méthode WaitAny() pour indiquer les tâches dont vous attendez le résultat : Task.WaitAny(tache1,…, tacheN)
Lorsque l’exécution des deux tâches est terminée, un message s’affiche dans la console et le programme se met en attente d’une touche clavier pour terminer son exécution : Console.WriteLine("Les deux racines ont été calculées avec deux cœurs différents.") Console.ReadKey()
La fonction Racine() admet deux paramètres : le nombre dont on désire calculer la racine et le résultat du calcul. Elle renvoie une valeur True lorsque le calcul est terminé : Function Racine(ByVal a As Integer, ByRef ret As Double) As Boolean ret = Math.Sqrt(a) Return True End Function
Pour avoir des informations complémentaires sur la programmation parallèle, consultez l’aide en ligne de Visual Basic 2010, en particulier les sections relatives aux classes P arallel et Task.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
14 Manipulation du Registre de Windows Depuis l’édition 95, Windows stocke les différents paramètres matériels et logiciels de l’ordinateur dans une gigantesque base de données appelée "Base du Registre" ou plus simplement "Registre". Cette base de données référence les paramètres concernant les éléments matériels de l’ordinateur ainsi que les paramètres relatifs à chacun des utilisateurs. Si vous n’êtes pas familier avec le Registre, consultez les trois premières sections de ce chapitre. Vous y apprendrez à utiliser l’Éditeur du Registre, vous ferez connaissance avec la structure hiérarchique du Registre et vous verrez comment réaliser des importations et exportations dans le Registre afin (respectivement) de lire et de modifier son contenu. Si vous savez comment manipuler le Registre, rendez-vous directement à la section intitulée "Visual Basic et le Registre". Vous pouvez également vous reporter au Chapitre 17 pour avoir un exemple concret d’utilisation du Registre.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
338
Visual Basic 2010
L’Éditeur du Registre Pour consulter le Registre, un outil appelé Éditeur du Registre est fourni avec Windows. Pour y accéder :
∑
Sous Windows 7 ou Vista : cliquez sur Démarrer, tapez regedit dans la zone de recherche rapide cliquez sur l’icône regedit, dans la partie supérieure du menu, puis confirmez votre action en cliquant sur Continuer.
∑
Sous Windows XP, lancez la commande Exécuter du menu Démarrer. Tapez regedit dans la zone de texte de la boîte de dialogue Exécuter et appuyez sur la touche Entrée.
Quelques instants plus tard, vous vous trouvez face à une fenêtre semblable à celle montrée à la Figure 14.1. Figure 14.1 La fenêtre de l’Éditeur du Registre.
L’Éditeur du Registre présente deux volets qui rappellent ceux de l’Explorateur de fichiers : à gauche, une arborescence rattachée au Poste de travail, à droite, le détail de l’élément sélectionné. Le Registre repose sur cinq catégories HKEYS (pour homekeys) qui apparaissent dans le volet gauche : HKEY_CLASSES_ROOT, HKEY_CURRENT_USER, HKEY_LOCAL_ MACHINE, HKEY_USERS et HKEY_CURRENT_CONFIG. Chaque catégorie est composée de plusieurs sous-catégories (clés) et d’éléments terminaux (valeurs) :
∑ ∑
Pour développer une catégorie, cliquez sur le signe + qui la précède. Pour replier une catégorie, cliquez sur le signe – qui la précède.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 14
∑
Manipulation du Registre de Windows
339
Pour visualiser les éléments terminaux rattachés à une clé, cliquez sur cette clé dans le volet gauche. Les différentes valeurs s’affichent dans le volet droit.
À la Figure 14.2, par exemple, les clés HKEY_LOCAL_MACHINE, Hardware et Description ont été développées, puis les valeurs de la clé System ont été visualisées en cliquant sur System. Figure 14.2 Un exemple de développement de l’arborescence du Registre.
Les valeurs peuvent être de l’un des types binaire, chaîne, DWORD (double mot), chaîne multiple ou chaîne extensible. La donnée affectée à une valeur apparaît dans la colonne Données, en regard du nom de la clé. Dans l’exemple de la Figure 14.2, plusieurs types de valeurs sont accessibles.
Modification du Registre Pour modifier la donnée affectée à une valeur, il suffit de double-cliquer dessus. Faites la modification souhaitée dans la zone de texte Données de la valeur, puis cliquez sur OK (voir Figure 14.3). Figure 14.3 Modification d’une valeur chaîne.
Pour ajouter une valeur, sélectionnez la clé parent dans le volet gauche, cliquez du bouton droit dans le volet droit et sélectionnez Nouveau/Valeur chaîne, Nouveau/Valeur binaire,
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
340
Visual Basic 2010
Nouveau/Valeur DWORD, Nouveau/Valeur de chaînes multiples ou Nouveau/Valeur de chaîne extensible selon le type de la valeur que vous souhaitez créer. Définissez le nom de la valeur et affectez-y la donnée de votre choix. Pour supprimer une valeur, cliquez dessus, puis appuyez sur la touche Suppr. La suppression se fait après confirmation. Pour ajouter une clé, sélectionnez la clé parente dans le volet gauche en cliquant sur son nom. Cliquez du bouton droit dans le volet droit et sélectionnez Nouveau, puis Clé dans le menu contextuel. La nouvelle clé apparaît dans le volet gauche. Son nom apparaît en surbrillance. Saisissez le nom souhaité, puis appuyez sur la touche Entrée pour le valider. À la Figure 14.4, la nouvelle clé a été créée après sélection de la clé Software. Figure 14.4 Création d’une nouvelle clé enfant de la clé Active Setup.
Pour supprimer une clé, cliquez sur son nom, puis sur la touche Suppr du clavier. La suppression se fait après confirmation.
Déplacements dans le Registre Vous l’avez vu, il suffit de cliquer sur les signes + et – pour déplier et replier les éléments de l’arborescence dans le volet gauche sur une clé pour en visualiser le contenu dans le volet droit. La souris étant un périphérique lent et imprécis, vous souhaiterez peut-être travailler dans le Registre en utilisant le clavier. Voici les principaux raccourcis utilisables. Raccourci
Effet
+
Déplie la clé en surbrillance.
–
Replie la clé en surbrillance.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 14
Manipulation du Registre de Windows
Raccourci
Effet
*
Développe toutes les entrées de l’arborescence.
Droite
Passe à la clé suivante, si nécessaire en développant l’arborescence.
Gauche
Passe à la clé précédente, si nécessaire en repliant l’arborescence.
PageSuivante
Déplace la surbrillance d’une page vers le bas.
PagePrécédente
Déplace la surbrillance d’une page vers le haut.
Origine
Déplace la surbrillance sur la première entrée (Poste de travail).
Fin
Déplace la surbrillance sur la dernière entrée.
ce Astu
341
Certaines branches du Registre sont très touffues. S’il vous arrive de vous perdre dans les arcanes du Registre, vous pouvez double-cliquer sur une des lignes en pointillés verticales pour retourner à la clé parent. Si vous avez développé de nombreuses clés, il suffit de quitter et de relancer l’Éditeur du Registre pour retrouver une configuration plus "propre" dans laquelle seules les six homekeys sont visibles.
Recherches dans le Registre En dépliant les homekeys du Registre, vous vous rendrez vite compte de son immensité. Pour vous aider à localiser telle ou telle clé, valeur ou donnée, vous utiliserez la commande de recherche. Lancez la commande Rechercher du menu Édition ou appuyez sur Ctrl+F. Désignez l’élément recherché dans la zone de texte Recherche, cochez une ou plusieurs cases dans le groupe d’options Regarder dans et cliquez sur le bouton Suivant (voir Figure 14.5). Pour trouver la prochaine occurrence de la recherche, lancez la commande Rechercher le suivant du menu Édition ou appuyez sur la touche F3. Figure 14.5 Recherche de la clé ACLFile.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
342
Visual Basic 2010
Structure du Registre Dans les lignes qui suivent, vous allez faire plus ample connaissance avec les six homekeys du Registre.
HKEY_CLASSES_ROOT La homekey HKEY_CLASSES_ROOT est chargée de la gestion des types de fichiers manipulés par Windows. C’est dans cette clé principale que sont définies les associations types de fichiers/applications. Supposons par exemple que vous ayez installé Word 2007 sur votre ordinateur. Cliquez sur la clé HKEY_CLASSES_ROOT\.docx. La valeur Défaut contient la donnée Word.Document.12. Recherchez cette clé dans la ruche HKEY_CLASSES_ROOT. Développez les clés shell, Open et cliquez sur la clé command. La valeur (par défaut) contient le nom du programme associé aux fichiers d’extension .docx (voir Figure 14.6). Figure 14.6 Les fichiers d’extension .doc sont associés au programme winword.exe.
Lorsque vous double-cliquez sur un fichier dans le Poste de travail ou l’Explorateur, Windows effectue la démarche qui vient d’être décrite pour ouvrir le fichier dans l’application qui y est associée.
Info
Si vous modifiez la donnée affectée à la valeur shell\Open\command\Défaut, vous modifiez l’association correspondante.
HKEY_LOCAL_MACHINE La homekey HKEY_LOCAL_MACHINE recense :
∑
les paramètres relatifs au matériel installé dans l’ordinateur ;
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 14
∑
Manipulation du Registre de Windows
343
les paramètres relatifs aux applications installées.
Ces deux catégories sont communes à tous les utilisateurs. Lorsqu’une application a été paramétrée par un utilisateur donné, les paramètres personnels ainsi définis sont enregistrés dans la homekey HKEY_USERS.
HKEY_CURRENT_CONFIG La homekey HKEY_CURRENT_CONFIG fait partie de HKEY_LOCAL_MACHINE. Dans le cas d’un profil utilisateur unique, HKEY_CURRENT_CONFIG est le reflet exact de HKEY_LOCAL_MACHINE\Config\001. Si plusieurs profils ont été définis, HKEY_CURRENT_CONFIG contient les paramètres du seul utilisateur actif. Lorsque l’utilisateur modifie un paramètre, la modification est faite dans HKEY_ CURRENT_CONFIG. Si elle est jugée valide par Windows, elle est reportée dans HKEY_LOCAL_MACHINE.
HKEY_USERS La homekey HKEY_USERS recense les paramètres personnels à chaque utilisateur. La branche .DEFAULT contient les paramètres qui seront affectés par défaut aux nouveaux utilisateurs créés dans la fenêtre Comptes d’utilisateurs.
HKEY_CURRENT_USER La homekey HKEY_CURRENT_USER fait partie de HKEY_USERS. Dans le cas d’un profil utilisateur unique, elle est le reflet exact de HKEY_USERS. Si plusieurs profils ont été définis, elle contient les paramètres du seul utilisateur actif. Lorsque l’utilisateur modifie un paramètre, la modification est faite dans HKEY_CURRENT_ USER. Si elle est jugée valide par Windows, elle est reportée dans HKEY_USERS.
Importations et exportations dans le Registre Pour faciliter les manipulations dans le Registre ou pour permettre la modification du Registre par un public non averti, il est possible d’utiliser des fichiers REG. Ces fichiers texte ont une extension .reg. Ils peuvent être créés à partir de n’importe quel éditeur de texte, par exemple le Bloc-notes de Windows. Ces fichiers commencent toujours par le label Windows Registry Editor Version 5.00. Ils listent ensuite un ensemble de clés et de valeurs.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
344
Visual Basic 2010
Voici, à titre d’exemple, les premières lignes d’un fichier REG qui agit sur la branche [HKEY_CURRENT_USER\Control Panel\Desktop] du Registre : Windows Registry Editor Version 5.00 [HKEY_CURRENT_USER\Control Panel\Desktop] "ActiveWndTrkTimeout"=dword:00000000 "AutoEndTasks"="0" "CaretWidth"=dword:00000001 "CoolSwitch"="1" "CoolSwitchColumns"="7" "CoolSwitchRows"="3" "CursorBlinkRate"="530" "DragFullWindows"="1" "DragHeight"="4" "DragWidth"="4" "FontSmoothing"="2" "FontSmoothingType"=dword:00000001 "ForegroundFlashCount"=dword:00000003 "ForegroundLockTimeout"=dword:00030d40 "GridGranularity"="0" "HungAppTimeout"="5000" "LowPowerActive"="0" "LowPowerTimeOut"="0" "MenuShowDelay"="400" "PaintDesktopVersion"=dword:00000000 "PowerOffActive"="0" "PowerOffTimeOut"="0"
La première ligne indique que ce fichier a été créé avec l’Éditeur du Registre version 5, c’est-à-dire le programme REGEDIT.EXE fourni avec Windows 7, Vista et XP. Les lignes suivantes définissent des valeurs dans le Registre. Remarquez la syntaxe utilisée :
∑
Le nom de la clé contenant la valeur à créer/modifier est spécifié in extenso entre crochets, par exemple [HKEY_LOCAL_MACHINE\Software\CLASSES\CLSID\ {00030007-0000-0000-C000-000000000046}\Ole1Class].
∑
Le nom de la valeur est défini sur une autre ligne, suivi d’un signe = et de la donnée à y affecter entre guillemets (le nom "@" représente la valeur Défaut).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 14
Manipulation du Registre de Windows
345
Visualiser un fichier REG Pour visualiser un fichier REG, pointez dessus dans le Poste de travail ou l’Explorateur, cliquez du bouton droit et sélectionnez Édition dans le menu contextuel. Le fichier est ouvert dans le Bloc-notes.
Exécuter un fichier REG Pour exécuter un fichier REG, il suffit de double-cliquer dessus dans le Poste de travail ou l’Explorateur. Les clés et les valeurs spécifiées dans le fichier seront mises à jour/créées dans le Registre. Il est également possible d’utiliser la commande Importer un fichier du Registre, du menu Registre de l’Éditeur du Registre. Spécifiez le fichier à importer et validez pour inclure son contenu dans le Registre.
Créer un fichier REG Pour créer un fichier REG, vous pouvez saisir les différentes clés et valeurs à définir/modifier dans le Bloc-notes. Vous pouvez également exporter une partie du Registre de votre ordinateur. Pour cela, cliquez sur la clé que vous souhaitez sauvegarder (toutes les sous-clés et valeurs de cette clé seront sauvegardées), puis lancez la commande Exporter du menu Fichier (voir Figure 14.7). Figure 14.7 Exportation d’une branche du Registre.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
346
Visual Basic 2010
Cliquez si nécessaire sur l’option Branche sélectionnée dans le groupe Étendue de l’exportation, donnez un nom au fichier, choisissez sa destination, puis cliquez sur le bouton Enregistrer.
Exemple de fichier REG Supposons que vous souhaitiez modifier le délai d’affichage des éléments contenus dans le menu Démarrer. Vous devez pour cela définir la valeur chaîne MenuShowDelay dans la clé HKEY_CURRENT_USER\Control Panel\Desktop et lui affecter une valeur comprise entre 1 et 10. Cette valeur correspond au délai, en millisecondes, avant l’affichage des éléments contenus dans le menu Démarrer. Lancez le Bloc-notes à l’aide de la commande Programmes > Accessoires > Bloc-notes du menu Démarrer et saisissez les lignes suivantes : Windows Registry Editor version 5.00 [HKEY_CURRENT_USER\Control Panel\Desktop] "MenuShowDelay"="1"
Sauvegardez ce fichier en lui attribuant une extension .reg. Pour intégrer cette modification dans le Registre, il suffit de double-cliquer sur le fichier REG qui vient d’être créé. ntion Atte
La modification du Registre n’est prise en compte qu’après le redémarrage de l’ordinateur.
Visual Basic et le Registre .NET Framework dispose de deux classes en rapport avec le Registre : Registry et RegistryKey. Ces deux classes sont référencées dans le système Microsoft.Win32. Avant de les utiliser, il est donc nécessaire de spécifier la clause Imports suivante : Imports Microsoft.Win32
Les différentes homekeys du Registre sont accessibles à l’aide des membres de la classe Registry : Membre de la classe Registry
Homekey
ClassesRoot
HKEY_CLASSES_ROOT
CurrentConfig
HKEY_CURRENT_CONFIG
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 14
Manipulation du Registre de Windows
Membre de la classe Registry
Homekey
CurrentUser
HKEY_CURRENT_USER
DynData
HKEY_DYN_DATA
LocalMachine
HKEY_LOCAL_MACHINE
PerformanceData
HKEY_PERFORMANCE_DATA
Users
HKEY_USERS
347
Si, par exemple, vous voulez accéder à la homekey HKEY_USERS, vous utiliserez la syntaxe suivante : Dim rk as RegistryKey Rk = Registry.Users
Les méthodes de la classe RegistryKey permettent de lire, d’ajouter, de supprimer et de remplacer des clés dans le Registre. Vous utiliserez essentiellement les méthodes du tableau suivant : Méthode
Fonction
Close
Ferme la clé
CreateSubKey
Crée une clé (si elle n’existe pas) ou ouvre une clé (si elle existe)
DeleteSubKey
Supprime une clé
DeleteSubKeyTree
Supprime une clé ainsi que ses enfants
DeleteValue
Supprime une valeur dans une clé
GetSubKeyNames
Retourne un tableau de Strings qui contient le nom des sous-clés de la clé spécifiée
GetValue
Retourne la valeur spécifiée
GetValueNames
Retourne un tableau de Strings qui contient toutes les valeurs associées à la clé spécifiée
OpenSubKey
Ouvre la clé spécifiée
SetValue
Définit la valeur spécifiée
L’objet My.Computer.Registry propose plusieurs procédures et fonctions directement liées à la manipulation du Registre :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
348
Visual Basic 2010
Procédure
Utilité
My.Computer.Registry.CurrentUser.CreateSubKey()
Création d’une clé
My.Computer.Registry.SetValue()
Définition de la valeur d’une clé
My.Computer.Registry.GetValue()
Lecture d’une clé
My.Computer.Registry.CurrentUser.DeleteSubKey()
Suppression d’une clé
Pour en savoir plus sur l’utilisation de ces nouvelles procédures, consultez la section intitulée "L’espace de nom My" au Chapitre 3. Vous vous reporterez également au Chapitre 17 pour avoir un exemple concret de l’utilisation de quelques-unes de ces procédures.
Ajout, visualisation et suppression d’une clé Nous allons définir un projet qui manipule la clé HKEY_CURRENT_USER\Control Panel\ Desktop\MenuShowDelay. Cette clé détermine le délai d’affichage (en millisecondes) du menu Démarrer et de ses entrées. Lancez la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez le modèle Application Windows Forms, donnez le nom Registre à l’application et validez. Ajoutez quatre Button et un TextBox au projet. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant : Contrôle
Propriété
Valeur
Button1
Text
Menu Démarrer rapide
Button2
Text
Menu Démarrer lent
Button3
Text
Afficher la valeur de MenuShowDelay
Button4
Text
Supprimer la valeur MenuShowDelay
TextBox1
Text
Form1
Text
Manipulation du Registre
Modifiez l’emplacement et les dimensions de ces contrôles de sorte que la feuille de l’application ressemble à la Figure 14.8.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 14
Manipulation du Registre de Windows
349
Figure 14.8 La feuille de l’application, en mode Édition.
Double-cliquez sur le premier bouton de commande et complétez la procédure Button1_ Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click Dim key As RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop", True) key.SetValue("MenuShowDelay", "0") key.Close() End Sub
La première instruction définit l’objet key de type RegistryKey qui sera utilisé pour manipuler le Registre : Dim key As RegistryKey
La deuxième instruction crée une référence sur la clé HKEY_CURRENT_USER\Control Panel\ Desktop : key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop", True)
La troisième instruction crée la valeur MenuShowDelay et lui affecte la valeur 0. Ainsi, l’affichage du menu Démarrer et de ses entrées ne sera pas différé : key.SetValue("MenuShowDelay", "0")
Enfin, la quatrième instruction ferme la clé qui a été ouverte avec la fonction OpenSubKey() : key.Close()
Double-cliquez sur le deuxième bouton de commande et ajoutez les instructions suivantes dans la procédure Button2_Click() : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
350
Visual Basic 2010
„ Handles Button2.Click Dim key As RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop", True) key.SetValue("MenuShowDelay", "40") key.Close() End Sub
Cette procédure est identique à la précédente, à ceci près qu’elle affecte la valeur 40 à la valeur MenuShowDelay. Le délai d’affichage du menu Démarrer et de ses commandes sera de 40 millisecondes. Double-cliquez sur le troisième bouton de commande et complétez la procédure Button3_ Click() comme suit : Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button3.Click Dim Key As RegistryKey Key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop") Dim val As Object val = Key.GetValue("MenuShowDelay") TextBox1.Text = val Key.Close() End Sub
Après avoir créé une référence sur la clé HKEY_CURRENT_USER\Control Panel\Desktop : Dim Key As RegistryKey Key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop")
la valeur MenuShowDelay est lue et stockée dans l’objet val : Dim val As Object val = Key.GetValue("MenuShowDelay")
Il suffit maintenant d’afficher la valeur retournée par la fonction GetValue() dans la zone de texte puis de refermer la clé ouverte avec la fonction OpenSubKey() : TextBox1.Text = val Key.Close()
Vous allez définir une procédure qui efface la valeur MenuShowDelay. Double-cliquez sur le quatrième bouton de commande et complétez la procédure Button4_Click() comme suit : Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button4.Click Dim key As RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop", True)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 14
Manipulation du Registre de Windows
351
Try key.DeleteValue("MenuShowDelay") Catch End Try End Sub
Après avoir référencé la clé HKEY_CURRENT_USER\Control Panel\Desktop : Dim key As RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop", True)
la fonction DeleteValue() est appelée pour supprimer la valeur MenuShowDelay. Remarquez l’utilisation de la structure Try Catch End Try pour éviter toute erreur en cas de suppression d’une valeur inexistante : Try key.DeleteValue("MenuShowDelay") Catch End Try
Voici le listing complet de l’application. Vous trouverez les fichiers correspondants à ce projet dans le dossier Registre après installation des sources de l’ouvrage. Imports Microsoft.Win32 Public Class Form1 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click Dim key As RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop", True) key.SetValue("MenuShowDelay", "0") key.Close() End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click Dim key As RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop", True) key.SetValue("MenuShowDelay", "40") key.Close() End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button3.Click Dim Key As RegistryKey
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
352
Visual Basic 2010
Key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop") Dim val As Object val = Key.GetValue("MenuShowDelay") TextBox1.Text = val Key.Close() End Sub Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button4.Click Dim key As RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel\Desktop", True) Try key.DeleteValue("MenuShowDelay") Catch End Try End Sub End Class
Accès au Registre par une requête LINQ Certaines méthodes de la classe RegistryKey renvoient des collections. Il est donc possible de les interroger avec une requête LINQ pour extraire un sous-ensemble de données satisfaisant une ou plusieurs conditions. Reportez-vous à la section intitulée "Accès au Registre" au Chapitre 27 pour savoir comment procéder.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
15 Fonctions API Le langage Visual Basic implémente de façon native un grand nombre d’API Windows. Ces API sont donc directement utilisables, sans avoir recours à une instruction Declare du type suivant : Declare Function nom Lib nomLib ([ByVal|ByRef]param1, …, [ByVal|ByRef]paramN) „ As type
Principales API Le tableau ci-après liste quelques-unes des fonctions API reconnues de façon native. Pour en savoir plus à leur sujet et accéder à l’ensemble des fonctions API, consultez le site http://allapi.mentalis.org/apilist/apilist.php. Toutes les alternatives VB.NET aux API y sont listées et commentées par ordre alphabétique.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
CryptGenKey
CryptEncrypt
customer 27921 at Fri Mar 11 19:22:06 +0100 2011 DestroyMenu
DestroyIcon DrawTextEx EnumFontFamiliesEx FillMemory FrameRgn FtpDeleteFile
DestroyCursor
DrawText
EnumFontFamilies
ExtTextOut
FindNextFile
FtpCreateDirectory
FtpFindFirstFile
FreeConsole
FillRect
EnumProcesses
DuplicateIcon
CryptVerifySignature
CryptReleaseContext CryptSignHash
CryptExportKey
CryptDecrypt
CreateSolidBrush
CreatePolyPolygonRgn
CreateMutex
CreateEllipticRgn
CreateCursor
CopyMemory
CompareFileTime
CloseHandle
CheckMenuRadioItem
BitBlt
CryptAcquireContext CryptCreateHash
CreateRoundRectRgn
CreateRectRgnIndirect
CreateCompatibleDC
CreateCompatibleBitmap
CreatePolygonRgn
CopyImage
CopyFileEx
CreatePenIndirect
CombineRgn
CoCreateGuid
CreateHatchBrush
CloseEventLog
CloseClipboard
CreateFontIndirect
CharUpper
CharLowerBuff
CreateDirectoryEx
BeginPath
ArcTo
AllocConsole
FtpGetCurrentDirectory
FreeEnvironmentStrings
FillRgn
EnumProcessModules
Ellipse
DestroyWindow
DeleteDC
CryptGetProvParam
CryptDeriveKey
CreateThread
CreatePopupMenu
CreatePalette
CreateEllipticRgn-Indirect
CreateDC
CoTaskMemFree
CompareString
ClosePrinter
CHOOSECOLOR
BringWindowToTop
AngleArc
FtpGetFile
FreeLibrary
FindClose
EqualRgn
EmptyClipboard
DrawIcon
DeleteFile
CryptGetUserKey
CryptDestroyHash
CreateToolhelp32Snapshot
CreateProcess
CreatePatternBrush
CreateFile
CreateDIBPatternBrushPt
CreateBitmap
Connect
closesocket
CHOOSEFONT
CallWindowProc
AppendMenu
FtpPutFile
FreeSid
FindFirstFile
ExitThread
EnableWindow
DrawIconEx
DeleteObject
CryptHashData
CryptDestroyKey
CreateWindowEx
CreateRectRgn
CreatePen
CreateFont
CreateDIBSection
CreateBrushIndirect
CopyFile
CloseWindow
ClearEventLog
CharLower
Arc
CreateDirectory
_lopen
_lclose
354
Visual Basic 2010
Propriété de Albiri Sigue
GetComputerName GetCurrentProcessId GetCurrentThread GetDIBits GetFileInformation- GetFileSize ByHandle GetFileVersionInfo- GetFocus Size GetLocaleInfo GetModuleFileName
GetCommandLine
GetCurrentProcess
GetDC
GetFileAttributes
GetFileVersionInfo
gethostname
GetMenuItemInfo
GetMenu
GetRgnBox GetSystemDirectory
GetProcessMemoryInfoGetProcessTimes GetSubMenu GetTickCount GetWindowPlacement ImageList_Draw IntersectClipRect IsCharUpper IsZoomed LoadIcon
GetStartupInfo
GetThreadPriority
GetWindowDC
GradientFillTriangle
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
InsertMenuItem
IsCharLower
IsWindowVisible
LoadIcon
LocalFileTimeToFileTime
LineTo
IsIconic
InvertRgn
inet_addr
GetWindowText
GetUserNameEx
GetSystemTime
GetSaveFileName
GetPolyFillMode
GetPriorityClass
GetOpenFileName
GetMenuItemID
lstrcat
LoadCursor
IsRectEmpty
IsCharAlpha
inet_ntoa
GetWindowTextLength
GetVersion
GetTempFileName
lstrcmp
LoadCursorFromFile
IsWindowEnabled
IsCharAlphaNumeric
InflateRect
GradientFillRect
GetVersionEx
GetThreadLocale
GetSaveFileNamePre- getsockopt view
GetPrinter
GetNumberFormat
GetMenuItemCount
gethostbyname
GetFileTitle
Fonctions API
LoadImage
KillTimer
IsDebuggerPresent
GetFileTime
IntersectRect
ImageList_DrawEx
GetWindowRect
GetUserName
GetPixel
GetOpenFileNamePre- GetParent view
GetDateFormat
GetCurrentDirectory
GetClipRgn
GetActiveWindow
GetEnvironmentVari- GetExitCodeProcess able
GetCursorPos
GetCurrencyFormat
GetClipboardData
GdiTransparentBlt
GetForegroundWindow gethostbyaddr
GetFileSizeEx
GetEnvironmentStrings
GetCursor
GetComputerNameEx
GetClientRect
GdiGradientFillRect
GetModuleFileNameEx GetNearestColor
GetLocalTime
GetDoubleClickTime
GetComputerName
GetBitmapBits
GetArcDirection
GetAncestor
FtpSetCurrentDirectory
FtpRenameFile
FtpRemoveDirectory
Chapitre 15
355
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011 SetTimer
SetPixelV
SetFileAttributes
SetArcDirection
ReleaseMutex
RegEnumKeyEx
recv
PtInRegion
PolyPolygon
PolyBezier
PAGESETUPDLG
OffsetRgn
MoveFile
ModifyMenu
lstrlen
UnionRect WriteConsole
TerminateProcess TrackPopupMenuEx WinExec
TrackPopupMenu
WaitForSingleObject
TextOut
SleepEx
SHFileOperation
WriteFile
UuidCreate
timeGetTime
socket
SHGetFileInfo
SHCreateDirectoryEx SHCreateThread
SetThreadPriority
TabbedTextOut
setsockopt
SetRectEmpty
SetPixel
Sleep
SetMenuItemInfo
SetLayeredWindow -Attributes
SetDIBitsToDevice
ShowWindow
SetCursorPos
SetCursor
Send
SHFileExists
SelectObject
SelectClipRgn
RegSetValueEx
Shell_NotifyIcon
RegQueryValueEx
RegOpenKeyEx
RegDeleteValue
SetWindowText
RegDeleteKey
RegCreateKeyEx
Rectangle
Process32Next
PolylineTo
Pie
OutputDebugString
OffsetRect
MonitorFromWindow
MessageBoxIndirect
SetWindowRgn
ReadFile
PathStripPath
PathIsDirectoryEmpty
ReadConsole
OpenProcess
OpenIcon
Process32First
MulDiv
MoveWindow
PrintDialog
MonitorFromRect
MonitorFromPoint
Polyline
MessageBoxEx
MessageBox
lstrcpyn
WSAAsyncSelect
UuidToString
timeKillEvent
StretchBlt
ShowCursor
ShellExecute
SetWindowPlacement
SetPriorityClass
SetFilePointer
SetClipboardData
RemoveDirectory
RegEnumValue
RegCloseKey
QueryPerformanceCounter
PolyPolyline
PolyBezierTo
PathFileExists
OpenClipboard
MoveFileEx
Module32First
lstrlenW
VerQueryValue
timeSetEvent
SystemTimeToFileTime
ShowScrollbar
ShellExecuteEx
SetWindowPos
SetRect
SetFileTime
SetCurrentDirectory
RemoveMenu
RegOpenKey
RegCreateKey
QueryPerformanceFrequency
PolyTextOut
PolyDraw
PathIsDirectory
OpenFile
MoveToEx
Module32Next
MakeSureDirectoryPathExists
Polygon
lstrcpy
lstrcmpi
356
Visual Basic 2010
Propriété de Albiri Sigue
Chapitre 15
Fonctions API
357
Utilisation des API natives et traditionnelles À titre d’exemple, nous allons développer un projet qui utilise de façon native les API ToLower et ToUpper et de façon traditionnelle les API CharLower et CharUpper pour (respectivement) transformer une chaîne en caractères minuscules et majuscules. Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom MinMaj au projet et validez en cliquant sur OK. Ajoutez deux TextBox et quatre Button au projet. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant : Contrôle
Propriété
Valeur
Form1
Text
Minuscules et majuscules
TextBox1
Text
TextBox2
Text
Button1
Text
Minuscules .NET ToLower
Button2
Text
Majuscules .NET ToUpper
Button3
Text
Minuscules API CharLower()
Button4
Text
Majuscules API CharUpper()
Modifiez l’emplacement et les dimensions de ces contrôles de sorte que la feuille de l’appli cation ressemble à la Figure 15.1. Figure 15.1 La feuille de l’application, en mode Édition.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
358
Visual Basic 2010
Double-cliquez sur le bouton Minuscules .NET ToLower et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click TextBox2.Text = TextBox1.Text.ToLower End Sub
Cette procédure se contente d’appeler la fonction ToLower() pour convertir en minuscules le texte placé dans le premier TextBox et pour l’afficher dans le deuxième TextBox. Double-cliquez sur le bouton Majuscules .NET ToUpper et complétez la procédure Button2_ Click() comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button2.Click TextBox2.Text = TextBox1.Text.ToUpper End Sub
Ici, le texte du contrôle TextBox1 est converti en utilisant la fonction ToUpper(). Nous allons maintenant utiliser les API CharLower() et CharUpper() par l’intermédiaire des boutons Minuscules API CharLower() et Majuscules API CharUpper(). Commencez par définir les fonctions API CharLower() et CharUpper() à la suite de la région "Windows Form Designer generated code" : Declare Function CharLower Lib "user32" Alias "CharLowerA" ( _ ByVal lpsz As String _ ) As String Declare Function CharUpper Lib "user32" Alias "CharUpperA" ( _ ByVal lpsz As String _ ) As String
Ces déclarations sont en tout point banalisées. Rendez-vous sur le site http://allapi.mentalis.org/apilist/apilist.php pour avoir une idée de la syntaxe à utiliser (voir Figure 15.2). Double-cliquez sur le bouton Minuscules API CharLower() et complétez la procédure Button3_Click() comme suit : Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button3.Click Dim s As String s = TextBox1.Text s = CharLower(s) TextBox2.Text = s End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 15
Fonctions API
359
Figure 15.2 Le site allapi.mentalis.org donne la syntaxe de toutes les fonctions API.
Le contenu de la première zone de texte est placé dans la variable String s : Dim s As String s = TextBox1.Text
La fonction API CharLower() est alors appliquée à la variable s. Le résultat est stocké dans la variable s elle-même : s = CharLower(s)
Le résultat de la conversion est apparaît dans le deuxième TextBox : TextBox2.Text = s
Double-cliquez sur le bouton Majuscules API CharUpper() et complétez la procédure Button4_Click() comme suit : Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button4.Click Dim s As String s = TextBox1.Text s = CharUpper(s) TextBox2.Text = s End Sub
Les instructions de cette procédure sont comparables à celles de la procédure Button3_ Click(), mais, ici, la conversion s’effectue avec l’API CharUpper().
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
360
Visual Basic 2010
Voici le listing complet de l’application. Ce projet se trouve dans le dossier Projects\MinMaj des sources de l’ouvrage après leur installation. Public Class Form1 Declare Function CharLower Lib "user32" Alias "CharLowerA" ( _ ByVal lpsz As String _ ) As String Declare Function CharUpper Lib "user32" Alias "CharUpperA" ( _ ByVal lpsz As String _ ) As String Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click TextBox2.Text = TextBox1.Text.ToLower End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click TextBox2.Text = TextBox1.Text.ToUpper End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button3.Click Dim s As String s = TextBox1.Text s = CharLower(s) TextBox2.Text = s End Sub Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button4.Click Dim s As String s = TextBox1.Text s = CharUpper(s) TextBox2.Text = s End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
16 Implémenter un système d’aide Les fichiers d’aide Microsoft existent sous deux formats : .HLP et .CHM. Le premier format est très ancien puisqu’il date de Windows 3.1. Apparu avec les systèmes Windows 32 bits, le deuxième format offre des avantages indéniables :
∑ ∑ ∑
possibilité de définir une table des matières, un index et/ou un onglet de favoris ; compilation des fichiers d’aide pour diminuer leur taille ; utilisation possible des fichiers CHM sur le Web via une méthode Visual Basic.
Signalons en outre que la mise en œuvre de fichiers CHM est plus simple que celle des fichiers HLP et qu’elle permet d’utiliser de nombreuses fonctionnalités du HTML, telles que CSS ou JavaScript. Les utilisateurs d’Office XP et 2003 peuvent se servir du programme HTML Help Workshop (qui est fourni) pour créer des fichiers d’aide au format .CHM.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
362
Visual Basic 2010
Si vous utilisez une version plus ancienne de Microsoft Office, vous pouvez télécharger gratuitement le programme HTML Help Workshop. Pour cela, rendez-vous (par exemple) sur le site Microsoft Download Center, à l’adresse http://www.microsoft.com/downloads/ details.aspx?FamilyID=00535334-c8a6-452f-9aa0-d597d16580cc&DisplayLang=en (voir Figure 16.1). Figure 16.1 Cette page permet de télécharger le programme HTML Help Workshop.
Pour faciliter la prise en main du programme HTML Help Workshop, nous allons raisonner sur un exemple concret en ajoutant de l’aide au projet "Personnaliser Windows 7", développé au Chapitre 17 (voir Figure 16.2). Figure 16.2 La fenêtre de l’application Personnalisation de Windows 7.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
363
Première étape : collecte des informations utilisées par le système d’aide Dans la première étape du projet, vous allez mettre à plat tous les sujets qui doivent être abordés par le système d’aide. Comme vous pouvez le voir à la Figure 16.2, les différentes fonctionnalités du projet Personnalisation de Windows XP sont regroupées sous trois onglets. Les informations qui apparaissent sous ces onglets peuvent être personnalisées et étendues à loisir par chaque utilisateur. Les rubriques d’aide pourraient donc être les suivantes :
∑ ∑ ∑ ∑ ∑ ∑ ∑ ∑ ∑ ∑
Message de bienvenue ; Historique de l’application ; Utilisation du produit ; Onglet Raccourcis ; Onglet Astuces ; Onglet Personnalisation ; Extension du produit ; Extension de l’onglet Raccourcis ; Extension de l’onglet Astuces ; Extension de l’onglet Personnalisation.
Deuxième étape : conception des pages HTML des rubriques Pour chacune des rubriques énumérées dans la première étape, une page HTML doit être élaborée. Utilisez l’éditeur HTML de votre choix (le Bloc-notes de Windows ou un éditeur spécialisé HTML, comme Notepad++ par exemple) pour créer les différentes pages. Voici quelques conseils pratiques :
∑
Utilisez un modèle de page de façon à uniformiser le look and feel de votre système d’aide.
∑
Choisissez un titre (marqueur ) parlant pour chacune des rubriques afin de faciliter votre futur travail dans le compilateur.
∑
Si vous insérez des images, des sons ou des vidéos dans les pages HTML, référencez-les de façon relative (et non par rapport à la racine du projet d’aide).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
364
Visual Basic 2010
Voici le code source et l’interprétation HTML des huit fichiers à intégrer dans l’aide. Présentation.htm Présentation L’application "Personnalisation de Windows 7" propose trois façons de faciliter „ l’utilisation de Windows 7 : Exécution de programmes d’un simple clic de souris ; Exposition détaillée de techniques permettant d’améliorer le fonctionnement „ de Windows 7 ; Modification de paramètres en agissant sur le Registre de Windows 7. Un ensemble de raccourcis, astuces et commandes est proposé avec l’application. Si vous le souhaitez, il est possible de supprimer ou de compléter à loisir les „ éléments accessibles par l’intermédiaire de cette application, et ce, sans avoir „ recours à la programmation.
Figure 16.3 La page Présentation.htm.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
365
Historique.htm Historique L’application "Personnalisation de Windows 7" a été développée en Visual Basic 2010. La version actuelle est 4.0. Elle date du 25 Mai 2010.
Figure 16.4 La page Historique.htm.
OngletRaccourcis.htm Onglet Raccourcis
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
366
Visual Basic 2010
L’onglet "Raccourcis" donne accès à un ensemble de programmes difficiles à lancer „ via le menu Démarrer. Pour lancer un programme, sélectionnez-le dans la liste déroulante et cliquez sur „ "Exécuter".
Figure 16.5 La page Onglet Raccourcis.htm.
OngletAstuces.htm Onglet Astuces L’onglet "Astuces" regroupe un ensemble d’astuces destinées à améliorer le fonction„ nement de Windows.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
367
Pour afficher le texte associé à une astuce, il suffit de sélectionner une entrée dans „ la liste déroulante.
Figure 16.6 La page Onglet Astuces.htm.
OngletPersonnalisation.htm Onglet Personnalisation L’onglet "Personnalisation" donne accès à un ensemble de paramètres qui agissent sur „ le Registre de Windows 7. Pour exécuter une des actions listées sous l’onglet Personnalisation, il suffit „ de faire votre choix dans la liste déroulante et de cliquer sur "Exécuter".
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
368
Visual Basic 2010
Figure 16.7 La page OngletPersonnalisation.htm.
PersoRaccourcis.htm Etendre l’onglet Raccourcis Pour modifier la liste des programmes exécutables sous l’onglet Raccourcis, un simple „ éditeur de texte suffit. Ouvrez le fichier "raccourcis.txt" et définissez trois lignes de texte pour chaque „ programme que vous voulez répertorier dans la liste : Le nom qui doit apparaître dans la liste déroulante ; Le texte d’aide à afficher lorsque le programme est sélectionné dans la liste „ déroulante ; La syntaxe complète de lancement du programme. Après chaque modification du fichier "raccourcis.txt", vous devez, si nécessaire, „ trier les informations selon le premier champ.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
369
Figure 16.8 La page PersoRaccourcis.htm.
PersoAstuces.htm Etendre l’onglet Astuces Pour modifier la liste des astuces affichées sous l’onglet Astuces, un simple éditeur „ de texte suffit. Ouvrez le fichier "astuces.txt" et définissez deux lignes de texte pour chaque astuce „ à répertorier : Le nom qui doit apparaître dans la liste déroulante ; Le texte d’aide à afficher lorsque le programme est sélectionné dans la liste „ déroulante. Après chaque modification du fichier "raccourcis.txt", vous devez, si nécessaire, „ trier les informations selon le premier champ.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
370
Visual Basic 2010
Figure 16.9 La page Perso Astuces.htm.
PersoPersonnalisation.htm Onglet Personnalisation Pour modifier la liste des commandes répertoriées sous l’onglet Personnalisation, un simple éditeur de texte suffit. Ouvrez le fichier "perso.txt" et définissez six lignes de texte pour chacune des commandes que vous souhaitez afficher : Le texte qui doit apparaître dans la liste déroulante Le nom de la ruche Le chemin de la clé Le nom de la valeur La donnée à affecter à cette valeur
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
371
Le type de la valeur Après chaque modification du fichier "perso.txt", vous devez, si nécessaire, trier les informations selon le premier champ.
Figure 16.10 La page PersoPersonnalisation.htm.
Troisième étape : conception du fichier d’aide .CHM Pour créer le fichier d’aide au format .CHM, vous allez devoir définir :
∑ ∑ ∑
un fichier projet d’extension .HHP ; un fichier sommaire d’extension .HHC ; un fichier index d’extension .HHK.
Lancez l’application HTML Help Workshop avec la commande Tous les programmes/ HTML Help Workshop/HTML Help Workshop dans le menu Démarrer (voir Figure 16.11).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
372
Visual Basic 2010
Figure 16.11 La fenêtre principale de HTML Help Workshop.
Lancez la commande New dans le menu File. Choisissez Project dans la boîte de dialogue et validez en cliquant sur OK. Un assistant vous aide à définir les informations qui permettront de construire le projet d’aide. La première boîte de dialogue demande s’il s’agit de la conversion d’un fichier WinHelp, c’est-à-dire d’un fichier d’aide 16 bits au format .HLP (voir Figure 16.12). Figure 16.12 L’Assistant sait convertir un fichier .HLP en un fichier .CHM.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
373
Laissez la case Convert WinHelp project décochée et cliquez sur Suivant. Définissez le chemin complet du projet d’aide (disque, dossier et nom) puis cliquez sur Suivant. La troisième boîte de dialogue vous demande si vous avez déjà conçu un fichier sommaire, un fichier index et/ou des fichiers HTML (voir Figure 16.13). Figure 16.13 Quels sont les fichiers déjà conçus ?
Cochez la case HTML files (.htm) et cliquez sur Suivant. Vous devez maintenant spécifier les fichiers HTML à intégrer au projet d’aide. Cliquez sur Add et utilisez la boîte de dialogue à sélection multiple Ouvrir pour désigner en une seule opération l’ensemble des fichiers à utiliser. La boîte de dialogue New Project doit maintenant ressembler à la Figure 16.14. Figure 16.14 Huit fichiers HTML doivent être intégrés au projet d’aide.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
374
Visual Basic 2010
Cliquez sur Suivant puis sur Terminer pour générer le projet d’aide. La fenêtre de l’application HTML Help Workshop se présente comme à la Figure 16.15. Figure 16.15 La fenêtre de l’application HTML Help Workshop après l’utilisation de l’Assistant.
Vous allez maintenant créer un fichier sommaire et un fichier index. Sélectionnez l’onglet Contents. La boîte de dialogue représentée à la Figure 16.16 s’affiche. Figure 16.16 Définition du fichier sommaire.
Choisissez l’option Create a new contents file. Cliquez sur OK. Donnez un nom au fichier sommaire et cliquez sur Enregistrer pour créer le fichier d’extension .HHC. Sélectionnez l’onglet Index. La boîte de dialogue représentée à la Figure 16.17 s’affiche.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
375
Figure 16.17 Définition de l’index.
Choisissez l’option Create a new index file. Cliquez sur OK. Donnez un nom au fichier index et cliquez sur Enregistrer pour créer le fichier d’extension .HHK. Basculez sur l’onglet Project et cliquez sur l’icône Add/Modify window definitions pour définir le style de la fenêtre d’aide. Utilisez les onglets de la boîte de dialogue Windows types pour choisir le titre de la fenêtre, les boutons à afficher dans la fenêtre, la position de la fenêtre sur l’écran, etc. (voir Figure 16.18). Figure 16.18 Cette boîte de dialogue définit le style de la fenêtre d’aide.
Définissez un fichier texte qui référence les différentes pages de l’aide comme à la Figure 16.19. Sauvegardez ce fichier en lui donnant l’extension .H.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
376
Visual Basic 2010
Figure 16.19 Chaque page a un numéro d’identification unique.
Cliquez sur le bouton HtmlHelp API Information (quatrième icône dans la fenêtre HTML Help Workshop). Une boîte de dialogue intitulée HtmlHelp API Information s’affiche. Cliquez sur le bouton Header file puis sur le bouton Browse et désignez le fichier d’extension .H que vous venez de créer. Vous devriez obtenir quelque chose comme à la Figure 16.20. Figure 16.20 Le fichier d’alias a été référencé.
Basculez sur l’onglet Alias de la boîte de dialogue HtmlHelp API information. Cliquez autant de fois que nécessaire sur le bouton Add pour définir tous les alias (voir Figure 16.21).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
377
Figure 16.21 Définition d’un alias.
Lorsque tous les alias ont été définis, vous devez obtenir quelque chose qui ressemble à la Figure 16.22. Figure 16.22 Tous les alias ont été définis.
Fermez la boîte de dialogue HtmlHelp API information.
Définition du sommaire Vous allez maintenant concevoir le sommaire de l’aide. Cliquez sur l’onglet Contents. Les rubriques seront créées à l’aide de l’icône Insert a page et les chapitres à l’aide de l’icône Insert a heading.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
378
Visual Basic 2010
À titre d’exemple, la Figure 16.23 représente la rubrique Présentation. L’information qui apparaît dans la zone File/URL and their information types a été définie en appuyant sur le bouton Add. Figure 16.23 Entrée de sommaire Présentation.
Lorsque toutes les entrées du sommaire ont été définies, la fenêtre HTML Help Workshop doit ressembler à la Figure 16.24. Figure 16.24 Le sommaire est entièrement défini.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
379
Définition de l’index Basculez sur l’onglet Index. Pour définir une entrée d’index, cliquez sur l’icône Insert a keyword. Entrez un mot dans la zone de texte Keyword et cliquez autant de fois que nécessaire sur le bouton Add pour lier le mot-clé aux pages de l’aide. À la Figure 16.25, par exemple, plusieurs pages sont reliées au mot-clé Onglet. Figure 16.25 Définition de l’entrée onglet dans l’index.
Cliquez sur le bouton Save file lorsque toutes les entrées d’index ont été créées. Vous allez maintenant compiler le projet d’aide pour créer le fichier .CHM correspondant. Basculez sur l’onglet Project et cliquez sur l’icône Save all files and compile. Le fichier d’aide .CHM est créé. Vérifiez qu’aucune erreur n’a été détectée en parcourant le fichier de log (voir Figure 16.26). Figure 16.26 Aucune erreur n’a été détectée dans le projet d’aide.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
380
Visual Basic 2010
Quatrième étape : interfaçage du fichier d’aide avec un projet Visual Basic Pour intégrer un fichier d’aide .CHM (ou .HLP) à un projet Visual Basic 2010, procédez comme suit : 1. Ajoutez un contrôle HelpProvider au projet et indiquez le nom du fichier d’aide à utiliser dans sa propriété HelpNameSpace. 2. Sélectionnez l’objet Form1 dans la fenêtre des propriétés et initialisez à True sa propriété ShowHelp sur HelpProvider. La Figure 16.27 donne un exemple d’affichage de l’aide depuis l’application Personna lisation de Windows 7 développée au Chapitre 17. Figure 16.27 La fenêtre d’aide a été affichée avec la touche F1.
Il est également possible d’accéder à l’index de l’aide avec la méthode ShowHelpIndex() : Help.ShowHelpIndex(Me, "c:\FichierAide.chm")
ou avec la méthode ShowHelp() : Help.ShowHelp(Me, "c:\FichierAide.chm", HelpNavigator.Index)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 16
Implémenter un système d’aide
381
Si nécessaire, vous pouvez également accéder à la page de recherche, à la page concernant un mot-clé particulier ou une rubrique particulière en utilisant la méthode ShowHelp() : ‘Accès à la page de recherche Help.ShowHelp(Me, "c:\FichierAide.chm", ‘Accès à la page relative à un mot clé Help.ShowHelp(Me, "c:\FichierAide.chm", ‘Accès à la rubrique dont le numéro est Help.ShowHelp(Me, "c:\FichierAide.chm",
Info
HelpNavigator.Find) "mot clé") spécifié HelpNavigator.Topic, numéro de rubrique)
Le deuxième argument de la méthode ShowHelp() peut également être une adresse URL. Utilisez dans ce cas le caractère séparateur "\" à la place du "/".
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
17 Personnaliser Windows 7 Au sommaire de ce chapitre
∑ Informations de la base de données ∑ Réalisation Le projet développé dans ce chapitre est une base de données ouverte qui rassemble des trucs, des astuces et des réglages pour Windows 7 et qui permet de lancer les applications difficilement accessibles par le menu Démarrer. Notez bien que cette base de données n’est utilisable que sous l’environnement Windows 7. Toute utilisation dans un autre système d’exploitation pourrait entraîner des dégradations matérielles ou logicielles irréversibles. Les informations incluses dans cette base de données ont été récupérées sur le Web et sur divers livres informatiques. Certains réglages agissent directement sur le Registre de Windows 7. D’autres sont exposés en détail, et vous devrez vous-même effectuer les manipulations adéquates. Si vous utilisez de manière inconsidérée ces réglages, il peut s’ensuivre une déstabilisation matérielle ou logicielle de votre ordinateur. CampusPress ne saurait en aucun cas être tenu pour responsable de telles détériorations. Prenez donc toutes les précautions nécessaires et n’agissez qu’en toute connaissance de cause…
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
384
Visual Basic 2010
Informations de la base de données La base de données développée dans ce chapitre propose trois types de services :
∑ ∑
exécution de programmes d’un simple clic de souris ;
∑
modification de paramètres en agissant sur le Registre de Windows 7.
exposition détaillée de techniques permettant d’améliorer le fonctionnement de Windows 7 ;
Exécution de programmes La base de données est accessible à l’aide de trois onglets : Raccourcis, Astuces et Personnalisation. L’onglet Raccourcis donne accès à un ensemble de programmes difficiles à lancer via le menu Démarrer (voir Figure 17.1). Figure 17.1 Le premier onglet donne accès à un ensemble de programmes que l’on peut lancer d’un simple clic.
Le tableau suivant donne un aperçu des programmes répertoriés sous l’onglet Raccourcis : Programme à lancer
Commande
Gestion de l’ordinateur
c:\windows\system32\mmc.exe c:\windows\system32\compmgmt.msc
Gestionnaire de périphériques
c:\windows\system32\mmc.exe c:\windows\system32\devmgmt.msc
Gestion des disques
c:\windows\system32\mmc.exe c:\windows\system32\diskmgmt.msc
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 17
Personnaliser Windows 7
385
Programme à lancer
Commande
Observateur d’événements
c:\windows\system32\mmc.exe c:\windows\system32\eventvwr.msc
Dossiers partagés
c:\windows\system32\mmc.exe c:\windows\system32\fsmgmt.msc
Utilisateurs et groupes locaux
c:\windows\system32\mmc.exe c:\windows\system32\lusrmgr.msc
Performance
c:\windows\system32\mmc.exe c:\windows\system32\perfmon.msc
Services
c:\windows\system32\mmc.exe c:\windows\system32\services.msc
Ces informations sont regroupées dans un fichier texte nommé raccourcis.txt. Chacun des programmes répertoriés demande trois informations :
∑ ∑ ∑
le nom qui doit apparaître dans la liste déroulante ; le texte d’aide à afficher lorsque le programme est sélectionné dans la liste déroulante ; la syntaxe complète de lancement du programme.
Les informations sont triées par ordre alphabétique sur le premier champ : Défragmenteur de disque Le Défragmenteur de disque est un utilitaire système qui permet d’analyser des volumes locaux et de localiser et d’unir les fichiers et dossiers fragmentés. Vous pouvez également défragmenter des disques à partir d’une ligne de commande à l’aide de la commande defrag. c:\windows\system32\mmc.exe c:\windows\system32\dfrg.msc … Utilisateurs et groupes locaux L’application Utilisateurs et groupes locaux est dédiée à la gestion des utilisateurs et des groupes locaux. c:\windows\system32\mmc.exe c:\windows\system32\lusrmgr.msc
Si vous le souhaitez, il est possible d’ajouter un ou plusieurs programmes dans le fichier raccourcis.txt, en respectant la structure du fichier et l’ordre de classement selon le premier champ.
Amélioration du fonctionnement de Windows L’onglet Astuces regroupe un ensemble d’astuces destinées à améliorer le fonctionnement de Windows (voir Figure 17.2).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
386
Visual Basic 2010
Figure 17.2 Le deuxième onglet présente un ensemble d’astuces.
Le tableau suivant donne un aperçu des astuces énumérées sous l’onglet Astuces : Effet recherché
Manipulation
Améliorer la gestion de la mémoire
Windows 7 n’utilise, par défaut, que 512 ko de mémoire vive en tant que mémoire tampon pour ses échanges avec le disque dur. Si vous disposez d’au moins 1 Go de mémoire vive, vous pouvez augmenter la quantité de mémoire allouée : la lecture et l’écriture de fichiers seront accélérées. Tapez RegEdit. Accédez au chemin HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management. Définissez la variable dword
IoPageLockLimit. Affectez-lui la valeur 000F0000. Créer des noms d’unités personnalisés
Lancez la commande Exécuter dans le menu Démarrer. Tapez RegEdit. Accédez au chemin HKEY_LOCAL_MACHINE\SOFTWARE\ Microsoft\Windows\CurrentVersion\Explorer. Créez la clé DriveIcons. Créez une nouvelle clé que vous nommerez par la lettre du lecteur qui vous intéresse ("D" par ex). Ouvrez cette nouvelle clé et créez une dernière clé à l’intérieur que vous nommerez DefaultLabel. Donnez le nom du lecteur à cette clé.
Désactiver les "dossiers ZIP"
Cliquez sur Démarrer, tapez regsvr32 /u zipfldr.dll dans la zone de saisie et validez.
Désactiver les rapports d’erreur
Ouvrez le Panneau de configuration. Double-cliquez sur l’icône Système. Sélectionnez l’onglet Avancé. Cliquez sur le bouton Rapports d’erreur. Cochez la case Désactiver le rapport d’erreur.
Empêcher le démarrage automatique de Windows Messenger
Lancez la commande Exécuter dans le menu Démarrer. Tapez RegEdit. Accédez au chemin HKEY_CURRENT_USER\software\Microsoft\Windows\CurrentVersion\Run\. Supprimer la clé MsnMsgr.
Éteindre l’ordinateur avec un raccourci
Cliquez droit sur un emplacement vide du Bureau et choisissez Nouveau puis Raccourci dans le menu. Définissez la commande shutdown -s pour éteindre l’ordinateur.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 17
Personnaliser Windows 7
387
Effet recherché
Manipulation
Désactiver les info-bulles
Lancez l’Éditeur du Registre avec la commande regedit dans le menu Démarrer. Développez l’arborescence HKEY_CURRENT_USER\ Software\Microsoft\Windows\CurrentVersion\Explorer\ Advanced. Créez une nouvelle clé de type DWORD nommée EnableBalloonTips et donnez-lui la valeur 0 pour désactiver les info-bulles, ou 1 pour les activer.
Afficher un message au démarrage
Pour afficher un message, juste avant de choisir un utilisateur, exécutez l’Éditeur du Registre. Développez l’arborescence jusqu’à HKEY_LOCAL_MACHINE\Software\Microsoft\WindowsNT\CurrentVersion\Winlogon. Donnez la valeur de votre choix aux données REG_SZ LegalNoticeCaption (titre) et LegalNoticeText (texte).
Modifier le nom de la Corbeille
Lancez l’Éditeur du Registre avec la commande Regedit dans le menu Démarrer. Développez l’arborescence HKEY_CLASSES_ROOT, cherchez la clé {645FF040-5081-101B-9F08-00AA002F954E}. Cliquez dessus. Double-cliquez sur la chaîne (par default) dont la valeur par défaut est Corbeille, et donnez-lui le nom que vous souhaitez.
Modifier l’emplacement du dossier Program Files
Ouvrez l’Éditeur du Registre avec la commande regedit dans le menu Démarrer. Développez l’arborescence HKEY_LOCAL_MACHINE\ SOFTWARE\Microsoft\Windows\CurrentVersion. Double-cliquez sur la clé ProgramFilesDir et indiquez le chemin du nouveau dossier Program Files.
Déplacer le dossier Documents
Déroulez le menu Démarrer, cliquez du bouton droit sur le dossier Documents et choisissez Propriétés dans le menu contextuel. Sélectionnez l’onglet Location, cliquez sur Déplacer, désignez le dossier à utiliser et cliquez sur OK pour valider.
Lancer l’optimisation des fichiers
Lancez la commande Exécuter dans le menu Démarrer. Tapez Run-
dll32.exe advapi32.dll,ProcessIdleTasks et validez.
Mieux gérer la priorité des processus
Appuyez simultanément sur les touches CTRL, ALT et SUPPR. Sélectionnez Ouvrir le Gestionnaire des tâches dans le menu. Cliquez sur l’onglet Processus. Cliquez droit sur le programme auquel vous voulez allouer plus de ressources, et choisissez une des entrées proposées sous la commande Définir la priorité.
Redémarrer l’ordinateur avec un raccourci
Cliquez droit sur un emplacement vide du Bureau et choisissez Nouveau puis Raccourci dans le menu. Définissez la commande shutdown -r pour redémarrer l’ordinateur.
Retirer les programmes qui se lancent au démarrage par le registre
Lancez l’Éditeur du Registre avec la commande RegEdit dans le menu Démarrer. Accédez au chemin HKEY_LOCAL_MACHINE\ SOFTWARE\Microsoft\Windows\CurrentVersion\Run. Supprimez les valeurs qui correspondent aux programmes que vous voulez retirer au démarrage.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
388
Visual Basic 2010
Ces informations sont regroupées dans un fichier texte nommé astuces.txt. Chacune des astuces répertoriées demande deux informations :
∑ ∑
le nom qui doit apparaître dans la liste déroulante ; le texte d’aide à afficher lorsque le programme est sélectionné dans la liste déroulante.
Les informations sont triées par ordre alphabétique sur le premier champ : Améliorer la gestion de la mémoire Windows 7 n’utilise, par défaut, que 512 ko de mémoire vive en tant que mémoire tampon pour ses échanges avec le disque dur. Si vous disposez d’au moins 1 Go de mémoire vive, vous pouvez augmenter la quantité de mémoire allouée : la lecture et l’écriture de fichiers seront accélérées. Tapez RegEdit. Accédez au chemin HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management. Définissez la variable dword IoPageLockLimit. Affectez-lui la valeur 000F0000. … Retirer les programmes qui se lancent au démarrage par le registre Lancez l’Editeur du Registre avec la commande RegEdit dans le menu Démarrer. Accédez au chemin HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\ Run. Supprimez les valeurs qui correspondent aux programmes que vous voulez retirer au démarrage.
Si vous le souhaitez, il est possible d’ajouter une ou plusieurs astuces dans le fichier astuces. txt, en respectant la structure du fichier et l’ordre de classement selon le premier champ.
Paramétrage de Windows L’onglet Personnalisation donne accès à un ensemble de paramètres qui agissent sur le Registre de Windows 7 (voir Figure 17.3). Figure 17.3 Les commandes du troisième onglet modifient le Registre.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 17
Personnaliser Windows 7
389
Le tableau suivant donne un aperçu des commandes énumérées sous l’onglet Personnalisation : Chemin
Valeur
Donnée
Type de la valeur
CurrentUser
Control Panel\ Desktop
MenuShowDelay
5
REG_SZ
Restaurer la vitesse du menu Démarrer
CurrentUser
Control Panel\ Desktop
MenuShowDelay
400
REG_SZ
Désactiver les info-bulles
CurrentUser
Software\Microsoft\ EnableBalloonTips Windows\CurrentVersion\Explorer\ Advanced
0
REG_DWORD
Réactiver les info-bulles
CurrentUser
Software\Microsoft\ EnableBalloonTips Windows\CurrentVersion\Explorer\ Advanced
1
REG_DWORD
Désactiver la dé- LocalMachine fragmentation des fichiers système au boot
SOFTWARE\ Microsoft\Dfrg\ BootOptimizeFunction
Enable
N
REG_SZ
Réactiver la LocalMachine défragmentation des fichiers système au boot
SOFTWARE\Microsoft\Dfrg\BootOptimizeFunction
Enable
Y
REG_SZ
Augmenter la LocalMachine mémoire tampon pour les accès au disque dur
SYSTEM\CurrentIoPageLockLimit ControlSet\Control\ Session Manager\ Memory Management
Effet recherché
Ruche principale
Accélérer le menu Démarrer
983040 REG_DWORD
Ces informations sont regroupées dans un fichier texte nommé perso.txt. Chacune des entrées répertoriées demande six informations :
∑ ∑ ∑ ∑ ∑ ∑
le texte qui doit apparaître dans la liste déroulante ; la ruche principale ; la clé à modifier dans le Registre ; la valeur à affecter à cette clé ; la donnée à affecter à cette valeur ; le type de la valeur (REG_SZ, REG_EXPAND_SZ, REG_DWORD ou REG_BINARY).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
390
Visual Basic 2010
Les informations sont triées par ordre alphabétique sur le premier champ. Accélérer le menu Démarrer CurrentUser Control Panel\Desktop MenuShowDelay 5 REG_SZ… Restaurer la vitesse du menu Démarrer CurrentUser Control Panel\Desktop MenuShowDelay 400 REG_SZ
Si vous le souhaitez, il est possible d’ajouter une ou plusieurs commandes dans le fichier perso.txt, en respectant la structure du fichier et l’ordre de classement selon le premier champ.
Réalisation Vous allez maintenant créer l’application Visual Basic qui gère la base de données : 1. Définissez le projet Tweak7 fondé sur le modèle Application Windows Forms. 2. Insérez un contrôle TabControl sur la feuille de l’application. 3. Cliquez sur les points de suspension qui apparaissent dans la propriété TabPages du contrôle TabControl. 4. Ajoutez un troisième onglet en cliquant sur le bouton Ajouter. 5. Définissez le nom des onglets à l’aide de la propriété Text (voir Figure 17.4), puis refermez la boîte de dialogue Éditeur de collections TabPage. 6. Agrandissez la fenêtre de l’application, puis affectez la valeur Fill à la propriété Dock du contrôle TabControl pour lui faire occuper la totalité de l’espace disponible dans la fenêtre. Pour cela, il suffit de développer la liste déroulante Dock et de cliquer sur le rectangle central (voir Figure 17.5). 7. Sous l’onglet Raccourcis, ajoutez un contrôle ComboBox, un bouton de commande, un contrôle GroupBox et un Label pour obtenir l’effet visuel de la Figure 17.6.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 17
Personnaliser Windows 7
391
Figure 17.4 La propriété Text permet de définir le nom des onglets (Raccourcis, Astuces et Personnalisation).
Figure 17.5 Maximisation de l’espace occupé par le contrôle TabControl.
Figure 17.6 Le premier onglet de l’application.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
392
Visual Basic 2010
8. Modifiez les propriétés des contrôles du premier onglet comme suit : Objet
Propriété
Valeur
Combo1
Text
Button1
Text
GroupBox1
Text
Label1
Text
Sélectionnez une entrée dans la liste pour exécuter la commande correspondante
Label1
AutoSize
False1
Label1
Font
Microsoft Sans Serif corps 12
Exécuter
1. Une fois que la propriété AutoSize du contrôle Label1 a été initialisée à False, vous devez redimensionner ce contrôle pour qu’il occupe la quasi-totalité du contrôle GroupBox.
9. Sous l’onglet Astuces, ajoutez un contrôle ComboBox, un contrôle GroupBox et un Label pour obtenir l’effet visuel de la Figure 17.7. Figure 17.7 Le deuxième onglet de l’application.
10. Modifiez les propriétés des contrôles du deuxième onglet comme suit : Objet
Propriété
Combo2
Text
GroupBox2
Text
Valeur
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 17
Personnaliser Windows 7
393
Objet
Propriété
Valeur
Label2
Text
Sélectionnez une entrée dans la liste pour afficher l’astuce correspondante
Label1
AutoSize
False2
Label2
Font
MS Sans Serif corps 12
2. Une fois que la propriété AutoSize du contrôle Label1 a été initialisée à False, vous devez redimensionner ce contrôle pour qu’il occupe la quasi-totalité du contrôle GroupBox.
11. Sous l’onglet Personnalisation, ajoutez un contrôle ComboBox, un bouton de commande, un contrôle GroupBox et un Label pour obtenir l’effet visuel de la Figure 17.8. Figure 17.8 Le troisième onglet de l’application.
12. Modifiez les propriétés des contrôles du troisième onglet comme suit : Objet
Propriété
Valeur
Combo3
Text
Button2
Text
GroupBox3
Text
Label3
Text
Sélectionnez une entrée dans la liste pour exécuter la commande correspondante
Label3
Font
MS Sans Serif corps 12
Exécuter
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
394
Visual Basic 2010
L’interface de l’application est entièrement définie. Vous allez maintenant passer à l’écriture de code. Sélectionnez Form1 dans la fenêtre Propriétés, cliquez sur l’icône Événements, double-cliquez sur l’événement Load et complétez la procédure Form1_Load() comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load ‘ -----------------------------------------------‘ Lecture du fichier de données du premier onglet ‘ -----------------------------------------------cd = CurDir() FileOpen(1, cd + "\raccourcis.txt", OpenMode.Input) For i = 1 To 8 ListeRaccourcis.Add(LineInput(1)) Comment1(i) = LineInput(1) commande1(i) = LineInput(1) Next ComboBox1.DataSource = ListeRaccourcis FileClose(1) ‘ -----------------------------------------------‘ Lecture du fichier de données du deuxième onglet ‘ -----------------------------------------------FileOpen(1, cd + "\astuces.txt", OpenMode.Input) For i = 1 To 15 ListeAstuces.Add(LineInput(1)) Comment2(i) = LineInput(1) Next ComboBox2.DataSource = ListeAstuces FileClose(1) ‘ -----------------------------------------------‘ Lecture du fichier de données du troisième onglet ‘ -----------------------------------------------FileOpen(1, cd + "\perso.txt", OpenMode.Input) For i = 1 To 7 ListePerso.Add(LineInput(1)) HotKey(i) = LineInput(1) chemin(i) = LineInput(1) clé(i) = LineInput(1) valeur(i) = LineInput(1)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 17
Personnaliser Windows 7
395
TypeVal(i) = LineInput(1) Next ComboBox3.DataSource = ListePerso FileClose(1) End Sub
Cette procédure initialise les listes déroulantes et place le contenu des trois fichiers de données dans des tableaux. Le premier bloc d’instructions est dédié à la gestion du fichier raccourcis.txt. Après avoir initialisé l’objet cd avec le dossier courant : cd = CurDir()
le fichier contenant les données relatives à l’onglet Raccourcis est ouvert en lecture : FileOpen(1, cd + "\raccourcis.txt", OpenMode.Input)
Une boucle For Next lit les triplets de données. La première donnée est placée dans la collection ListeRaccourcis à l’aide de la procédure Add(). Les autres données sont placées dans les tableaux comment1() et commande1() : For i = 1 To 8 ListeRaccourcis.Add(LineInput(1)) Comment1(i) = LineInput(1) commande1(i) = LineInput(1) Next
Lorsque la boucle est terminée, la liste déroulante de l’onglet Raccourcis est initialisée à l’aide de la collection ListeRaccourcis, puis le fichier raccourcis.txt est fermé : ComboBox1.DataSource = ListeRaccourcis FileClose(1)
Des instructions similaires permettent d’initialiser les deux autres listes déroulantes et les tableaux comment2(), HotKey(), chemin(), clé() et valeur(). Pour compléter cette procédure, définissez les objets ci-après : Dim Dim Dim Dim Dim Dim Dim Dim
cd As String ListeRaccourcis As New Collections.ArrayList() ListeAstuces As New Collections.ArrayList() ListePerso As New Collections.ArrayList() i As Integer Comment1(9), commande1(9) As String Comment2(21) As String HotKey(22), chemin(22), clé(22), valeur(22) As String
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
396
Visual Basic 2010
Vous allez maintenant définir les actions correspondant aux contrôles de chaque onglet. Sous l’onglet 1, le programme doit réagir aux choix dans la liste déroulante et au clic sur le bouton de commande. Basculez dans la fenêtre de code, sélectionnez le contrôle ComboBox1 dans la première liste déroulante et l’événement SelectedIndexChanged dans la deuxième. Ajoutez l’instruction suivante à la procédure ComboBox1_SelectedIndexChanged() : Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged Label1.Text = Comment1(ComboBox1.SelectedIndex + 1) End Sub
L’unique instruction de cette procédure initialise le contenu du label en fonction de l’entrée sélectionnée dans la liste déroulante. ComboBox1.SelectedIndex renvoie le numéro de l’entrée sélectionnée dans la liste déroulante. Pour accéder à l’information correspondante, il suffit de se servir de cette information comme index dans le tableau comment1(). Double-cliquez sur le bouton de commande et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click Dim s As String s = commande1(ComboBox1.SelectedIndex + 1) Shell(s, 1) End Sub
L’index de l’entrée sélectionnée dans la liste déroulante est utilisé pour trouver la commande correspondante dans le tableau commande1(). Le libellé de la commande est stocké dans l’objet String s : Dim s As String s = commande1(ComboBox1.SelectedIndex + 1)
La troisième instruction utilise la fonction Shell() pour exécuter la commande qui se trouve dans la variable s : Shell(s, 1)
Passons au deuxième onglet. Basculez dans la fenêtre de code. Sélectionnez le contrôle ComboBox2 dans la première liste déroulante et l’événement SelectedIndexChanged dans la deuxième. Ajoutez l’instruction suivante à la procédure ComboBox2_SelectedIndexChanged() : Private Sub ComboBox2_SelectedIndexChanged(ByVal sender As System.Object,
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 17
Personnaliser Windows 7
397
„ ByVal e As System.EventArgs) Handles ComboBox2.SelectedIndexChanged Label2.Text = Comment2(ComboBox2.SelectedIndex + 1) End Sub
Cette procédure ressemble beaucoup à ComboBox1_SelectedIndexChanged (). L’index de l’entrée sélectionnée dans la liste est utilisé pour trouver l’information correspondante dans le tableau comment2(). Cette information est affectée à la propriété Text du label et apparaît dans le cadre. Nous allons maintenant nous occuper du troisième onglet. Double-cliquez sur le bouton de commande et complétez la procédure Button2_Click() comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button2.Click Dim hk, ch, c, v, t As String Dim key As RegistryKey hk = LCase(HotKey(ComboBox3.SelectedIndex + 1)) ch = chemin(ComboBox3.SelectedIndex + 1) c = clé(ComboBox3.SelectedIndex + 1) v = valeur(ComboBox3.SelectedIndex + 1) If hk = "classesroot" Then key = Registry.ClassesRoot.OpenSubKey(ch, True) If hk = "currentconfig" Then key = Registry.CurrentConfig.OpenSubKey(ch, True) If hk = "currentuser" Then key = Registry.CurrentUser.OpenSubKey(ch, True) If hk = "dyndata" Then key = Registry.DynData.OpenSubKey(ch, True) If hk = "localmachine" Then key = Registry.LocalMachine.OpenSubKey(ch, True) If hk = "performancedata" Then key = Registry.PerformanceData.OpenSubKey(ch, True) If hk = "users" Then key = Registry.Users.OpenSubKey(ch, True) If t = "REG_SZ" Then key.SetValue(c, v) If t = "REG_DWORD" Then key.SetValue(c, v, Microsoft.Win32.Registry„ ValueKind.DWord) key.Close() End Sub
Les deux premières instructions définissent les objets utilisés dans la procédure : Dim hk, ch, c, v, t As String Dim key As RegistryKey
Pour pouvoir déclarer un objet RegistryKey, vous devez ajouter une instruction Imports en début de listing : Imports Microsoft.Win32
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
398
Visual Basic 2010
Dans le bloc d’instructions suivant, l’index de l’entrée sélectionnée dans la liste déroulante (ComboBox3.SelectedIndex) est utilisé pour extraire les informations des tableaux HotKey(), chemin(), clé() et valeur(). Ces données sont mémorisées dans les variables hk, ch, c et v : hk = LCase(HotKey(ComboBox3.SelectedIndex + 1)) ch = chemin(ComboBox3.SelectedIndex + 1) c = clé(ComboBox3.SelectedIndex + 1) v = valeur(ComboBox3.SelectedIndex + 1)
Le bloc d’instructions suivant fait appel à la procédure OpenSubKey() pour ouvrir une clé dans le Registre. L’instruction Registry.xxx.OpenSubKey() à utiliser dépend de la hotkey : If hk = "classesroot" Then key = Registry.ClassesRoot.OpenSubKey(ch, True) If hk = "currentconfig" Then key = Registry.CurrentConfig.OpenSubKey(ch, True) If hk = "currentuser" Then key = Registry.CurrentUser.OpenSubKey(ch, True) If hk = "dyndata" Then key = Registry.DynData.OpenSubKey(ch, True) If hk = "localmachine" Then key = Registry.LocalMachine.OpenSubKey(ch, True) If hk = "performancedata" Then key = Registry.PerformanceData.OpenSubKey(ch, True) If hk = "users" Then key = Registry.Users.OpenSubKey(ch, True)
Lorsque la clé a été ouverte, une valeur est définie à l’aide de la procédure SetValue() puis la clé est fermée : If t = "REG_SZ" Then key.SetValue(c, v) If t = "REG_DWORD" Then key.SetValue(c, v, Microsoft.Win32.RegistryValueKind.DWord) key.Close()
L’application est entièrement opérationnelle et prête à l’emploi. Vous pouvez à loisir compléter cette base de données en utilisant des informations complémentaires sur les revues, les livres d’informatique et les sites web dédiés à Windows 7. Pour compléter l’un des trois fichiers qui composent la base de données (astuces.txt, perso.txt et raccourcis. txt), un simple éditeur de texte suffit. Vous pouvez, par exemple, utiliser le Bloc-notes de Windows. Dans tous les cas, veillez à respecter la structure de chaque fichier et l’ordre alphabétique des informations affichées dans les listes déroulantes. Voici le listing complet du programme. Les fichiers du projet se trouvent dans le dossier Projects\Tweak7 des sources de l’ouvrage après leur installation. Imports Microsoft.Win32 Public Class Form1 Dim cd As String Dim ListeRaccourcis As New Collections.ArrayList() Dim ListeAstuces As New Collections.ArrayList() Dim ListePerso As New Collections.ArrayList()
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 17
Dim Dim Dim Dim
Personnaliser Windows 7
399
i As Integer Comment1(9), commande1(9) As String Comment2(21) As String HotKey(22), chemin(22), clé(22), valeur(22), TypeVal(22) As String
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load ‘ -----------------------------------------------‘ Lecture du fichier de données du premier onglet ‘ -----------------------------------------------cd = CurDir() FileOpen(1, cd + "\raccourcis.txt", OpenMode.Input) For i = 1 To 8 ListeRaccourcis.Add(LineInput(1)) Comment1(i) = LineInput(1) commande1(i) = LineInput(1) Next ComboBox1.DataSource = ListeRaccourcis FileClose(1) ‘ -----------------------------------------------‘ Lecture du fichier de données du deuxième onglet ‘ -----------------------------------------------FileOpen(1, cd + "\astuces.txt", OpenMode.Input) For i = 1 To 15 ListeAstuces.Add(LineInput(1)) Comment2(i) = LineInput(1) Next ComboBox2.DataSource = ListeAstuces FileClose(1) ‘ -----------------------------------------------‘ Lecture du fichier de données du troisième onglet ‘ -----------------------------------------------FileOpen(1, cd + "\perso.txt", OpenMode.Input) For i = 1 To 7 ListePerso.Add(LineInput(1)) HotKey(i) = LineInput(1)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
400
Visual Basic 2010
chemin(i) = LineInput(1) clé(i) = LineInput(1) valeur(i) = LineInput(1) TypeVal(i) = LineInput(1) Next ComboBox3.DataSource = ListePerso FileClose(1) End Sub Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ComboBox1.SelectedIndexChanged Label1.Text = Comment1(ComboBox1.SelectedIndex + 1) End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click Dim s As String s = commande1(ComboBox1.SelectedIndex + 1) Shell(s, 1) End Sub Private Sub ComboBox2_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ComboBox2.SelectedIndexChanged Label2.Text = Comment2(ComboBox2.SelectedIndex + 1) End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. EventArgs) Handles Button2.Click Dim hk, ch, c, v, t As String Dim key As RegistryKey hk = LCase(HotKey(ComboBox3.SelectedIndex + 1)) ch = chemin(ComboBox3.SelectedIndex + 1) c = clé(ComboBox3.SelectedIndex + 1) v = valeur(ComboBox3.SelectedIndex + 1) t = TypeVal(ComboBox3.SelectedIndex + 1) If hk = "classesroot" Then key = Registry.ClassesRoot.OpenSubKey(ch, True) If hk = "currentconfig" Then key = Registry.CurrentConfig.OpenSubKey(ch, True) If hk = "currentuser" Then key = Registry.CurrentUser.OpenSubKey(ch, True) If hk = "dyndata" Then key = Registry.DynData.OpenSubKey(ch, True)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 17
Personnaliser Windows 7
401
If hk = "localmachine" Then key = Registry.LocalMachine.OpenSubKey(ch, True) If hk = "performancedata" Then key = Registry.PerformanceData. „ OpenSubKey(ch, True) If hk = "users" Then key = Registry.Users.OpenSubKey(ch, True) If t = "REG_SZ" Then key.SetValue(c, v) If t = "REG_DWORD" Then key.SetValue(c, v, Microsoft.Win32.Registry„ ValueKind.DWord) key.Close() End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
18 Visual Basic et Microsoft Office Les applications de la suite Microsoft Office peuvent être commandées par des programmes externes, écrits avec un langage de script, tel que VBA, ou un langage compilé tel que Visual Basic 2010. Dans ce chapitre, nous allons vous montrer comment manipuler les applications Word et Excel en utilisant la technique de l’OLE Automation.
Prise de contrôle de Microsoft Word Cette section explique comment accéder à Microsoft Word en utilisant des objets dynamiques OLE Automation. L’application présentée permet d’effectuer les actions suivantes :
∑ ∑
ouverture et fermeture de Word ; création d’un nouveau document vierge ;
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
404
∑ ∑ ∑
Visual Basic 2010
ouverture d’un document existant ; modification du document ouvert ; sauvegarde du document en cours d’édition.
Mise en place visuelle Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom Word à l’application et validez en cliquant sur OK. Déposez sept contrôles Button et un contrôle TextBox sur la feuille. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau ci-après. Contrôle
Propriété
Valeur
Form1
Text
Manipulation de Word
Button1
Text
Ouvrir Word
Button2
Text
Nouveau document
Button3
Text
Fermer Word
Button4
Text
Ouvrir le fichier exemple
Button5
Text
Taille des caractères = 15 points
Button6
Text
Texte en italique
Button7
Text
Sauvegarder le fichier et quitter Word
Edit
Text
c:\exemple.doc
Repositionnez et redimensionnez les contrôles pour obtenir une feuille semblable à celle montrée à la Figure 18.1. Figure 18.1 La feuille de l’application Manipulation de Word, en mode Édition.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 18
Visual Basic et Microsoft Office
405
Définition des procédures de traitement Définissez les trois variables Object suivantes, juste après l’instruction Public Class Form1 : Dim WordApp As Object Dim WordDoc As Object Dim WordRng As Object
Ces variables seront utilisées pour manipuler l’application Word et les documents ouverts. Double-cliquez sur le bouton Ouvrir Word et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click WordApp = CreateObject("Word.Application") WordApp.Visible = True End Sub
La première instruction instancie l’objet WordApp. La seconde instruction provoque l’exécution de l’application Microsoft Word. Double-cliquez sur le bouton Nouveau document et complétez la procédure Button2_ Click() comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button2.Click WordDoc = WordApp.Documents.Add() End Sub
L’unique instruction de cette procédure ouvre un document vierge, Add(), dans l’application Microsoft Word. Double-cliquez sur le bouton Fermer Word et complétez la procédure Button3_Click() comme suit : Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button3.Click WordApp.Quit() End Sub
Vous l’aurez compris, l’unique instruction de cette procédure ferme la fenêtre de l’application Microsoft Word. Double-cliquez sur le bouton Ouvrir le fichier exemple. Voici le code de la procédure Button4_Click() : Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button4.Click WordDoc = WordApp.Documents.Open(TextBox1.Text) End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
406
Visual Basic 2010
Pour ouvrir le document dont le nom est spécifié dans la zone de texte, il suffit d’invoquer la procédure Open(). Nous allons maintenant définir le code relatif aux traitements. Double-cliquez sur le bouton Taille des caractères = 15 points et complétez la procédure Button5_Click() comme suit : Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button5.Click WordDoc = WordApp.ActiveDocument WordRng = WordDoc.Range WordRng.Font.Size = 15 End Sub
La première instruction affecte le document actif à l’objet WordDoc : WordDoc = WordApp.ActiveDocument
La deuxième instruction définit le domaine d’action de la troisième instruction (ici tout le document) : WordRng = WordDoc.Range
Enfin, la troisième instruction modifie la taille des caractères : WordRng.Font.Size = 15
La même technique permet d’appliquer l’attribut Italique à la totalité du document. Doublecliquez sur le bouton Texte en italique et complétez la procédure Button6_Click() comme suit : Private Sub Button6_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button6.Click WordDoc = WordApp.ActiveDocument WordRng = WordDoc.Range WordRng.Font.Italic = True End Sub
Pour terminer, double-cliquez sur le bouton Sauvegarder le fichier et quitter Word et complétez la procédure Button7_Click() comme suit : Private Sub Button7_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button7.Click WordDoc.Save() WordApp.Quit() End Sub
La première instruction sauvegarde le document et la seconde ferme l’application Microsoft Word.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 18
Visual Basic et Microsoft Office
407
Exécution de l’application Appuyez sur la touche F5 pour lancer l’application et vérifiez le bon fonctionnement de tous les boutons de commande. Voici le listing complet de l’application. Ce projet se trouve dans le dossier Projects\Word des sources de l’ouvrage. Public Class Form1 Dim WordApp As Object Dim WordDoc As Object Dim WordRng As Object Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click WordApp = CreateObject("Word.Application") WordApp.Visible = True End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click WordDoc = WordApp.Documents.Add() End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button3.Click WordApp.Quit() End Sub Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button4.Click WordDoc = WordApp.Documents.Open(TextBox1.Text) End Sub Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button5.Click WordDoc = WordApp.ActiveDocument WordRng = WordDoc.Range WordRng.Font.Size = 15 End Sub Private Sub Button6_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button6.Click WordDoc = WordApp.ActiveDocument WordRng = WordDoc.Range WordRng.Font.Italic = True End Sub Private Sub Button7_Click(ByVal sender As System.Object, ByVal e As System.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
408
Visual Basic 2010
„ EventArgs) Handles Button7.Click WordDoc.Save() WordApp.Quit() End Sub End Class
Prise de contrôle de Microsoft Excel Cette section explique comment accéder à Microsoft Excel en utilisant des objets dynamiques OLE Automation. Cette application propose les fonctionnalités suivantes :
∑ ∑ ∑ ∑ ∑
ouverture et fermeture d’Excel ; création d’un nouveau classeur ; ouverture d’un classeur existant ; modification d’une feuille du classeur ouvert ; sauvegarde du classeur en cours d’édition.
Mise en place visuelle Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom Excel au projet et validez en cliquant sur OK. Déposez sept boutons de commande et une zone de texte sur la feuille, de la même façon que dans l’application Word précédente. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau ci-après. Contrôle
Propriété
Valeur
Form1
Text
Manipulation d’Excel
Button1
Text
Ouvrir Excel
Button2
Text
Nouveau classeur
Button3
Text
Fermer Excel
Button4
Text
Ouvrir le fichier exemple
Button5
Text
Divise la cellule B2 par 2
Button6
Text
Change la couleur de B2-C4
Button7
Text
Sauvegarder le fichier exemple
Edit
Text
c:\exemple.xls
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 18
Visual Basic et Microsoft Office
409
Repositionnez et redimensionnez les contrôles pour obtenir une feuille analogue à celle montrée à la Figure 18.2. Figure 18.2 La feuille de l’application Manipulation d’Excel, en mode Édition.
Définition des procédures de traitement Définissez les variables ci-après à la suite de la déclaration Public Class Form1 : Dim Dim Dim Dim
ExcelApp As Object ExcelCla As Object ExcelFeuille As Object ExcelPlage As Object
Double-cliquez sur le bouton Ouvrir Excel et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button1.Click ExcelApp = CreateObject("Excel.Application") ExcelApp.Visible = True End Sub
La première instruction instancie l’objet ExcelApp et la seconde ouvre la fenêtre de l’application associée à cet objet. Double-cliquez sur le bouton Nouveau classeur et complétez la procédure Button2_Click() comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button2.Click ExcelCla = ExcelApp.Workbooks.Add() End Sub
L’unique instruction de cette procédure instancie le classeur ExcelCla à l’aide de la méthode Workbooks.Add(). Un nouveau classeur vide est donc ouvert dans Microsoft Excel.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
410
Visual Basic 2010
Double-cliquez sur le bouton Fermer Excel et complétez la procédure Button3_Click() comme suit : Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button3.Click ExcelApp.Quit() End Sub
Vous l’aurez certainement compris, l’unique instruction de cette procédure ferme l’application Microsoft Excel. Double-cliquez sur le bouton Ouvrir le fichier exemple et complétez la procédure Button4_ Click() comme suit : Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button4.Click ExcelCla = ExcelApp.Workbooks.Open(TextBox1.Text) End Sub
La méthode Workbooks.Open() est utilisée pour ouvrir le classeur dont le nom est spécifié dans la zone de texte TextBox1. Le résultat de cette fonction est employé pour instancier l’objet ExcelCla. Double-cliquez sur le bouton Diviser la cellule B2 par 2 et complétez la procédure TForm1. DiviseB2Click() comme suit : Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button5.Click ExcelFeuille = ExcelCla.Sheets("Feuil1") Dim c As Single = ExcelFeuille.Cells.Item(2, 2).Value ExcelFeuille.Cells.Item(2, 2).Value = c / 2 End Sub
La première instruction affecte la première feuille du classeur à l’objet ExcelFeuille : ExcelFeuille = ExcelCla.Sheets("Feuil1")
La deuxième instruction définit la variable Single c et lui affecte la valeur contenue dans la cellule B2. Remarquez l’accès à la cellule, Cells.Item(2,2), puis à la valeur contenue dans la cellule, .Value : Dim c As Single = ExcelFeuille.Cells.Item(2, 2).Value
Enfin, la troisième instruction affecte à la cellule B2 la moitié de la valeur qu’elle contenait : ExcelFeuille.Cells.Item(2, 2).Value = c / 2
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 18
Visual Basic et Microsoft Office
411
Avant de définir la procédure relative au bouton Change la couleur de B2-C4, vous allez initialiser la variable booléenne ChangeCouleur à False dans la procédure Form1_Load() : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load ChangeCouleur = False End Sub
Double-cliquez sur le bouton Plage B2-C4 en gras et complétez la procédure Button6_ Click() comme suit : Private Sub Button6_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button6.Click ExcelFeuille = ExcelCla.Sheets("Feuil1") ExcelPlage = ExcelFeuille.Range("B2:C4") ExcelPlage.Font.Bold = True End Sub
La première instruction affecte la première feuille du classeur à l’objet ExcelFeuille : ExcelFeuille = ExcelCla.Sheets("Feuil1")
La deuxième instruction définit l’objet ExcelPlage et lui affecte la plage de cellules B2:C4 : ExcelPlage = ExcelFeuille.Range("B2:C4")
Enfin, la troisième instruction met en gras la plage de cellules sélectionnée : ExcelPlage.Font.Bold = True
Pour terminer le projet, double-cliquez sur le bouton Sauvegarder le classeur et complétez la procédure Button7_Click() comme suit : Private Sub Button7_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button7.Click ExcelCla.Save() End Sub
L’unique instruction de cette procédure sauvegarde le classeur en cours d’édition à l’aide de la méthode Save().
Exécution de l’application Appuyez sur la touche F5 pour lancer l’application et vérifiez le bon fonctionnement de tous les boutons de commande. Voici le listing complet de l’application. Ce projet se trouve dans le dossier Projects\Excel des sources de l’ouvrage.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
412
Visual Basic 2010
Public Class Form1 Dim Dim Dim Dim
ExcelApp As Object ExcelCla As Object ExcelFeuille As Object ExcelPlage As Object
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click ExcelApp = CreateObject("Excel.Application") ExcelApp.Visible = True End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click ExcelCla = ExcelApp.Workbooks.Add() End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button3.Click ExcelApp.Quit() End Sub Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button4.Click ExcelCla = ExcelApp.Workbooks.Open(TextBox1.Text) End Sub Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button5.Click ExcelFeuille = ExcelCla.Sheets("Feuil1") Dim c As Single = ExcelFeuille.Cells.Item(2, 2).Value ExcelFeuille.Cells.Item(2, 2).Value = c / 2 End Sub Private Sub Button6_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button6.Click ExcelFeuille = ExcelCla.Sheets("Feuil1") ExcelPlage = ExcelFeuille.Range("B2:C4") ExcelPlage.Font.Bold = True End Sub Private Sub Button7_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button7.Click ExcelCla.Save() End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
19 Programmation WPF Les applications WPF représentent une alternative complémentaire aux traditionnelles applications Windows Forms. Capables d’être exécutées sous Windows 7, Vista, Windows Vista SP1 et supérieur, Windows XP SP2 et supérieur et Windows Server 2003 SP1 et supérieur, ces applications utilisent le langage XAML et de nouvelles API graphiques pour manipuler simplement des objets 2D et 3D vectoriels et des éléments multimédias. Ce chapitre laisse entrevoir les immenses possibilités des applications WPF. Si vous êtes un programmeur web, rassurez-vous : la plupart des possibilités offertes par WPF sont communes au tout nouveau langage Silverlight (anciennement WPF/e pour WPF everywhere).
Une première application WPF Lancez la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sous Modèles installés, développez Visual Basic, cliquez sur Windows puis sur Application WPF (voir Figure 19.1), puis validez en cliquant sur OK.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
414
Visual Basic 2010
Figure 19.1 Vous êtes sur le point de créer une nouvelle application WPF.
Quelques instants plus tard, Visual Studio revêt un aspect quelque peu inhabituel (voir Figure 19.2). Figure 19.2 L’environnement de développement est différent de celui utilisé pour les projets WinForm.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
415
L’interface de l’application est définie dans le volet central (Concepteur). Très classiquement, il suffit d’y déposer un ou plusieurs contrôles issus de la Boîte à outils de Visual Studio. Au fur et à mesure de l’agencement de l’interface, le volet Design est modifié en conséquence. Ce volet contient la description de l’interface en langage XAML.
Info
Si vous le souhaitez, vous pouvez y insérer des instructions XAML manuel lement, mais il faut avouer qu’il est bien plus simple de passer par le volet du concepteur.
ntion Atte
Le concepteur WPF de Visual Studio Express ne fonctionne que partiellement. Si vous voulez tirer pleinement parti de cette fonctionnalité, vous devrez vous rabattre sur une version commerciale de Visual Studio.
Pour vous faire une première idée de la programmation WPF, nous allons créer un blocnotes qui mémorisera tout ce que vous tapez au clavier. Définissez une nouvelle application WPF. Ajoutez un contrôle TextBox et deux contrôles Button au concepteur et modifiez leurs tailles et emplacement pour obtenir un agencement visuel comparable à celui de la Figure 19.3. Figure 19.3 Le concepteur WPF, après avoir placé et redimensionné les contrôles.
À titre d’information, voici le code XAML créé a partir du concepteur :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
416
Visual Basic 2010
Effacer Quitter
Cliquez successivement sur les deux boutons et modifiez leur propriété Content pour les renommer en "Effacer" et "Quitter" (voir Figure 19.4). Figure 19.4 Les deux boutons ont été renommés.
Vous allez maintenant définir le code de l’application. Lancez la commande Code dans le menu Affichage ou appuyez sur la touche de fonction F7. Sélectionnez Window1Evénements dans la liste déroulante Nom de la classe et Loaded dans la liste déroulante Nom de la méthode. La procédure Window1_Loaded est automatiquement créée : Private Sub Window1_Loaded(ByVal sender As Object, ByVal e As System.Windows. „ RoutedEventArgs) Handles Me.Loaded End Sub
Cette procedure est l’équivalent Windows Form de Form1_Load(). Vous allez la compléter avec les lignes de code suivantes : Private Sub Window1_Loaded(ByVal sender As Object, ByVal e As System.Windows. „ RoutedEventArgs) Handles Me.Loaded tout = "" Try FileOpen(1, "c:\test\memo.txt", OpenMode.Input) While Not EOF(1)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
417
texte = LineInput(1) tout = tout + texte + Chr(13) + Chr(10) End While TextBox1.Text = tout Catch Finally FileClose(1) End Try End Sub
Cette procédure lit le contenu du fichier texte c:\test\memo.txt : tout = "" Try FileOpen(1, "c:\test\memo.txt", OpenMode.Input) While Not EOF(1) texte = LineInput(1) tout = tout + texte + Chr(13) + Chr(10) End While
Ce contenu est affecté à la propriété Text du contrôle TextBox1 : TextBox1.Text = tout
Puis le fichier texte est fermé : Catch Finally FileClose(1) End Try
Pour completer cette procedure, définissez les variables String tout et texte en début de listing : Class Window1 Dim tout As String Dim texte As String
Vous allez maintenant définir les procédures événementielles associées au clic sur les deux boutons. Sélectionnez Button1 dans la liste déroulante Nom de la classe et Click dans la liste déroulante Nom de la méthode, puis complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ Windows.RoutedEventArgs) Handles Button1.Click TextBox1.Text = "" End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
418
Visual Basic 2010
Cette procédure se contente d’effacer le contenu de contrôle TextBox1. Sélectionnez Button2 dans la liste déroulante Nom de la classe et Click dans la liste déroulante Nom de la méthode, puis complétez la procédure Button2_Click() comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ Windows.RoutedEventArgs) Handles Button2.Click Try FileOpen(1, "c:\test\memo.txt", OpenMode.Output) Print(1, TextBox1.Text) Catch Finally FileClose(1) End Try End End Sub
Comme vous pouvez le voir, cette procédure sauvegarde le contenu du contrôle textBox dans le fichier texte c:\test\memo.txt : Try FileOpen(1, "c:\test\memo.txt", OpenMode.Output) Print(1, TextBox1.Text)
Puis referme le fichier texte : Catch Finally FileClose(1) End Try
Info
Pour définir la procédure événementielle d’un bouton, il est également possible de double-cliquer dessus dans le volet du concepteur. Le gabarit de la procédure est alors automatiquement créé.
Le programme est entièrement opérationnel. Appuyez sur la touche de fonction F5 pour l’exécuter (voir Figure 19.5).
Info
Si vous redimensionnez la fenêtre de l’application (et c’est là un des gros avantages des applications WPF), les contrôles seront automatiquement redimensionnés à la volée.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
419
Figure 19.5 Une ligne de texte a été mémorisée dans le contrôle TextBox.
Les contrôles WPF par défaut Cette section fait le tour des contrôles disponibles par défaut dans une application WPF. Icône
Contrôle
Fonction
Border
Bordure autour d’un contenu.
Button
Permet à l’utilisateur d’effectuer une action lorsqu’il clique sur le bouton.
Canvas
Définit une zone dans laquelle des éléments enfants peuvent être positionnés à l’aide des coordonnées relatives à la zone du Canvas
CheckBox
Case à cocher.
ComboBox
Contrôle de sélection assorti d’une liste déroulante qui peut être affichée ou masquée d’un clic sur la flèche du contrôle.
ContentControl
Conteneur destinée à héberger un type unique de contenu.
DockPanel
Définit une zone où les éléments enfants peuvent être réorganisés horizontalement ou verticalement l’un par rapport à l’autre.
DocumentViewer
Conteneur pouvant héberger un objet FixedDocument.
Ellipse
Trace une ellipse.
Expander
Ce contrôle est composé d’un en-tête et d’une fenêtre réductible affichant un contenu.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
420
Icône
Visual Basic 2010
Contrôle
Fonction
Frame
Contrôle de contenu qui prend en charge la navigation.
Grid
Grille flexible qui se compose de lignes et de colonnes.
GridSplitter
Répartit l’espace entre les lignes ou les colonnes d’un contrôle Grid.
GroupBox
Zone de groupe, utilisée pour rassembler plusieurs contrôles.
Image
Affiche une image.
Label
Affiche un texte sur un formulaire.
ListBox
Liste déroulante.
ListView
Ce contrôle regroupe une liste d’éléments.
MediaElement
Conteneur audio ou vidéo.
Menu
Menu Windows.
PasswordBox
Contrôle dédié à la saisie d’un mot de passe.
ProgressBar
Indique la progression d’une opération.
RadioButton
Bouton radio. Permet à l’utilisateur de choisir un élément dans un ensemble où les différents éléments sont mutuellement exclusifs.
Rectangle
Trace un rectangle.
RichTextBox
Conteneur de documents riches de type FlowDocument.
ScrollBar
Barre défilante vertical ou horizontale.
ScrollViewer
Zone dont le contenu peut défiler.
Separator
Séparateur de contrôles.
Slider
Ce contrôle permet de sélectionner une valeur dans une plage.
StackPanel
Permet d’empiler des contrôles enfants, verticalement ou horizonta lement.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Icône
Programmation WPF
421
Contrôle
Fonction
StatusBar
Contrôle barre d’état.
TabControl
Arrange le contenu visual sous la dorme d’un tableau.
TextBox
Zone de texte utilisée pour saisir le texte entré au clavier par l’utilisateur.
ToolBar
Contrôle barre d’outils.
ToolBarPanel
Permet d’organiser les divers éléments inclus dans un contrôle ToolBar.
ToolBarTray
Gère la disposition des éléments contenus dans un contrôle ToolBar.
Treeview
Ce contrôle affiche une arborescence dans laquelle les divers éléments peuvent être pliés et dépliés.
ViewBox
Décorateur de contenu utilisé pour ajuster un contrôle enfant afin d’occuper l’espace disponible.
WindowsFormsHost
Conteneur de contrôle Windows Forms dans une page WPF.
WrapPanel
Ce contrôle positionne séquentiellement, de gauche à droite, des éléments enfants.
Manipuler des éléments multimédias Le contrôle MediaElement permet de manipuler des éléments multimédias vidéo (au format avi, jpg, mpg ou .wmv) et audio (au format mid ou wma). Ces éléments peuvent se trouver sur l’ordinateur, sur un des ordinateurs d’un réseau local ou sur Internet. Dans cette mini-application, nous allons utiliser un contrôle MediaElement pour jouer :
∑ ∑
un diaporama web au format wmv ; un fichier local au format mid.
Créez une nouvelle application WPF, insérez un contrôle MediaElement, deux contrôles RadioButton et deux contrôles Button sur la feuille de l’application. Positionnez, redimensionnez et modifiez la propriété Content de ces contrôles pour obtenir quelque chose comme à la Figure 19.6.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
422
Visual Basic 2010
Figure 19.6 La fenêtre de l’application WPF.
Info
Pour assurer un ancrage dans la partie gauche de la fenêtre pour les contrôles RadioButton et Button, veillez à initialiser leur propriété HorizontalAlignment à Left.
Double-cliquez sur le bouton Jouer et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ Windows.RoutedEventArgs) Handles Button1.Click If RadioButton1.IsChecked Then MediaElement1.Source = New Uri("http://lem.korp.free.fr/divers/usa.wmv") MediaElement1.LoadedBehavior = MediaState.Play End If If RadioButton2.IsChecked Then MediaElement1.Source = New Uri("c:\windows\media\flourish.mid") MediaElement1.LoadedBehavior = MediaState.Play End If End Sub
Cette procédure est composée de deux blocs If End If dans lesquels on teste l’état des boutons radio. Si le premier bouton radio est sélectionné, la propriété Source du contrôle MediaElement est initialisée avec l’adresse URL d’un média vidéo sur le Web, et le média est lu : If RadioButton1.IsChecked Then MediaElement1.Source = New Uri("http://lem.korp.free.fr/divers/usa.wmv") MediaElement1.LoadedBehavior = MediaState.Play End If
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
423
Si le deuxième bouton radio est sélectionné, la propriété Source du contrôle MediaElement est initialisée avec le chemin d’un fichier audio local, et le média est lu : If RadioButton2.IsChecked Then MediaElement1.Source = New Uri("c:\windows\media\flourish.mid") MediaElement1.LoadedBehavior = MediaState.Play End If
Double-cliquez sur le bouton Arrêter et complétez la procédure Button2_Click comme suit : Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ Windows.RoutedEventArgs) Handles Button3.Click MediaElement1.LoadedBehavior = MediaState.Stop End Sub
Quel que soit le type de media en cours d’exécution, cette procedure se contente d’y mettre fin en invoquant la méthode MediaState.Stop. Après installation des sources de l’ouvrage, cette mini-application se trouve dans le dossier Wpf-Media.
Graphiques 2D WPF propose des fonctionnalités graphiques et d’animation bien plus avancées que celles accessibles aux Windows Forms via GDI (Graphics Device Interface). Pour tracer un élément en deux dimensions, vous utiliserez les contrôles Ellipse et Rectangle de la Boîte à outils. Vous agirez sur les propriétés de ces objets pour modifier la façon dont ils s’affichent : Propriété
Signification
BitmatEffect
Effet appliqué à l’objet : BlurBitmapEffect, EmbossBitmapEffect, BevelBitmapEffect, DrowShadowBitmapEffect ou OuterGlowBitmapEffect
BitmapEffect/BevelWidth
Largeur de la bordure
BitmapEffect/LightAngle
Angle d’éclairage de l’objet
Fill
Couleur de tracé, à choisir dans une liste prédéfinie, de AliceBlue à YellowGreen
La Figure 19.7 représente quelques exemples d’utilisation de ces propriétés sur des objets Ellipse. Le code correspondant se trouve dans le dossier Projects\Wpf-Ellipse des codes sources de l’ouvrage après leur installation.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
424
Visual Basic 2010
Figure 19.7 Les objets Ellipse peuvent avoir des aspects très différents.
Géométries 2D La classe Geometry permet de décrire la géométrie des formes 2D. En l’état de développement actuel de Visual Strudio 2010, la Boîte à outils n’implémente pas les géométries. Vous devrez donc écrire le code correspondant manuellement, dans le volet XAML. Les lignes suivantes vous montrent comment tracer les géométries les plus courantes.
Info
Les couleurs utilisées comme paramètres des marqueurs de géométrie XAML peuvent être spécifiées en clair (red, black, yellow, etc.) ou sous la forme d’un nombre hexadécimal à 8 digits : #abcdefgh
où : • ab représente la transparence alpha : entre 00 (transparent) et FF (opaque) ; • cd représente la composante rouge de la couleur ; • ef représente la composante verte de la couleur ; • gh représente la composante bleue de la couleur.
Segments de droites Pour tracer un segment de droite, vous utiliserez le marqueur . Par exemple, pour tracer une droite de couleur rouge et d’épaisseur 5 entre les coordonnées 10, 10 et 200, 300, vous utiliserez les instructions suivantes (voir Figure 19.8).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
425
Figure 19.8 Tracé d’une droite rouge d’épaisseur 5.
Polygones Pour tracer un polygone, vous utiliserez le marqueur . À titre d’exemple, le code ci-après trace un carré d’épaisseur 3, de couleur CornglowerBlue entre les coordonnées 50,50 et 250,250 (voir Figure 19.9) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
426
Visual Basic 2010
Figure 19.9 Tracé d’un carré avec PolyLineSegment.
Arcs elliptiques Pour tracer un arc de cercle ou d’ellipse, vous utiliserez le marqueur . Par exemple, pour tracer un arc d’ellipse entre les points 50,50 et 50,150, vous utiliserez les instructions suivantes (voir Figure 19.10) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
427
Figure 19.10 Tracé d’un arc d’ellipse avec ArcSegment.
Info
Pour simplifier l’écriture du code XAML, vous pouvez utiliser la syntaxe abrégée suivante :
Courbes de Bézier Pour tracer des courbes de Bézier1, vous utiliserez les marqueurs suivants : Marqueur
Description
Courbe de Bézier cubique entre deux points
Série de courbes de Bézier cubiques
.
Courbe de Bézier quadratique
Série de courbes de Bézier quadratiques
Pour tracer une courbe de Bézier cubique entre les points 10,100 et 300,200, en utilisant les points de contrôle 100,0 et 200,300, vous utiliserez les instructions suivantes (voir Figure 19.11) : 1. Les courbes de Bézier sont des courbes polynomiales décrites par l’ingénieur français Pierre Bézier, en 1962. Elles peuvent être linéaires (équations de degré 1), quadratiques (équations de degré 2) ou cubiques (équations de degré 3).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
428
Visual Basic 2010
Figure 19.11 Tracé d’une courbe de Bézier cubique.
Info
Pour simplifier l’écriture du code XAML, vous pouvez utiliser la syntaxe abrégée suivante :
Pour tracer une courbe de Bézier quadratique entre les points 10,100 et 200,100, en utilisant le point de contrôle 300,200, vous utiliserez les instructions suivantes (voir Figure 19.12) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
429
Figure 19.12 Tracé d’une série de courbes de Bézier quadratique.
Pour simplifier l’écriture du code XAML, vous pouvez utiliser la syntaxe abrégée suivante :
Info
Ellipses Pour tracer une ellipse, vous utiliserez le marqueur . À titre d’exemple, pour tracer une ellipse de contour rouge épais de 3 pixels, remplie en vert, de centre 150,150, de rayon X 100 et de rayon Y 50, vous utiliserez les instructions suivantes (voir Figure 19.13) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
430
Visual Basic 2010
Figure 19.13 Tracé d’une ellipse avec .
Rectangles Pour tracer un rectangle, vous utiliserez le marqueur . À titre d’exemple, pour tracer un rectangle de contour noir épais de 1 pixel, rempli en rouge, entre les points de coordonnées 50,50 et 200,100, vous utiliserez les instructions suivantes (voir Figure 19.14) :
Figure 19.14 Tracé d’un rectangle avec .
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
431
Géométries combinées Vous pouvez utiliser le mode Exclude (exclusion), Intersect (intersection), Union (réunion) ou Xor (ou exclusif) pour combiner deux formes géométriques. Par exemple, pour définir l’union entre un rectangle dont les bords opposés ont pour coordonnées 50,50 et 200,10 et une ellipse de centre 125,75 et de rayons X et Y 50, vous utiliserez les instructions suivantes (voir Figure 19.15) :
Figure 19.15 Union d’un rectangle et d’un cercle.
En appliquant le mode Xor à ces deux objets, le résultat est totalement différent (voir Figure 19.16) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
432
Visual Basic 2010
Figure 19.16 Ou exclusif entre un rectangle et un cercle.
L’effet est également intéressant lorsque le paramètre StrokeThickness est initialisé à 0 (voir Figure 19.17). Figure 19.17 Ou exclusif entre un rectangle et un cercle, sans bordures.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
433
Le pinceau Pour remplir une forme géométrique avec une couleur unie, il suffit de spécifier cette couleur dans le paramètre Fill. À titre d’exemple, les instructions ci-après définissent un rectangle à bord noir et le remplissent avec la couleur jaune (voir Figure 19.18) :
Pour créer un rectangle centré sur la zone d’affichage, vous pouvez également utiliser la syntaxe simplifiée suivante :
Figure 19.18 Remplissage uniforme d’une figure 2D.
Le remplissage peut également s’effectuer en utilisant un gradient de couleurs. Vous utiliserez pour cela les marqueurs et . Par exemple, pour créer un rectangle centré de largeur 200, de hauteur 100 et dont la couleur varie du jaune au rouge, du bord supérieur gauche (0.0) au bord inférieur droit (1.1), vous utiliserez les instructions suivantes (voir Figure 19.19) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
434
Visual Basic 2010
Figure 19.19 Dégradé uniforme d’un côté du rectangle au côté opposé.
Rien ne vous empêche d’utiliser plusieurs marqueurs pour réaliser autant de dégradés que nécessaire dans le même objet (voir Figure 19.20) :
Figure 19.20 Quatre dégradés de couleurs ont été insérés dans ce rectangle.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
435
Pour modifier le sens du dégradé, il suffit de changer les paramètres StartPoint et/ou EndPoint du marqueur . Ici, par exemple, nous définissons un gradient de couleur horizontal (voir Figure 19.21).
Figure 19.21 Dégradé de couleurs horizontal.
Et ici, un gradient de couleurs vertical (voir Figure 19.22).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
436
Visual Basic 2010
Figure 19.22 Dégradé de couleurs vertical.
Les objets peuvent également être remplis par des images en utilisant le marqueur . L’image est automatiquement redimensionnée pour occuper l’espace qui lui est alloué dans l’application (voir Figure 19.23).
Figure 19.23 Remplissage avec une image.
Le remplissage d’image peut également être utilisé sur un texte (voir Figure 19.24) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
437
Texte texturé
Figure 19.24 Remplissage d’un texte avec une image.
Info
Vous pouvez également utiliser un dessin (marqueur ) ou un visuel (marqueur ) pour peindre un objet. Vous trouverez des renseignements complémentaires à ce sujet sur la page http://msdn2.microsoft. com/fr-fr/library/aa970904.aspx.
Géométries 3D Pour afficher un objet 3D, vous procéderez selon les quatre étapes décrites ci-après. Dans cet exemple, nous afficherons une pyramide de couleur verte.
Étape 1 – Définition d’un objet Viewport3D L’objet Viewport va permettre de positionner la scène sur le cannevas :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
438
Visual Basic 2010
Étape 2 – Définition d’une caméra Le marqueur va vous permettre de décrire le point d’observation :
Imaginez qu’un observateur regarde votre scène 3D :
∑ ∑ ∑ ∑ ∑
Position est la position de l’observateur ; LookDirection définit la position observée ; UpDirection définit l’inclinaison vers le haut ; FieldOfView définit l’angle de visibilité de la scène ; NearPlaneDistance définit la profondeur de vue.
Info
Pour comprendre la signification de ces paramètres, le plus simple consiste à expérimenter plusieurs valeurs.
Étape 3 – Définition de l’éclairage Pour être en mesure de voir la scène, vous devez l’éclairer en définissant une lumière. // Définition de la lumière
La lumière peut être ambiante :
Ou directionnelle, c’est-à-dire émise depuis un point particulier :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
439
Étape 4 – Implémentation d’un objet Pour définir un objet, vous devez déclarer sa géométrie en créant un marqueur .
où :
∑ ∑
Positions définit les coordonnées des triangles qui délimitent l’objet ;
∑
TriangleIndices défini si les triangles sont sur une face visible ou cachée.
Normals définit les vecteurs perpendiculaires aux faces des triangles qui délimitent
l’objet ;
Vous devez ensuite définir les couleurs d’avant et d’arrière-plan à l’aide de balises :
Le code XAML complet Voici le code XAML complet. Il correspond aux quatre étapes décrites précédemment :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
440
Visual Basic 2010
La Figure 19.25 représente l’interprétation de ce code dans le volet Design de Visual Studio 2010. Figure 19.25 La pyramide apparaît en 3D.
Cette première approche des géométries 3D dans le langage XAML est loin d’être exhaustive. Pour aller plus loin, je ne saurais trop vous conseiller de consulter le site MSDN, à l’adresse http://msdn2.microsoft.com/fr-fr/library/system.windows.media.media3d. aspx.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
441
Transformations 2D Plusieurs types de transformations peuvent être effectués sur les objets 2D créés en XAML : Classe
Description
RotateTransform
Fait pivoter l’objet
ScaleTransform
Modifie l’échelle de l’objet selon les valeurs ScaleX et ScaleY spécifiées
SkewTransform
Incline l’objet selon les valeurs AngleX et AngleY spécifiées
TranslateTransform
Déplace l’objet selon les valeurs X et Y spécifiées
Nous allons partir du rectangle XAML défini par les instructions ci-après :
Rotation Figure 19.26 L’objet Rectangle, avant et après la rotation.
Pour effectuer une rotation, vous définirez un marqueur . Ici, par exemple, nous effectuons une rotation de centre 175,100 et d’angle 45° (voir Figure 19.26) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
442
Visual Basic 2010
Modification de l’échelle Pour effectuer une modification d’échelle, vous définirez un marqueur . Ici, par exemple, nous effectuons une réduction d’échelle à 20% de la taille initiale, centrée sur les coordonnées 175,150 (voir Figure 19.27) :
Figure 19.27 L’objet Rectangle, avant et après la modification d’échelle.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
443
Inclinaison Pour effectuer une inclinaison, vous définirez un marqueur . Ici, par exemple, nous effectuons une inclinaison de centre 100,100, et d’angles 45,10 selon les axes X et Y (voir Figure 19.28) :
Figure 19.28 L’objet Rectangle, avant et après l’inclinaison.
Translation Pour effectuer une translation, vous définirez un marqueur . Ici, par exemple, nous effectuons une translation de 50 points sur les axes X et Y (voir Figure 19.29) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
444
Visual Basic 2010
Figure 19.29 L’objet Rectangle, avant et après la translation.
Transformations 3D Plusieurs types de transformations peuvent être effectués sur les objets 3D créés en XAML : Classe
Description
RotateTransform3D
Fait pivoter l’objet
ScaleTransform3D
Modifie l’échelle de l’objet selon les valeurs ScaleX, ScaleY et ScaleZ spécifiées
TranslateTransform3D
Déplace l’objet selon les valeurs X, Y et Z spécifiées
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
445
Nous allons partir de la pyramide XAML définie dans la section "Géométries 3D". Le code de la transformation sera inséré à la place des trois lignes de commentaire qui apparaissent en gras dans le listing ci-après.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
446
Visual Basic 2010
Rotation Pour effectuer une rotation, vous définirez un marqueur . Ici, par exemple, nous effectuons une rotation de 20 degrés sur les axes X et Y (voir Figure 19.30) :
Figure 19.30 La pyramide, avant et après la rotation.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
447
Modification d’échelle Pour effectuer une modification d’échelle, vous définirez un marqueur . Ici, par exemple, nous affectons un multiplicateur d’échelle 1, 0.5, 2 selon les axes X, Y et Z (voir Figure 19.31) :
Figure 19.31 La pyramide, avant et après la modification d’échelle.
Translation Pour effectuer une translation, vous définirez un marqueur . Ici, par exemple, nous affectons un multiplicateur d’échelle 1, 0.5, 2 selon les axes X, Y et Z (voir Figure 19.32) :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
448
Visual Basic 2010
Figure 19.32 La pyramide, avant et après la translation.
Animations WPF est doté d’un ensemble de fonctionnalités dédiées à l’animation des objets 2D et 3D. Le principe général de l’animation WPF consiste à modifier une ou plusieurs propriétés à intervalles réguliers ou lors des actions de l’utilisateur. Ces modifications peuvent s’effectuer dans le XAML ou dans le code Visual Basic. Dans cette section, nous allons vous montrer comment réaliser une animation sans utiliser le langage Visual Basic.
Animation de couleurs À titre d’exemple, nous allons modifier à intervalles réguliers la couleur et l’opacité d’un SolidolorBrush appliqué à un rectangle. Ces modifications se feront en réaction aux actions de l’utilisateur :
∑
La couleur passera progressivement du rouge au noir lorsque le pointeur de la souris sera placé sur le rectangle.
∑ ∑
La couleur passera du noir au rouge lorsque le pointeur de la souris quittera le rectangle. L’opacité deviendra progressivement totale lorsque l’utilisateur cliquera sur le rectangle.
Dans une premier temps, nous définissons le seul et unique objet de l’application et nous le remplissons d’une couleur uniforme rouge :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
449
Pour animer la couleur du rectangle lorsque la souris le survole, nous définissons une balise et un événement Rectangle.MouseEnter :
L’animation se fait dans la balise . Par touches successives (toutes les secondes), elle modifie la propriété Color de l’objet BrushAnimee jusqu’à obtenir la couleur noire :
La modification de l’opacité est très similaire. Le bloc de code est exécuté lorsque l’utilisateur clique sur le bouton gauche de la souris (MouseLeftButtonDown), au dessus du rectangle (Rectangle). La propriété affectée est Opacity. Les retouches se font toutes les secondes (0:0:1), jusqu’à atteindre une opacité nulle (To "0"), c’est-à-dire la transparence complète : Animation de la propriété Opacity lorsque l’utilisateur clique sur le rectangle
Enfin, le dernier bloc de code est exécuté lorsque le pointeur de la souris sort du rectangle (Rectangle.MouseLeave). Simultanément, les propriétés Color et Opacity sont réajustées : la propriété color passe progressivement au rouge, et la propriété Opacity à une opacité
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
450
Visual Basic 2010
totale (cette dernière animation ne fonctionne que dans la cas où l’utilisateur a précé demment cliqué sur le rectangle, modifiant ainsi son opacité) :
Info
Dans cet exemple, nous avons utilisé le mot-clé To pour spécifier la valeur finale d’une propriété. Vous pouvez également utiliser les mots-clés From et By pour spécifier (respectivement) la valeur de départ et le pas de la progression.
Voici le code XAML complet :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
451
Animer un objet avec ses propriétés Le déplacement d’un objet peut se faire en agissant sur une de ses propriétés. Ici, par exemple, nous allons déplacer un objet Ellipse en agissant sur sa propriété Center par l’intermédiaire d’un PointAnimation.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
452
Visual Basic 2010
Dans un premier temps, nous définissons une ellipse de centre 20,20 et de rayons 15,15. Cette ellipse est remplie avec la couleur rouge et entourée d’une bordure noire épaisse de 3 pixels :
Nous définissons ensuite un gestionnaire d’événements qui se déclenchera à l’exécution du programme :
Il suffit maintenant d’y inclure une balise PointAnimation pour réaliser l’animation de l’ellipse. L’animation s’exécuter indéfiniment (RepeatBehavior="Forever"), elle reviendra automatiquement au point de départ (AutoReverse="True"), elle s’étendra entre les points de coordonnées 20,20 et 200,200 :
Voici le code XAML complet :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
453
Animer un objet avec une transformation À titre d’exemple, nous allons animer la pyramide définie dans la section " Géométries 3D". Pour ce faire, nous définissions un marqueur de transformation :
Puis nous l’animons à l’aide d’un marqueur :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
454
Visual Basic 2010
Voici le code XAML complet :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 19
Programmation WPF
455
Nous n’avons fait qu’effleurer l’animation d’objets en XAML. Cependant, en utilisant les techniques de cette section, vous pouvez mettre en place des animations bien plus complexes et ce, sans qu’aucune ligne de code Visual Basic ne soit nécessaire. Pour aller plus loin dans l’animation XAML, je vous conseille de consulter le site MSDN, et en particulier la page http://msdn2.microsoft.com/fr-fr/library/ms752312.aspx.
Pour aller plus loin Vous avez encore du mal avec les applications WPF ? Vous pouvez :
∑
Visionner le Webcast de Mitsu Furuta, à l’adresse www.microsoft.com/france/vision/ WebcastMsdn.aspx?eID=663df81a-29bb-4290-959f-e48af116acbb.
∑
Vous rendre sur MSDN, à l’adresse http://msdn2.microsoft.com/fr-fr/library/ ms754130.aspx.
∑
Rechercher des ressources complémentaires en effectuant une recherche sur le terme WPF dans votre navigateur web préféré.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
III Programmation Internet Cette troisième partie aborde différents aspects de la programmation Internet. Après avoir appris à composer des numéros de téléphone par l’intermédiaire d’un modem RTC, vous verrez à quel point il est simple de réaliser un client HTTP pour naviguer sur le Web et un client FTP pour télécharger des fichiers. Vous découvrirez également comment réaliser des programmes ASP.NET destinés à être utilisés dans un navigateur web. Enfin, vous apprendrez à consommer et à définir vos propres services web.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
20 Composeur téléphonique Dans ce chapitre, vous allez apprendre à utiliser l’objet My.Computer.Ports pour commander un modem afin de composer des numéros de téléphone (voir Figure 20.1). Figure 20.1 L’application Numéroteur, en mode Exécution.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
460
Visual Basic 2010
Avant de commencer L’application Numéroteur contient :
∑ ∑ ∑ ∑
un système de menus ; une liste modifiable ; une zone de texte ; un bouton de commande.
Le menu Port permet de définir le port sur lequel est connecté le modem (COM1, COM2, COM3 ou COM4). Un des ports peut éventuellement être sélectionné par défaut ; dans notre exemple, il s’agit du port COM2. Dès l’ouverture de l’application, la liste modifiable donne accès aux noms des correspondants. Pour composer un numéro, il suffit de sélectionner un des correspondants. Son numéro de téléphone apparaît dans la zone de texte. Un clic sur le bouton Numéroter déclenche la numérotation. Les méthodes de l’objet My.Computer.Ports permettent d’utiliser les ports série de l’ordinateur pour communiquer, par câble ou par modem, avec d’autres ordinateurs. Pour dialoguer avec un port série, vous devez au préalable l’ouvrir à l’aide de la fonction My.Computer. Ports.OpenSerialPort(). Il suffit alors d’invoquer la procédure Write() pour envoyer des données au modem et la fonction ReadLine() pour en recevoir. Pour communiquer avec un modem, vous utiliserez des commandes de type AT : ATDT45894465; compose le numéro de téléphone 45 89 44 65, ATH interrompt la liaison, ATL0 règle sur faible le volume du haut-parleur.
Mise en place visuelle de l’application Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom NumTel au projet et validez en cliquant sur OK. Ajoutez un contrôle MenuStrip, un contrôle ComboBox, un contrôle TextBox et un contrôle Button à l’application. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau ci-après. Contrôle
Propriété
Valeur
Form1
Caption
Numéroteur téléphonique
ComboBox1
(Name)
Nom
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 20
Composeur téléphonique
Contrôle
Propriété
Valeur
ComboBox1
Sorted
True
ComboBox1
Text
Choisissez un correspondant
TextBox1
Text
TextBox1
(Name)
Numéro
Button1
Text
Composer
461
Pour terminer, vous allez définir le menu de l’application. Cliquez sur la bande représentant le menu. Définissez la commande principale Port et les commandes secondaires COM1, COM2, COM3 et COM4. Donnez enfin les noms COM1 à COM4 [propriété (Name)] aux commandes secondaires de menu. Si vous avez suivi nos indications, la fenêtre de l’application doit maintenant ressembler à la Figure 20.2. Figure 20.2 Tous les contrôles ont été mis en place.
ntion Atte
Si vous envisagez d’utiliser systématiquement le modem sur le même port, affectez la valeur Checked à la propriété CheckState correspondante. Ce port sera ainsi utilisé par défaut.
Définition des procédures de traitement Dès le lancement de l’application, deux tâches doivent être accomplies :
∑ ∑
l’initialisation de la liste modifiable Nom ; la définition du port utilisé pour la numérotation.
Double-cliquez sur un endroit libre de la feuille et complétez la procédure Form1_Load() comme suit :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
462
Visual Basic 2010
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load Dim i As Integer = 1 Try FileOpen(1, "c:\test\agend.txt", OpenMode.Input) Do NomTel(i) = LineInput(1) NumTel(i) = LineInput(1) Nom.Items.Add(NomTel(i)) i = i + 1 Loop Until EOF(1) FileClose() Catch ex As Exception MsgBox("Le fichier c:\test\agend.txt n’existe pas") End Try Max = i - 1 If COM1.Checked If COM2.Checked If COM3.Checked If COM4.Checked End Sub
Then Then Then Then
CommPort CommPort CommPort CommPort
= = = =
1 2 3 4
Les noms des correspondants et les numéros de téléphone sont stockés dans un fichier texte au format ANSI. Ils ne sont pas modifiables par l’application. En revanche, vous pouvez utiliser un traitement de texte ou un éditeur de texte quelconques pour les mettre à jour ou les compléter. Le format utilisé est très simple : Nom du Numéro Nom du Numéro … Nom du Numéro
correspondant 1 du correspondant 1 correspondant 2 du correspondant 2 dernier correspondant du dernier correspondant
Les représentent des passages à la ligne volontaires. Ils correspondent à l’appui sur la touche Entrée du clavier. Après avoir déclaré l’index de boucle i : Dim i As Integer = 1
Une structure FileOpen tente d’ouvrir le fichier c:\test\agend.txt en lecture, à l’intérieur d’une structure Try Catch End Try : Try FileOpen(1, "c:\test\agend.txt", OpenMode.Input)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 20
Composeur téléphonique
463
Si le fichier c:\test\agend.txt a pu être ouvert, l’exécution se poursuit en séquence. La lecture des données se fait à l’intérieur d’une boucle Do Loop : Do NomTel(i) = LineInput(1) NumTel(i) = LineInput(1) Nom.Items.Add(NomTel(i)) i = i + 1 Loop Until EOF(1)
Puis le fichier c:\test\agend.txt est fermé : FileClose()
Si le fichier c:\test\agend.txt n’est pas trouvé, une exception est générée, ce qui provoque l’exécution de l’instruction située après l’instruction Catch : Catch ex As Exception MsgBox("Le fichier c:\test\agend.txt n’existe pas")
La variable Max est mise à jour pour refléter le nombre de données lues dans le fichier c:\test\data.txt : Max = i - 1
Le dernier bloc d’instructions initialise la variable CommPort en fonction de la commande de menu précédée d’une coche : If If If If
COM1.Checked COM2.Checked COM3.Checked COM4.Checked
Then Then Then Then
CommPort CommPort CommPort CommPort
= = = =
1 2 3 4
La procédure Form1_Load() utilise des variables communes à d’autres portions de code. Vous devez donc les déclarer entre l’instruction Public Class Form1 et la déclaration Private de la procédure Form1_Load() : Dim Class Form1 Dim max, CommPort as Integer Dim NomTel(0 To 20), NumTel(0 to 20) As String Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load
Info
Si le nombre de correspondants à stocker est plus important, modifiez le nombre d’éléments des tableaux NumTel et NomTel en conséquence.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
464
Visual Basic 2010
Gestion du menu Port Vous allez maintenant définir les procédures associées aux commandes du menu Port. Ces procédures déterminent le port à utiliser pour numéroter. La commande choisie doit être repérée par une coche. Affichez l’onglet Form1.vb (Design) dans l’interface de développement, déroulez le menu Port, double-cliquez sur la commande COM1 et complétez la procédure COM1_Click() comme suit : Private Sub COM1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles COM1.Click CommPort = 1 COM1.Checked = True COM2.Checked = False COM3.Checked = False COM4.Checked = False End Sub
La première instruction indique au contrôle MSComm1 que le modem est relié sur le port COM1 : CommPort = 1
Les instructions suivantes cochent la commande COM1 et décochent les autres commandes : COM1.Checked COM2.Checked COM3.Checked COM4.Checked
= = = =
True False False False
Les procédures Com2_Click() à Com4_Click() sont très semblables. Déroulez le menu Port, double-cliquez sur la commande COM2 et entrez les instructions suivantes : Private Sub COM2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles COM1.Click CommPort = 2 COM1.Checked = False COM2.Checked = True COM3.Checked = False COM4.Checked = False End Sub
Déroulez le menu Port, double-cliquez sur la commande COM3 et entrez les instructions suivantes :
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 20
Composeur téléphonique
465
Private Sub COM3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles COM1.Click CommPort = 3 COM1.Checked = False COM2.Checked = False COM3.Checked = True COM4.Checked = False End Sub
Déroulez le menu Port, double-cliquez sur la commande COM4 et entrez les instructions suivantes : Private Sub COM4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles COM1.Click CommPort = 4 COM1.Checked = False COM2.Checked = False COM3.Checked = False COM4.Checked = True End Sub
Gestion du ComboBox Nom Nous allons maintenant nous intéresser au contrôle ComboBox Nom. Lorsque l’utilisateur sélectionne un nom dans cette liste, la procédure Nom_Click() est exécutée. Elle doit provoquer l’affichage du numéro de téléphone correspondant, dans la zone de texte Numéro. Dans la fenêtre de code, sélectionnez l’objet Nom et l’événement SelectedIndexChanged. Complétez la procédure Nom_SelectedIndexChanged() en entrant les instructions suivantes : Private Sub Nom_SelectedIndexChanged(ByVal sender As Object, ByVal e As System. „ EventArgs) Handles Nom.SelectedIndexChanged Numéro.Text = NumTel(Nom.SelectedIndex + 1) End Sub
Rappelez-vous que les noms lus dans le fichier C:\test\agend.txt ont été stockés dans le tableau NomTel et dans la liste modifiable. Quant aux numéros de téléphone, ils ont été stockés dans le tableau NumTel. Pour obtenir le numéro de téléphone correspondant au nom sélectionné dans la liste modifiable, il suffit de lire la donnée stockée dans l’élément SelectedIndex + 1 dans le tableau NumTel. Le résultat apparaît dans la zone de texte Numéro : Numéro.Text = NumTel(Nom.SelectedIndex + 1)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
466
Visual Basic 2010
Sauvegardez le projet, puis définissez le fichier texte C:\test\agend.txt, par exemple dans le Bloc-notes de Windows. Entrez les noms et les numéros de téléphone de vos correspondants en respectant le format décrit quelques pages plus haut. Sauvegardez le fichier. Vous pouvez lancer le projet NUMTEL. Vérifiez que la sélection d’un correspondant produit bien l’affichage de son numéro de téléphone dans la zone de texte.
Gestion du bouton de commande Nous pouvons poursuivre et clôturer le code de l’application en définissant la procédure Button1_Click() associée au bouton Composer. Double-cliquez sur le bouton de commande et complétez la procédure Button1_Click() comme suit : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click If CommPort = 1 Then Dim COM1 As IO.Ports.SerialPort COM1 = My.Computer.Ports.OpenSerialPort("COM1", 19200) COM1.Write("ATDT" + Numéro.Text + vbCrLf) End If If CommPort = 2 Then Dim COM2 As IO.Ports.SerialPort COM2 = My.Computer.Ports.OpenSerialPort("COM1", 19200) COM2.Write("ATDT" + Numéro.Text + vbCrLf) End If If CommPort = 3 Then Dim COM3 As IO.Ports.SerialPort COM3 = My.Computer.Ports.OpenSerialPort("COM1", 19200) COM3.Write("ATDT" + Numéro.Text + vbCrLf) End If If CommPort = 4 Then Dim COM4 As IO.Ports.SerialPort COM4 = My.Computer.Ports.OpenSerialPort("COM1", 19200) COM4.Write("ATDT" + Numéro.Text + vbCrLf) End If End Sub
Cette procédure consiste en quatre blocs d’instructions. Un seul d’entre eux sera exécuté, en fonction de la commande cochée dans le menu Port. Examinons le premier bloc d’instructions.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 20
Composeur téléphonique
467
Si la variable CommPort vaut 1 (en d’autres termes, si l’utilisateur a lancé la commande COM1 dans le menu Port) : If CommPort = 1 Then
l’objet IO.Ports.SerialPort COM1 est créé : Dim COM1 As IO.Ports.SerialPort
le port COM1 est ouvert à l’aide de la fonction OpenSerialPort() : COM1 = My.Computer.Ports.OpenSerialPort("COM1", 19200)
et une commande ATDT est envoyée au modem afin de composer le numéro de téléphone qui apparaît dans le contrôle Numéro : COM1.Write("ATDT" + Numéro.Text + vbCrLf)
Les trois autres blocs d’instructions sont semblables, à ceci près qu’ils travaillent sur un autre port de communication. Il ne vous reste plus qu’à placer les noms et numéros de vos correspondants dans le fichier c:\test\agend.txt. Si vous avez plus de vingt correspondants, n’oubliez pas de modifier le nombre d’éléments des tableaux NumTel et NomTel. Appuyez sur F5. Si le port par défaut ne convient pas, choisissez une des commandes du menu Port pour sélectionner le port à utiliser. Déroulez la liste modifiable. Les noms apparaissent classés par ordre alphabétique. Sélectionnez un correspondant. Son numéro de téléphone apparaît immédiatement dans la zone de texte. Cliquez sur le bouton Composer. Après un bref instant, le numéro est composé. Décrochez le combiné et parlez… Voici le listing complet de l’application. Les fichiers correspondants se trouvent dans le dossier Projects\NumTel des sources de l’ouvrage. Public Class Form1 Dim max, CommPort As Integer Dim NomTel(0 To 20), NumTel(0 To 20) As String Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load Dim i As Integer = 1 Try FileOpen(1, "c:\test\agend.txt ", OpenMode.Input) Do NomTel(i) = LineInput(1) NumTel(i) = LineInput(1) Nom.Items.Add(NomTel(i)) i = i + 1
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
468
Visual Basic 2010
Loop Until EOF(1) FileClose() Catch ex As Exception MsgBox("Le fichier c:\test\agend.txt n’existe pas") End Try Max = i - 1 If COM1.Checked Then CommPort = 1 If COM2.Checked Then CommPort = 2 If COM3.Checked Then CommPort = 3 If COM4.Checked Then CommPort = 4 End Sub Private Sub COM1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles COM1.Click CommPort = 1 COM1.Checked = True COM2.Checked = False COM3.Checked = False COM4.Checked = False End Sub Private Sub COM2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles COM2.Click CommPort = 2 COM1.Checked = False COM2.Checked = True COM3.Checked = False COM4.Checked = False End Sub Private Sub COM3_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles COM3.Click CommPort = 3 COM1.Checked = False COM2.Checked = False COM3.Checked = True COM4.Checked = False End Sub Private Sub COM4_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles COM4.Click CommPort = 4 COM1.Checked = False
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 20
Composeur téléphonique
469
COM2.Checked = False COM3.Checked = False COM4.Checked = True End Sub Private Sub Nom_SelectedIndexChanged(ByVal sender As Object, ByVal e As „ System.EventArgs) Handles Nom.SelectedIndexChanged Numéro.Text = NumTel(Nom.SelectedIndex + 1) End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click If CommPort = 1 Then Dim COM1 As IO.Ports.SerialPort COM1 = My.Computer.Ports.OpenSerialPort("COM1", 19200) COM1.Write("ATDT" + Numéro.Text + vbCrLf) End If If CommPort = 2 Then Dim COM2 As IO.Ports.SerialPort COM2 = My.Computer.Ports.OpenSerialPort("COM1", 19200) COM2.Write("ATDT" + Numéro.Text + vbCrLf) End If If CommPort = 3 Then Dim COM3 As IO.Ports.SerialPort COM3 = My.Computer.Ports.OpenSerialPort("COM1", 19200) COM3.Write("ATDT" + Numéro.Text + vbCrLf) End If If CommPort = 4 Then Dim COM4 As IO.Ports.SerialPort COM4 = My.Computer.Ports.OpenSerialPort("COM1", 19200) COM4.Write("ATDT" + Numéro.Text + vbCrLf) End If End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
21 Clients HTTP et FTP Dans ce chapitre, vous allez voir qu’il est simple de réaliser un navigateur web et un outil de téléchargement FTP. Pour surfer sur la toile avec une application de votre cru, il vous suffira de déplacer le contrôle WebBrowser sur la feuille d’une application. Pour réaliser une application de téléchargement FTP, vous n’aurez qu’à faire appel aux méthodes de l’objet My.Computer.Network.
Un client HTTP élémentaire Les adeptes d’Internet et du Web sont tous les jours plus nombreux. Bientôt, le Net ne sera qu’une extension conventionnelle de tout PC qui se respecte, au même titre que la carte son ou le lecteur de CD-ROM quelques années auparavant. Dans cette section, vous allez voir à quel point il est simple d’obtenir des données HTTP (sur le Web) grâce à Visual Basic 2010. L’application proposée dans cet ouvrage est certes basique, mais elle plante le décor que vous pourrez utiliser pour réaliser des projets plus ambitieux…
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
472
Visual Basic 2010
Avant de commencer Le langage du parfait internaute comprend de nombreux termes techniques plus ou moins complexes. Sans doute avez-vous déjà entendu parler de client et de serveur. Toute la technologie Internet est fondée sur ce système. Un serveur est un programme capable de fournir des données. Au contraire, un client est un programme demandeur de données. Dans cette section, nous allons réaliser une mini-application qui permettra d’afficher une page web quelconque après la saisie et la validation de son adresse URL. Pour cela, il suffira d’inclure un contrôle WebBrowser dans l’application (voir Figure 21.1). Figure 21.1 Bien qu’élémentaire, cette application est un véritable navigateur web.
Mise en place de l’application 1. Lancez la commande Nouveau/Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom ClientHTTP à l’application et validez en cliquant sur OK. 2. Ajoutez un contrôle ToolStrip et un contrôle WebBrowser à l’application. 3. À l’intérieur du contrôle ToolStrip, ajoutez une zone de texte (TextBox) et trois boutons (Button). Nous allons modifier l’allure de ces contrôles. Cliquez sur une
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 21
Clients HTTP et FTP
473
partie inoccupée du contrôle ToolStrip, puis sur la propriété Items dans la fenêtre des propriétés. Un bouton contenant trois boutons de suspension apparaît à droite de la propriété. Cliquez dessus pour afficher la boîte de dialogue Éditeur de collections Items (voir Figure 21.2). Figure 21.2 Cette boîte de dialogue permet de modifier les contrôles inclus dans le ToolStrip.
4. Cliquez sur l’entrée ToolStripTextBox1 dans la zone de liste Membres et affectez la valeur 400 à la propriété Size/Width. 5. Cliquez sur l’entrée ToolStripButton1 dans la zone de liste Membres. Affectez la valeur Text à la propriété DisplayStyle et la valeur OK à la propriété Text. 6. Cliquez sur l’entrée ToolStripButton2 dans la zone de liste Membres. Affectez la valeur Text à la propriété DisplayStyle et la valeur Précédent à la propriété Text. 7. Enfin, cliquez sur l’entrée ToolStripButton3 dans la zone de liste Membres. Affectez la valeur Text à la propriété DisplayStyle et la valeur Suivant à la propriété Text. 8. Le contrôle ToolStrip est entièrement paramétré. Cliquez sur le bouton OK pour fermer la boîte de dialogue Éditeur de collections Items. 9. Donnez la valeur Navigateur à la propriété Text du contrôle Form1 et la valeur Fill à la propriété Dock du contrôle WebBrowser1, de façon à attribuer la taille maximale au contrôle WebBrowser. La fenêtre de l’application doit à présent ressembler à la Figure 21.3.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
474
Visual Basic 2010
Figure 21.3 Disposition des contrôles sur la feuille.
Définition des procédures de traitement Les procédures de traitement à mettre en œuvre sont très simples. Elles concernent les trois boutons de commande et le redimensionnement de la fenêtre de l’application (événement Form1_Resize). Double-cliquez sur le premier bouton de commande et complétez la procédure Tool StripButton1_Click() comme suit : Private Sub ToolStripButton1_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles ToolStripButton1.Click WebBrowser1.Navigate(ToolStripTextBox1.Text) End Sub
L’instruction WebBrowser1.Navigate() provoque l’affichage de la page dont l’adresse est spécifiée dans le contrôle TextBox1.Text, lui-même placé dans le contrôle WebBrowser. Double-cliquez sur le deuxième bouton de commande et complétez la procédure Tool StripButton2_Click() comme suit : Private Sub ToolStripButton2_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles ToolStripButton2.Click WebBrowser1.GoBack() End Sub
L’instruction WebBrowser1.GoBack() provoque l’affichage de la page précédente dans le contrôle WebBrowser. Elle correspond au bouton Précédente d’Internet Explorer. Enfin, double-cliquez sur le troisième bouton de commande et complétez la procédure ToolStripButton3_Click() comme suit : Private Sub ToolStripButton3_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles ToolStripButton3.Click WebBrowser1.GoForward() End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 21
Clients HTTP et FTP
475
L’instruction WebBrowser1.GoForward() provoque l’affichage de la page suivante dans le contrôle WebBrowser. Elle correspond au bouton Suivante d’Internet Explorer. Nous allons maintenant écrire quelques lignes de code pour attribuer une largeur maximale au contrôle ToolStripTextBox1 en fonction de la largeur de la fenêtre. Sélectionnez l’entrée Form1 dans la fenêtre des Propriétés. Cliquez sur le bouton Événements et double-cliquez sur l’événement Resize. Cette action provoque le passage dans la fenêtre de code. Le point d’insertion est positionné à l’intérieur de la procédure Form1_ Resize(). Complétez cette procédure comme suit : Private Sub Form1_Resize(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Resize ToolStripTextBox1.Size = New System.Drawing.Size(Me.Width - 160, 25) End Sub
Lors d’un redimensionnement de la fenêtre, la procédure Form1_Resize() affecte au contrôle ToolStripTextBox1 la largeur de la feuille (Me.Width) diminuée de 160 points. Cette valeur correspond à la somme des largeurs des boutons ToolStripButton1, Tool StripButton2 et ToolStripButton3.
Exécution de l’application Connectez-vous chez votre fournisseur d’accès, puis appuyez sur la touche de fonction F5. L’application est immédiatement fonctionnelle. Entrez l’adresse URL d’un site quelconque dans la zone de texte et cliquez sur OK. La page correspondante apparaît dans la partie inférieure de la fenêtre. Vous pouvez naviguer à partir de cette page ou entrer une autre adresse URL dans la zone de texte et cliquer à nouveau sur OK. Utilisez les boutons Précédent et Suivant pour naviguer dans les sites visités.
Info
Les boutons Précédent et Suivant ne fonctionnent que dans les pages visitées : si vous remontez trop loin avec le bouton Précédent ou que vous tentiez d’afficher une page qui n’a pas été visitée avec le bouton Suivant, aucune action n’en découlera.
Voici le listing complet de l’application. Ce projet se trouve dans le dossier Projects\ ClientHTTP des sources de l’ouvrage. Public Class Form1 Private Sub ToolStripButton1_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles ToolStripButton1.Click WebBrowser1.Navigate(ToolStripTextBox1.Text)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
476
Visual Basic 2010
End Sub Private Sub ToolStripButton2_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles ToolStripButton2.Click WebBrowser1.GoBack() End Sub Private Sub ToolStripButton3_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles ToolStripButton3.Click WebBrowser1.GoForward() End Sub Private Sub Form1_Resize(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Resize ToolStripTextBox1.Size = New System.Drawing.Size(Me.Width - 160, 25) End Sub End Class
Un client FTP élémentaire Nous allons réaliser une mini-application qui permettra de télécharger (c’est-à-dire de rapatrier sur votre ordinateur) un fichier quelconque situé sur un site FTP dont vous connaissez l’adresse (voir Figure 21.4). Figure 21.4 La connexion au serveur a été établie.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 21
Clients HTTP et FTP
477
Mise en place de l’application Lancez la commande Nouveau Projet du menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Sélectionnez Visual Basic/Windows dans le volet gauche et Application Windows Forms dans le volet central. Donnez le nom ClientFTP à l’appli cation et validez en cliquant sur OK. Ajoutez quatre contrôles Label, cinq contrôles TextBox et deux contrôles Button dans la nouvelle application. Modifiez les propriétés de ces contrôles comme suit : Contrôle
Propriété
Valeur
Label1
Text
Site FTP
Label2
Text
User ID
Label3
Text
Password
Label4
Text
Fichier
TextBox1
Text
ftp.jussieu.fr
TextBox1
(Name)
Adresse
TextBox2
Text
anonymous
TextBox2
(Name)
UserID
TextBox3
Text
[email protected]
TextBox3
(Name)
Password
TextBox4
(Name)
Fichier
TextBox4
Text
jussieu/README
Button1
Text
Connecter
Button1
(Name)
Connecter
Button2
Text
Télécharger
Button2
(Name)
Telech
TextBox5
MultiLine
True
TextBox5
(Name)
Message
Form1
Text
Téléchargement FTP
Disposez et redimensionnez ces contrôles de sorte que la feuille ressemble à la Figure 21.5.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
478
Visual Basic 2010
Figure 21.5 Disposition des contrôles sur la feuille.
ce Astu
Le serveur FTP de l’université de Jussieu a été pris en exemple dans cette section. Cependant, rien ne vous empêche de faire vos essais sur un autre serveur FTP. Pour obtenir l’adresse de sites français et étrangers, rendez-vous sur le site web.cnrs-orleans.fr/SERVICES/FTP/ftp-sites.html.
Définition des procédures de traitement Double-cliquez sur le bouton Connecter et complétez la procédure Connecter_Click() comme suit : Private Sub Connecter_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Connecter.Click If My.Computer.Network.Ping(Adresse.Text) Then Message.Text = Message.Text + "L’ordinateur visé est accessible" + vbCrLf Else Message.Text = Message.Text + "L’ordinateur visé n’est pas accessible" + vbCrLf End If End Sub
Ce code repose sur une instruction If Then Else : If My.Computer.Network.Ping(Adresse.Text) Then Else End If
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 21
Clients HTTP et FTP
479
La fonction My.Computer.Network.Ping() renvoie la valeur True si le serveur spécifié en argument renvoie une réponse à un ping. Elle renvoie la valeur False dans le cas contraire. Si le serveur répond au ping, un message indiquant la réussite de la connexion s’affiche dans la zone de texte multiligne : Message.Text = Message.Text + "L’ordinateur visé est accessible" + vbCrLf
Dans le cas contraire, un message indiquant l’indisponibilité du site apparaît dans la zone de texte multiligne : Else Message.Text = Message.Text + "L’ordinateur visé n’est pas accessible" + vbCrLf
Double-cliquez sur le bouton Télécharger et complétez la procédure Telech_Click() comme suit : Private Sub Telech_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Telech.Click Message.Text = Message.Text + "Début du téléchargement" + vbCrLf My.Computer.Network.DownloadFile("ftp://" + Adresse.Text + "/" + Fichier.Text, „ "c:\download\" + Fichier.Text, UserID.Text, Password.Text, True, 500, True) Message.Text = Message.Text + "Le fichier a été copié ici : c:\download\" „ + Fichier.Text + vbCrLf End Sub
La première instruction affiche un message indiquant le début du téléchargement dans la zone de texte multiligne : Message.Text = Message.Text + "Début du téléchargement" + vbCrLf
Le fichier est alors téléchargé à l’aide de la procédure DownloadFile() : My.Computer.Network.DownloadFile("ftp://" + Adresse.Text + "/" + Fichier.Text, „ "c:\download\" + Fichier.Text, UserID.Text, Password.Text, True, 500, True)
Voici la signification des sept arguments de la procédure DownloadFile() :
∑ ∑ ∑ ∑ ∑
adresse URL complète du fichier à télécharger ; adresse de stockage sur l’ordinateur (ici dans le dossier c:\download) ; nom d’utilisateur pour la connexion FTP ; mot de passe pour la connexion FTP ; affichage (True) d’un indicateur de progression de téléchargement ;
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
480
∑ ∑
Visual Basic 2010
durée maximale de réponse (en millisecondes) attribuée au serveur ; écrasement (True) d’un éventuel fichier de même nom.
Lorsque le téléchargement est terminé, un message s’affiche dans la zone de texte multiligne : Message.Text = Message.Text + "Le fichier a été copié ici : c:\download\" „ + Fichier.Text + vbCrLf
Exécution de l’application Connectez-vous chez votre fournisseur d’accès, puis appuyez sur la touche de fonction F5. Les quatre premières zones de texte sont complétées dès l’exécution. Cliquez sur le bouton Connecter et patientez jusqu’à l’affichage du message "L’ordinateur visé est accessible". Si une boîte de dialogue analogue à celle montrée à la Figure 21.6 s’affiche, cliquez sur Débloquer. Figure 21.6 Alerte de sécurité générée sous Windows 7.
Cliquez maintenant sur le bouton Télécharger et patientez jusqu’à l’affichage du message "Le fichier a été copié ici". La Figure 21.7 représente l’application Téléchargement FTP en mode Exécution. Remarquez les messages affichés dans le contrôle Mémo.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 21
Clients HTTP et FTP
481
Figure 21.7 Téléchargement du fichier README sur le serveur ftp. jussieu.fr.
Voici le listing complet du programme ClientFTP. Ce projet se trouve dans le dossier Projects\ClientFTP des sources de l’ouvrage. Public Class Form1 Private Sub Connecter_Click(ByVal sender As System.Object, ByVal e As „ System.EventArgs) Handles Connecter.Click If My.Computer.Network.Ping(Adresse.Text) Then Message.Text = Message.Text + "L’ordinateur visé est accessible" + vbCrLf Else Message.Text = Message.Text + "L’ordinateur visé n’est pas accessible" „ + vbCrLf End If End Sub Private Sub Telech_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Telech.Click Message.Text = Message.Text + "Début du téléchargement" + vbCrLf My.Computer.Network.DownloadFile("ftp://" + Adresse.Text + "/" + Fichier.Text, „ "c:\download\" + Fichier.Text, UserID.Text, Password.Text, True, 500, True) Message.Text = Message.Text + "Le fichier a été copié ici : c:\download\" „ + Fichier.Text + vbCrLf End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
22 Applications web Avec Visual Studio 2010, Microsoft offre aux développeurs la possibilité de porter tout ou partie de leurs applications sur le Net. Ces applications sont alors accessibles par un simple navigateur web. Dans les pages qui suivent, vous allez découvrir à quel point il est simple de concevoir, de développer, de déboguer et de déployer des applications web puissantes qui réduisent considérablement la durée du développement. Les applications web ou Web Forms sont générées à partir de Visual Studio. Tout se passe comme si vous étiez en train de concevoir une application Windows Forms : 1. Définissez l’interface visuelle de l’application en déplaçant un ou plusieurs contrôles de la Boîte à outils vers la feuille de l’application. 2. Modifiez autant de propriétés que nécessaire en utilisant la fenêtre des propriétés. 3. Définissez des propriétés événementielles pour réagir aux événements utilisateur. 4. Générez l’application en appuyant sur la touche F5 via la commande Générer le site web dans le menu Générer. Un document ASP+ est créé par Visual Studio. Ce document est directement affichable dans un navigateur Internet.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
484
Visual Basic 2010
Le code généré est compilé lors du premier accès au document ASP+. Vous avez bien lu ! La première fois que le document sera lu, ASP+ compilera le code correspondant. Toutes les personnes qui visualiseront ce document par la suite utiliseront sa version compilée, donc beaucoup plus rapide… Les contrôles disponibles pour les Web Forms sont très nombreux. Ils vont du simple label au très sophistiqué calendrier, en passant par un GridView, facilement connectable à un RecordSet. Le simple fait de placer un contrôle sur la feuille du document génère le code ASP correspondant. Il existe un certain nombre de contrôles "invisibles". Comparables au Timer de Visual Basic, ces contrôles sont essentiellement dédiés à la validation des données entrées par l’utilisateur. Enfin, sachez également qu’il est possible de développer des contrôles personnalisés serveur. D’une manière comparable aux OCX, ces contrôles peuvent implémenter des propriétés qui leur sont propres et utiliser une gestion événementielle spécifique.
Une première application web Vous allez maintenant créer votre première application web, qui va se contenter d’afficher un simple texte dans la fenêtre du navigateur lors de son exécution. Lancez la commande Nouveau/Site web dans le menu Fichier. Dans le volet gauche, choisissez Visual Basic sous Modèles installés. Sélectionnez le modèle Site web ASP.NET vide, indiquez l’emplacement et le nom de votre projet et cliquez sur OK (voir Figure 22.1). Figure 22.1 L’application web PremiereAW est sur le point d’être générée.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 22
Applications web
485
Cliquez sur OK. Quelques instants plus tard, une nouvelle solution web vide est créée. Dans l’Explorateur de solutions, cliquez du bouton droit sur l’entrée PremiereAW et sélectionnez Ajouter un nouvel élément dans le menu contextuel. Choisissez Web Form et cliquez sur Ajouter. La fenêtre de Visual Studio se présente comme à la Figure 22.2. L’onglet Standard de la Boîte à outils donne accès à un certain nombre de contrôles spécifiques aux applications web. Pour les utiliser, il suffit de les déposer à l’emplacement souhaité sur le document, comme vous le feriez pour une application Windows Forms. D’une façon similaire, la fenêtre des propriétés donne accès aux propriétés de l’objet sélectionné ou du document si aucun objet n’est sélectionné. Figure 22.2 Votre première application web a été générée par Visual Studio et la page Default.aspx y a été insérée.
Déplacez un contrôle Label sur le document et affectez la valeur "Ceci est un contrôle Label" à la propriété Text de ce contrôle. Cliquez maintenant sur une partie non occupée du document et affectez la valeur "Ma première application web" à la propriété title. Appuyez sur la touche F5 pour exécuter l’application web. Si une boîte de dialogue vous signale que le débogage n’est pas activé dans Web.config, sélectionnez l’option Modifier le fichier Web.config pour activer le débogage et cliquez sur OK. Après quelques instants, Internet Explorer est exécuté et le document qui vient d’être créé dans Visual Studio y est affiché (voir Figure 22.3).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
486
Visual Basic 2010
Figure 22.3 Le document Visual Studio affiché dans Internet Explorer.
Le document représenté dans Internet Explorer est au format ASP (WebForm1.aspx). Pour visualiser son code, lancez la commande Source dans le menu Affichage d’Internet Explorer. Voici le listing obtenu : Ma première application Web Ceci est un contrôle Label
Le label a été généré dans un marqueur : Ceci est un contrôle Label
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 22
Applications web
487
Les éléments affichés dans une application web peuvent être modifiés, comme vous le feriez dans une application Windows Forms. Pour vous en convaincre, ajoutez deux boutons de commande au document précédent en les faisant glisser depuis la Boîte à outils. Modifiez les propriétés de ces boutons comme indiqué dans le tableau suivant : Contrôle
Propriété
Valeur
Button1
Text
Rouge
Button1
(ID)
Rouge
Button2
Text
Noir
Button2
(ID)
Noir
Double-cliquez sur le bouton Rouge et complétez la procédure Rouge_Click() comme suit : Private Sub Rouge_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Rouge.Click Label1.ForeColor = Drawing.Color.Red End Sub
L’unique instruction de cette procédure modifie la couleur du label. Double-cliquez maintenant sur le bouton Noir et complétez la procédure Noir_Click() comme suit : Private Sub Rouge_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Rouge.Click Label1.ForeColor = Drawing.Color.Black End Sub
Appuyez sur la touche F5. Vous pouvez maintenant modifier la couleur du label en cliquant sur les boutons Rouge et Noir. Voici le code ASP généré par Visual Studio (ce code se trouve dans le dossier Websites\ PremiereAW des sources après l’installation des sources de l’ouvrage) : Page sans titre
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
488
Visual Basic 2010
Ceci est un label
Remarquez les instructions utilisées pour définir les deux boutons de commande :
Lorsqu’on clique sur un bouton, une requête submit est générée et la portion de code définie dans la procédure Click() correspondante est exécutée, ce qui provoque le changement de couleur du label.
Une application web en un seul contrôle Même s’ils restent simples d’utilisation, certains contrôles sont très évolués. Nous allons en faire la démonstration en utilisant le contrôle Calendrier. Définissez un nouveau projet de type Site web ASP.NET vide. Ajoutez un nouvel élément Web Form dans le projet. Double-cliquez sur le contrôle Calendar pour l’insérer dans le document, puis appuyez sur la touche F5 pour générer le code ASP correspondant. La Figure 22.4 donne un aperçu du résultat obtenu dans Internet Explorer.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 22
Applications web
489
Figure 22.4 Il a suffi d’un doubleclic pour créer cette page web.
Si la forme par défaut du calendrier ne vous convient pas, retournez sur la page Default. aspx dans Visual Studio, cliquez du bouton droit sur le dessin du calendrier dans la page en cours d’édition et sélectionnez Mise en forme automatique dans le menu surgissant. Une boîte de dialogue vous permet de modifier l’aspect du calendrier en deux clics (voir Figure 22.5). Figure 22.5 L’aspect du calendrier peut être très facilement modifié.
Le calendrier se cale automatiquement sur le mois en cours. Si vous cliquez sur les flèches situées sur la première ligne du calendrier ou sur un des jours du mois précédent ou suivant, le mois correspondant est automatiquement affiché.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
490
Visual Basic 2010
L’affichage n’est donc pas statique. Voici le code qui a été généré par Visual Studio (cette application se trouve dans le dossier Websites\Calendrier des sources après l’installation des sources de l’ouvrage). Page sans titre //
< mai 2010> lun. mar.mer.jeu.ven. sam. dim.25 26 27 28 29 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 1 2 3 4 5 6
Valider les données L’onglet Validations de la Boîte à outils inclut plusieurs contrôles qui permettent de vérifier la validité des données saisies par l’utilisateur :
∑
RequiredFieldValidator. Affiche un message si un contrôle obligatoire n’est pas
∑
CompareValidator. Compare une valeur saisie par l’utilisateur à une constante ou à une autre valeur saisie par l’utilisateur.
∑ ∑ ∑ ∑
rempli.
RangeValidator. Vérifie que le contenu d’une zone de saisie se situe entre les limites
autorisées. RegularExpressionValidator. Vérifie que le contenu d’une zone de saisie correspond
au modèle spécifié. CustomValidator. Ce contrôle permet de définir une fonction de validation personnalisée. ValidationSummary. Affiche les messages d’erreur sous la forme d’une liste, d’une liste à puces ou d’un simple texte, sur la page ou dans une boîte de message.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
494
Visual Basic 2010
Les contrôles de validation sont "invisibles". Ils apparaissent uniquement en mode conception et en aucun cas dans le navigateur Internet. Supposons par exemple que vous souhaitiez tester la validité d’un mot de passe. Vous utiliserez pour cela un contrôle RegularExpressionValidator. Définissez un nouveau projet de type Site web ASP.NET vide. Ajoutez un nouvel élément Web Form au projet. Ajoutez un Label, un TextBox, un Button et un RegularExpression Validator à la feuille (les trois premiers contrôles se trouvent sous l’onglet Standard de la Boîte à outils et le quatrième sous l’onglet Validation). Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant : Contrôle
Propriété
Valeur
Label1
Text
Entrez le mot de passe
TextBox1
Text
Button
Text
Valider
RegularExpressionValidator1
ControlToValidate
TextBox1
RegularExpressionValidator1
ErrorMessage
Mot de passe incorrect
RegularExpressionValidator1
ValidationExpression
Le mot de passe
La propriété ValidationExpression est initialisée avec le mot de passe. Si vous cliquez sur les points de suspension, à droite de cette propriété, vous voyez que l’expression de validation peut également faire partie d’un certain nombre d’expressions standard (voir Figure 22.6). Figure 22.6 Ici, l’expression de validation est la constante «pearson».
Générez l’application en appuyant sur F5. Si une boîte de dialogue vous signale que le débogage n’est pas activé dans Web.config, sélectionnez l’option Modifier le fichier Web. config pour activer le débogage et cliquez sur OK.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 22
Applications web
495
Entrez un mot de passe non conforme puis cliquez sur le bouton Valider. Un message d’erreur s’affiche à droite du bouton de commande (voir Figure 22.7). Si vous entrez le bon mot de passe, le message d’erreur disparaît lorsque vous cliquez sur le bouton Valider. Figure 22.7 La saisie d’un mot de passe incorrect provoque l’affichage d’un message d’erreur.
Voici le code ASP généré par Visual Studio (ce code se trouve dans le dossier Websites\ Validation des sources après l’installation des sources de l’ouvrage). Page sans titre
496
Visual Basic 2010
theForm = document.form1; } function __doPostBack(eventTarget, eventArgument) { if (!theForm.onsubmit || (theForm.onsubmit() != false)) { theForm.__EVENTTARGET.value = eventTarget; theForm.__EVENTARGUMENT.value = eventArgument; theForm.submit(); } } // -->
Entrez le mot de passe Mot de passe incorrect
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 22
Applications web
497
Remarquez le marqueur , qui, à lui seul, permet de valider le mot de passe entré dans la zone de texte. Les propriétés errormessage et validationexpression apparaissent directement dans le script :
498
Visual Basic 2010
RegularExpressionValidator1.evaluationfunction = "RegularExpressionValidatorEvaluateIsValid"; RegularExpressionValidator1.validationexpression = "vs2010"; // -->
Le tableau suivant indique les plus importantes propriétés des différents contrôles de validation. Contrôle
Propriété
Fonction
RegularExpressionValidator
ErrorMessage
Message d’erreur à afficher en cas de non-conformité
RegularExpressionValidator
ControlToValidate
Nom du contrôle sur lequel porte le test
RegularExpressionValidator
ValidationExpression
Expression à utiliser pour déterminer la validité
RequiredFieldValidator
ErrorMessage
Message affiché si le contrôle testé est laissé vide
RequiredFieldValidator
ControlToValidate
Nom du contrôle sur lequel porte le test
CompareValidator
ErrorMessage
Message d’erreur à afficher en cas de non-conformité
CompareValidator
ControlToCompare
Nom du contrôle à comparer
CompareValidator
ControlToValidate
Nom du contrôle sur lequel porte le test
CompareValidator
ValueToCompare
Valeur à comparer au contrôle testé
RangeValidator
ErrorMessage
Message d’erreur à afficher en cas de non-conformité
RangeValidator
ControlToValidate
Nom du contrôle sur lequel porte le test
RangeValidator
MaximumValue
Valeur maximale de la plage autorisée
RangeValidator
MinimumValue
Valeur minimale de la plage autorisée
CustomValidator
ErrorMessage
Message d’erreur à afficher en cas de non-conformité
CustomValidator
ControlToValidate
Nom du contrôle sur lequel porte le test
ValidationSummary
HeaderText
En-tête du message d’erreur
ValidationSummary
DisplayMode
Mode d’affichage des messages d’erreur : List, BulletList ou SingleParagraph
ValidationSummary
ShowMessageBox
True pour afficher le message d’erreur dans une boîte de message, False pour
l’afficher dans la feuille
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 22
Applications web
499
Supposons que l’utilisateur doive saisir deux champs d’information obligatoires sur une feuille : son nom et son prénom. Si un des champs n’est pas saisi, vous pouvez afficher un message d’erreur à l’aide d’un contrôle RequiredFieldValidator. Vous pouvez également indiquer les champs non saisis dans une boîte de message à l’aide d’un contrôle ValidationSummary. Nous allons nous intéresser à cette deuxième possibilité. Définissez un nouveau projet de type Site web ASP.NET vide. Insérez un nouvel élément de type Web Form dans le projet. Ajoutez deux Label, deux TextBox, un Button, deux RequiredFieldValidator et un ValidationSummary au Web Form (ces contrôles se trouvent sous l’onglet Web Forms de la Boîte à outils). Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant : Contrôle
Propriété
Valeur
Label1
Text
Entrez votre nom
Label2
Text
Entrez votre prénom
TextBox1
Text
TextBox1
(ID)
TextBox2
Text
TextBox2
(ID)
Prénom
Button1
Text
Valider
Button1
(ID)
Valider
RequiredFieldValidator1
Display
None
RequiredFieldValidator1
ControlToValidate
Nom
RequiredFieldValidator1
ErrorMessage
Le champ nom est obligatoire
RequiredFieldValidator2
Display
None
RequiredFieldValidator2
ControlToValidate
Prénom
RequiredFieldValidator2
ErrorMessage
Le champ prénom est obligatoire
ValidationSummary
HeaderText
Attention :
ValidationSummary
ShowMessageBox
True
ValidationSummary
ShowSummary
False
Nom
En affectant la valeur None à la propriété Display des deux contrôles RequiredFieldValidator, aucun message n’apparaîtra à l’emplacement de ces contrôles si l’utilisateur laisse le champ correspondant vide.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
500
Visual Basic 2010
Générez et affichez la page ASP correspondante en appuyant sur F5. La Figure 22.8 donne un aperçu du résultat obtenu lorsque l’utilisateur clique sur le bouton Valider alors que les deux zones de texte obligatoires sont laissées vides. Figure 22.8 Une boîte de dialogue signale les champs obligatoires non remplis.
Voici le code ASP généré par Visual Studio (le code source se trouve dans le dossier Websites\ Validation2 des sources de l’ouvrage après installation des applications de l’ouvrage). Page sans titre
Entrez votre nom Entrez votre prénom
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
502
Visual Basic 2010
Remarquez le marqueur , associé au contrôle ValidationSummary et responsable de l’affichage de la boîte de message en cas de non-saisie des champs obligatoires :
504
Visual Basic 2010
document.getElementById("ValidationSummary1"); ValidationSummary1.headertext = "Attention :"; ValidationSummary1.showmessagebox = "True"; ValidationSummary1.showsummary = "False"; // -->
Envoyer des e-mails avec une application web L’envoi d’un message e-mail depuis une application web ASP.NET est vraiment élémentaire. Il suffit pour cela d’utiliser la méthode System.Web.Mail.SmtpMail.Send() : System.Web.Mail.SmtpMail.Send(expéditeur, destinataire, sujet, contenu)
Le message est envoyé au format Texte brut. Nous allons maintenant voir comment envoyer des messages plus sophistiqués au format HTML. Si nécessaire, vous pourrez définir un ou plusieurs destinataires secondaires et attacher un ou plusieurs fichiers au message. Lancez la commande Nouveau/Site web dans le menu Fichier. Dans le volet gauche, choisissez Visual Basic sous Modèles installés. Sélectionnez le modèle Site Web ASP.NET vide, donnez le nom Messages à l’application et validez. Insérez un nouvel élément Web Form à l’application. Ajoutez neuf Label, six TextBox, cinq RadioButton et un Button à ce Web Form. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant. Contrôle
Propriété
Valeur
Label1
Text
Envoi d’un e-mail
Label1
Font/Bold
True
Label1
Font/Size
Large
Label2
Text
Expéditeur
Label3
Text
Destinataire
Label4
Text
Sujet
Label5
Text
Contenu
Label6
Text
Autres destinataires
Label7
Text
Fichier attaché
Label8
Text
Priorité
Label9
Text
Format
TextBox1
(ID)
Exp
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 22
Applications web
Contrôle
Propriété
Valeur
TextBox2
(ID)
Dest
TextBox3
(ID)
Sujet
TextBox4
(ID)
Contenu
TextBox4
TextMode
MultiLine
TextBox5
(ID)
AutresDestin
TextBox6
(ID)
Attachement
RadioButton1
(ID)
PriorFaible
RadioButton1
(ID)
PriorNormale
RadioButton1
(ID)
PriorElevée
RadioButton1
(ID)
TexteBrut
RadioButton1
(ID)
HTML
RadioButton1
Text
Faible
RadioButton1
Text
Normale
RadioButton1
Text
Élevée
RadioButton1
Text
Texte Brut
RadioButton1
Text
HTML
RadioButton2
Checked
True
RadioButton5
Checked
True
Button1
Text
Envoyer
505
Pour améliorer l’agencement de ces contrôles, vous allez insérer un tableau HTML à deux colonnes et huit lignes sur la feuille. Déplacez-vous dans l’onglet HTML de la Boîte à outils et double-cliquez sur Table. Une table à trois lignes et trois colonnes s’affiche (voir Figure 22.9). Figure 22.9 Un tableau HTML de trois colonnes sur trois lignes est inséré sur la feuille.
Sélectionnez la troisième colonne et appuyez sur Maj+Suppr pour la supprimer. Sélectionnez une ligne et dupliquez-la autant de fois que nécessaire pour obtenir un tableau à
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
506
Visual Basic 2010
huit lignes. Il ne vous reste plus qu’à déplacer les labels dans les colonnes de gauche et les contrôles dans les colonnes de droite. Une fois cette opération effectuée, procédez comme suit : 1. Alignez à droite la colonne de gauche. Pour cela, sélectionnez la colonne de gauche et affectez la valeur Right à sa propriété Align. 2. Alignez à gauche la colonne de droite. Pour cela, sélectionnez la colonne de droite et affectez la valeur Left à sa propriété Align. Pour terminer, cliquez sur un endroit inoccupé de la feuille et lancez la commande Justifier > Centrer du menu Format. La feuille doit à présent ressembler à la Figure 22.10. Figure 22.10 Agencement des contrôles sur la feuille.
Double-cliquez sur le bouton Envoyer et complétez la procédure Button1_Click() comme suit : Protected Sub Button1_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles Button1.Click Dim Email As New System.Net.Mail.MailMessage(Exp.Text, Dest.Text) Email.Subject = Sujet.Text Email.Body = Contenu.Text Dim data = New Net.Mail.Attachment(Attachement.Text) Email.Attachments.Add(data)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 22
Applications web
507
If AutresDestin.Text "" Then Dim bccAddress = New MailAddress(AutresDestin.Text) Email.Bcc.Add(bccAddress) End If If PriorFaible.Checked Then Email.Priority = MailPriority.Low If PriorNormale.Checked Then Email.Priority = MailPriority.Normal If PriorElevée.Checked Then Email.Priority = MailPriority.High If TexteBrut.Checked Then Email.IsBodyHtml = False Else Email.IsBodyHtml = True End If Dim mailClient As New System.Net.Mail.SmtpClient() Dim basicAuthenticationInfo As New System.Net.NetworkCredential „ ("Nom d’utilisateur", "Mot de passe") mailClient.Host = "Serveur SMTP" mailClient.UseDefaultCredentials = False mailClient.Credentials = basicAuthenticationInfo mailClient.Send(Email) End Sub
La première instruction définit l’objet Email de type System.Net.Mail.MailMessage. Cet objet sera utilisé pour définir le message, ses attributs et finalement pour envoyer le message. Les deux arguments de la fonction MailMessage sont l’adresse de l’expéditeur et l’adresse du destinataire : Dim Email As New System.Net.Mail.MailMessage(Exp.Text, Dest.Text)
Le bloc d’instructions suivant définit le sujet et le contenu du message à partir des zones de texte Sujet et Contenu : Email.Subject = Sujet.Text Email.Body = Contenu.Text
Le bloc d’instructions suivant définit (s’il existe) le fichier attaché au message : If Attachement.Text"" Then Dim data = New Net.Mail.Attachment(Attachement.Text) Email.Attachments.Add(data) End If
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
508
Visual Basic 2010
Si un destinataire est spécifié dans la zone de texte AutresDestin, le champ bccAddress est initialisé : If AutresDestin.Text "" Then Dim bccAddress = New MailAddress(AutresDestin.Text) Email.Bcc.Add(bccAddress) End If
Le bloc d’instructions suivant définit la priorité du message en fonction des boutons radio Faible, Normale et Élevée : If PriorFaible.Checked Then Email.Priority = MailPriority.Low If PriorNormale.Checked Then Email.Priority = MailPriority.Normal If PriorElevée.Checked Then Email.Priority = MailPriority.High
Enfin, les boutons radio Texte brut et HTML sont examinés de façon à définir le type du message : If TexteBrut.Checked Then Email.IsBodyHtml = False Else Email.IsBodyHtml = True End If
Toutes les données sont prêtes à l’envoi. Nous allons maintenant définir le client de messagerie à utiliser. Dans un premier temps, nous définissons un objet mailClient de type SmtpClient : Dim mailClient As New System.Net.Mail.SmtpClient()
Puis nous entrons le nom d’utilisateur et le mot de passe du compte de messagerie à utiliser : Dim basicAuthenticationInfo As New System.Net.NetworkCredential „ ("Nom d’utilisateur", "Mot de passe")
Le bloc d’instructions suivant définit le client SMTP à utiliser et demande une identification classique : mailClient.Host = "Serveur SMTP" mailClient.UseDefaultCredentials = False mailClient.Credentials = basicAuthenticationInfo
Si, par exemple, vous utilisez le fournisseur d’accès, remplacez "Serveur SMTP" par "smtp. free.fr". La dernière instruction envoie le message à l’aide de la méthode Send() : mailClient.Send(Email)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 22
Applications web
509
Voici le listing complet de l’application. Vous trouverez les fichiers correspondants dans le dossier Websites\Messages des sources de l’ouvrage après leur installation. Imports System.Net Imports system.Net.mail Partial Class _Default Inherits System.Web.UI.Page Protected Sub Button1_Click(ByVal sender As Object, ByVal e As System. „ EventArgs) Handles Button1.Click Dim Email As New System.Net.Mail.MailMessage(Exp.Text, Dest.Text) Email.Subject = Sujet.Text Email.Body = Contenu.Text If Attachement.Text "" Then Dim data = New Net.Mail.Attachment(Attachement.Text) Email.Attachments.Add(data) End If If AutresDestin.Text "" Then Dim bccAddress = New MailAddress(AutresDestin.Text) Email.Bcc.Add(bccAddress) End If If PriorFaible.Checked Then Email.Priority = MailPriority.Low If PriorNormale.Checked Then Email.Priority = MailPriority.Normal If PriorElevée.Checked Then Email.Priority = MailPriority.High If TexteBrut.Checked Then Email.IsBodyHtml = False Else Email.IsBodyHtml = True End If
Dim mailClient As New System.Net.Mail.SmtpClient() Dim basicAuthenticationInfo As New System.Net.NetworkCredential „ ("lem.korp", "nn9dpyhd") mailClient.Host = "smtp.sfr.fr" mailClient.UseDefaultCredentials = False mailClient.Credentials = basicAuthenticationInfo mailClient.Send(Email) End Sub End Class
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
510
Info
Visual Basic 2010
Dans cet exemple, le hôte SMTP utilisé est SFR. Bien entendu, vous devez adapter cette information à votre propre hôte SMTP pour que le code fonctionne.
Vous pouvez maintenant tester l’application en cliquant sur l’icône Démarrer le débogage. Il ne vous reste plus qu’à remplir les champs de la feuille et à cliquer sur le bouton Envoyer (voir Figure 22.11). Figure 22.11 La feuille Envoi d’un e-mail, en mode Exécution.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
23 Annuaire de sites web Ce chapitre va vous montrer comment réaliser une application ASP.NET à l’aide de Visual Basic 2010 pour réaliser un annuaire de sites web. Les données manipulées proviennent de l’ouvrage Annuaire des 10 000 sites web francophones, publié aux éditions CampusPress. Pour faciliter leur accès, les sites ont été répartis dans douze groupes représentés par des listes déroulantes à la Figure 23.1. Chaque liste donne accès à un certain nombre de sites. Pour accéder à l’un d’entre eux, il suffit de le sélectionner dans la liste correspondante.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
512
Visual Basic 2010
Figure 23.1 La page principale du projet 10 000 sites web.
Mise en place de l’application Pour réaliser ce projet, nous allons créer un site web ASP.NET . Lancez la commande Nouveau/Site web dans le menu Fichier. Dans le volet gauche, choisissez Visual Basic sous Modèles installés. Sélectionnez le modèle Site web ASP.NET, donnez le nom Annuaire au projet et cliquez sur OK. Vous allez maintenant implanter différents contrôles sur la page web. Développez l’entrée HTML dans la Boîte à outils et insérez un contrôle Table. Cette action insère un tableau vierge de trois lignes et trois colonnes sur la page (voir Figure 23.2). Figure 23.2 Un tableau vierge 3 × 3 a été inséré sur la page.
Sélectionnez une ligne du tableau, copiez-la dans le presse-papiers de Windows et dupliquez-la pour obtenir un tableau de 8 lignes sur trois colonnes (voir Figure 23.3). Figure 23.3 Cinq lignes ont été ajoutées au tableau.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 23
Annuaire de sites web
513
Ajoutez douze contrôles Label (onglet Standard) et douze contrôles DropdownList (onglet Standard) dans les cellules du tableau pour obtenir la mise en forme représentée Figure 23.4. Figure 23.4 Vingt-quatre contrôles viennent d’être insérés.
En utilisant les poignées de tedimensionnement, donnez une largeur de 222 pixels à chacune des colonnes du tableau. Modifiez ensuite les propriétés des contrôles comme suit : Contrôle
Propriété
Valeur
Label1
Text
Culture et arts
Label2
Text
Cyberculture
Label3
Text
Économie et finance
Label4
Text
Éducation
Label5
Text
Emploi, services
Label6
Text
Informatique
Label7
Text
Loisirs
Label8
Text
Média, info
Label9
Text
Savoirs
Label10
Text
Vie politique et sociale
Label11
Text
Vie pratique
Label12
Text
Voyage et tourisme
DropDownList1
(ID)
ddl1
DropDownList2
(ID)
ddl2
DropDownList3
(ID)
ddl3
DropDownList4
(ID)
ddl4
DropDownList5
(ID)
ddl5
DropDownList6
(ID)
ddl6
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
514
Visual Basic 2010
Contrôle
Propriété
Valeur
DropDownList7
(ID)
ddl7
DropDownList8
(ID)
ddl8
DropDownList9
(ID)
ddl9
DropDownList10
(ID)
ddl10
DropDownList11
(ID)
ddl11
DropDownList12
(ID)
ddl12
Définition des procédures de traitement Vous allez maintenant définir le contenu des douze listes déroulantes. Double-cliquez sur une partie inoccupée de la page web et complétez la procédure Page_Load() comme suit : Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load ‘Initialisation des DropDownLists ddl1.Items.Add("Choisissez une entrée") ddl1.Items.Add("Actualité, festivals") ddl1.Items.Add("Annuaires, moteurs, portails") ddl1.Items.Add("Architecture") ddl1.Items.Add("Arts créatifs, multimédia, comm") ddl1.Items.Add("Arts de la scène") ddl1.Items.Add("Arts(plastiques)") ddl1.Items.Add("Ateliers, clubs, écoles") ddl1.Items.Add("Bande(dessinée) : éditeurs()") ddl1.Items.Add("Bande(dessinée) : e(-zines)") ddl1.Items.Add("Bande dessinée en ligne") ddl1.Items.Add("Bibliothèques") ddl1.Items.Add("Cinéma: actualité") ddl1.Items.Add("Cinéma: annuaires") ddl1.Items.Add("Cinéma : pour les pros") ddl1.Items.Add("Cinéma: production, distribution") ddl1.Items.Add("Cinéma : sites de films, d’acteurs") ddl1.Items.Add("Cinéma: sites(généralistes)") ddl1.Items.Add("Cinéma: vente") ddl1.Items.Add("Cirque, magie") ddl1.Items.Add("Danse") ddl1.Items.Add("Galeries(d) ‘exposition") ddl1.Items.Add("Index, moteurs, annuaires")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 23
Annuaire de sites web
515
ddl1.Items.Add("Littérature: actualité") ddl1.Items.Add("Littérature: annuaires, moteurs") ddl1.Items.Add("Littérature: éditeurs") ddl1.Items.Add("Littérature : magazines, sites génér.") ddl1.Items.Add("Littérature : salons, festivals…") ddl1.Items.Add("Littérature: styles(littéraires)") ddl1.Items.Add("Littérature: textes") ddl1.Items.Add("Littérature: vente") ddl1.Items.Add("Mode()") ddl1.Items.Add("Moteurs, annuaires") ddl1.Items.Add("Musées, sites de peintres") ddl1.Items.Add("Musique : apprendre la musique") ddl1.Items.Add("Musique: associations, écoles") ddl1.Items.Add("Musique: chanteurs, musiciens, groupes") ddl1.Items.Add("Musique: concerts, festivals, opéras") ddl1.Items.Add("Musique: genres(musicaux)") ddl1.Items.Add("Musique: MIDI, MP3, RealAudio") ddl1.Items.Add("Musique: moteurs, annuaires") ddl1.Items.Add("Musique: paroles, partitions, tablatures") ddl1.Items.Add("Musique: portails, magazines, actualité") ddl1.Items.Add("Musique : pour les pros") ddl1.Items.Add("Musique: vente()") ddl1.Items.Add("Organismes, divers") ddl1.Items.Add("Patrimoine()") ddl1.Items.Add("Photographie()") ddl1.Items.Add("Photo: expositions, galeries") ddl1.Items.Add("Photo: journaux, conseils") ddl1.Items.Add("Photo: photographes, agences, stc") ddl1.Items.Add("Photo : safaris et chasses photo") ddl1.Items.Add("Photo: vente()") ddl1.Items.Add("Religion()") ddl1.Items.Add("Vente()") ddl1.Items.Add("Vente de bandes dessinées") ddl2.Items.Add("Choisissez une entrée") ddl2.Items.Add("Actualité art, musique et culture") ddl2.Items.Add("Annuaires") ddl2.Items.Add("Fournisseurs d’accès à Internet") ddl2.Items.Add("Groupes de discussion, listes de diffusion") ddl2.Items.Add("Hébergeurs") ddl2.Items.Add("Jeux en ligne") ddl2.Items.Add("Jeux en ligne : clans") ddl2.Items.Add("Sites de communautés") ddl2.Items.Add("Site de journaux")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
516
Visual Basic 2010
ddl2.Items.Add("Webcams, netcams") ddl2.Items.Add("Webzines") ddl3.Items.Add("Choisissez une entrée") ddl3.Items.Add("Actualités et généralités") ddl3.Items.Add("Assurance") ddl3.Items.Add("Banque et crédit") ddl3.Items.Add("Bourse") ddl3.Items.Add("Euro") ddl3.Items.Add("Institutions et organismes") ddl3.Items.Add("Portails") ddl3.Items.Add("Webzines, sites de magazines ") ddl4.Items.Add("Choisissez une entrée") ddl4.Items.Add("Documentation et orientation") ddl4.Items.Add("Juniors") ddl4.Items.Add("Organismes de formation, écoles") ddl4.Items.Add("Sites pour enseignants") ddl4.Items.Add("Sites pour étudiants, lycéens") ddl4.Items.Add("Soutien scolaire ") ddl5.Items.Add("Choisissez une entrée") ddl5.Items.Add("Annuaires d’entreprises, portails, moteurs") ddl5.Items.Add("Artisans") ddl5.Items.Add("Associations") ddl5.Items.Add("Banques de CV, aide à la création de CV") ddl5.Items.Add("Cabinets de recrutement") ddl5.Items.Add("Création d’entreprise, d’association") ddl5.Items.Add("Emploi à l’étranger") ddl5.Items.Add("Entreprises") ddl5.Items.Add("Formation professionnelle") ddl5.Items.Add("Intérim") ddl5.Items.Add("Petites annonces") ddl5.Items.Add("Portails de professions") ddl5.Items.Add("Restauration") ddl5.Items.Add("Services publics") ddl5.Items.Add("Sites d’annonces, banques de CV") ddl5.Items.Add("Sociétés de services") ddl5.Items.Add("Télétravail et travailleurs indépendants") ddl6.Items.Add("Choisissez une entrée") ddl6.Items.Add("Actualité, presse, livres, manifestations") ddl6.Items.Add("Aide, astuces, didacticiels, clubs") ddl6.Items.Add("Améliorer, bricoler le PC")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 23
Annuaire de sites web
517
ddl6.Items.Add("Divers") ddl6.Items.Add("Emulation") ddl6.Items.Add("Graphisme, 3D") ddl6.Items.Add("Gratuit") ddl6.Items.Add("Internet, création de sites") ddl6.Items.Add("Jeux et consoles") ddl6.Items.Add("Jeux et consoles : téléchargement gratuit") ddl6.Items.Add("Jeux et consoles : vente") ddl6.Items.Add("Langages Internet") ddl6.Items.Add("Logiciels") ddl6.Items.Add("Matériel") ddl6.Items.Add("Matériel : vente") ddl6.Items.Add("Musique") ddl6.Items.Add("PDA, calculatrices, ordinateurs de poche") ddl6.Items.Add("Photos, cliparts") ddl6.Items.Add("Programmation") ddl6.Items.Add("Sécurité") ddl6.Items.Add("Sharewares, freewares, logiciels gratuits") ddl6.Items.Add("Surf rémunéré") ddl6.Items.Add("Systèmes") ddl6.Items.Add("Wap, mobiles") ddl7.Items.Add("Choisissez une entrée") ddl7.Items.Add("Auto, moto, vélo") ddl7.Items.Add("Aviation") ddl7.Items.Add("Bricolage") ddl7.Items.Add("Chasse et pêche") ddl7.Items.Add("Collections, fêtes et costumes") ddl7.Items.Add("Coquin, rencontre, amour, mariage") ddl7.Items.Add("Gastronomie") ddl7.Items.Add("Gastronomie : alimentation bio") ddl7.Items.Add("Gastronomie : restaurants, bars") ddl7.Items.Add("Gastronomie : vins et boissons") ddl7.Items.Add("Glisse") ddl7.Items.Add("Hobby") ddl7.Items.Add("Humour") ddl7.Items.Add("Jardinage") ddl7.Items.Add("Jeux, parcs d’attractions, fêtes") ddl7.Items.Add("Photo") ddl7.Items.Add("Randonnée, montagne, ski") ddl7.Items.Add("Sports") ddl7.Items.Add("Technologie") ddl8.Items.Add("Choisissez une entrée")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
518
Visual Basic 2010
ddl8.Items.Add("Agences de presse") ddl8.Items.Add("Conseil, guides de marché") ddl8.Items.Add("DVD") ddl8.Items.Add("Journaux&mag en ligne : actualité") ddl8.Items.Add("Journaux&mag en ligne : culturel") ddl8.Items.Add("Journaux&mag en ligne : divers") ddl8.Items.Add("Journaux&mag en ligne : enfants") ddl8.Items.Add("Journaux&mag en ligne : informatique") ddl8.Items.Add("Journaux&mag en ligne : musique") ddl8.Items.Add("Journaux&mag en ligne : sport") ddl8.Items.Add("Publicité") ddl8.Items.Add("Radioamateurs") ddl8.Items.Add("Radios") ddl8.Items.Add("Sites généraux, sites portails") ddl8.Items.Add("Télévision, vidéo") ddl8.Items.Add("Veille technologique") ddl8.Items.Add("Wap") ddl8.Items.Add("WebTV") ddl9.Items.Add("Choisissez une entrée") ddl9.Items.Add("Archéologie, minéralogie") ddl9.Items.Add("Armée, police, gendarmerie") ddl9.Items.Add("Dictionnaires, glossaires, lexiques") ddl9.Items.Add("Encyclopédies") ddl9.Items.Add("Espace, astronomie, aviation") ddl9.Items.Add("Généalogie") ddl9.Items.Add("Généralités et actualités scientifiques") ddl9.Items.Add("Géographie, histoire") ddl9.Items.Add("Langues") ddl9.Items.Add("Mathématiques et sciences physiques") ddl9.Items.Add("Mers et océans") ddl9.Items.Add("Nature, animaux, protection des animaux") ddl9.Items.Add("Recherche") ddl9.Items.Add("Sciences (vie, terre, environnement)") ddl9.Items.Add("Sciences humaines et sociales") ddl9.Items.Add("Sciences médicales") ddl9.Items.Add("Spéléologie") ddl9.Items.Add("Traduction") ddl10.Items.Add("Choisissez une entrée") ddl10.Items.Add("Etudes et statistiques") ddl10.Items.Add("Forums, mouvements, débats") ddl10.Items.Add("Francophonie, Europe, culture française") ddl10.Items.Add("Humanitaire")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 23
Annuaire de sites web
519
ddl10.Items.Add("Ministères, gouvernements, lois") ddl10.Items.Add("Pouvoirs publics, administrations") ddl10.Items.Add("Sites de partis") ddl11.Items.Add("Choisissez une entrée") ddl11.Items.Add("Achats en ligne") ddl11.Items.Add("Acheter moins cher") ddl11.Items.Add("Ados, jeunes") ddl11.Items.Add("Alcool") ddl11.Items.Add("Animaux de compagnie") ddl11.Items.Add("Annuaires") ddl11.Items.Add("Aquariums") ddl11.Items.Add("Auto") ddl11.Items.Add("Beauté") ddl11.Items.Add("Bijoux") ddl11.Items.Add("Brocantes") ddl11.Items.Add("Chats, forums") ddl11.Items.Add("Chaussures") ddl11.Items.Add("Comparateurs de prix") ddl11.Items.Add("Cuisine, recettes") ddl11.Items.Add("Démarches et droits") ddl11.Items.Add("Drogues") ddl11.Items.Add("E-cartes") ddl11.Items.Add("E-mails gratuits, acheminement e-mail") ddl11.Items.Add("Enchères") ddl11.Items.Add("Extra-terrestres, inexpliqué, paranormal") ddl11.Items.Add("Faire des économies") ddl11.Items.Add("Famille") ddl11.Items.Add("Famille : guide") ddl11.Items.Add("Famille : vente") ddl11.Items.Add("Féminin : services") ddl11.Items.Add("Guides") ddl11.Items.Add("Handicapés") ddl11.Items.Add("Heroic fantasy, fées, sorcières") ddl11.Items.Add("Horoscopes, astrologie…") ddl11.Items.Add("Immobilier") ddl11.Items.Add("Maison, déco") ddl11.Items.Add("Météo") ddl11.Items.Add("Moteurs de recherche") ddl11.Items.Add("Moto") ddl11.Items.Add("Nourriture bio") ddl11.Items.Add("Petites annonces") ddl11.Items.Add("Portails, guides") ddl11.Items.Add("Santé")
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
520
Visual Basic 2010
ddl11.Items.Add("Seniors") ddl11.Items.Add("Services : trafic, réparation de lunettes…") ddl11.Items.Add("Sortir") ddl11.Items.Add("Tabac") ddl11.Items.Add("Tatouage, piercing") ddl11.Items.Add("Vêtements, mode") ddl12.Items.Add("Choisissez une entrée") ddl12.Items.Add("Ambassades") ddl12.Items.Add("Annuaires, moteurs de recherche") ddl12.Items.Add("Cartes") ddl12.Items.Add("Hébergement") ddl12.Items.Add("Monuments, sites") ddl12.Items.Add("Portails et sites généraux, annuaires") ddl12.Items.Add("Ressources et documentation") ddl12.Items.Add("Santé") ddl12.Items.Add("Tour opérateurs, agences, promotions") ddl12.Items.Add("Transports") ddl12.Items.Add("Visites virtuelles : étranger") ddl12.Items.Add("Visites virtuelles : France") End Sub
Sélectionnez la première liste déroulante, cliquez sur l’icône Événements dans la fenêtre des Propriétés et double-cliquez sur l’événement SelectedIndexChanged. Modifiez la procédure ddl1_SelectedIndexChanged() comme suit : Protected Sub ddl1_SelectedIndexChanged(ByVal sender As Object, ByVal e As „ System.EventArgs) Handles ddl1.SelectedIndexChanged Dim i As Integer = ddl1.SelectedIndex Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub
La première instruction définit la variable Integer I et lui affecte une valeur correspondant au numéro de l’entrée sélectionnée dans la liste : Dim i As Integer = ddl1.SelectedIndex
L’instruction suivante convertit cet index en une chaîne : Dim s As String = Str(i)
L’espace automatiquement ajouté à gauche de la chaîne est ensuite enlevé : s = Right(s, Len(s) - 1)
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 23
Annuaire de sites web
521
Puis l’adresse de la page à accéder est calculée : s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm"
Info
Les différentes pages accédées se trouvent dans le répertoire web http://lem. korp.free.fr/annuaire/data.
Il ne reste plus qu’à afficher la page dont l’adresse se trouve dans la variable String s à l’aide de la fonction Response.Write() : Response.Write("window.open(‘" + s + "‘)")
Le code correspondant à un changement dans les onze autres listes déroulantes est sensiblement identique : Protected Sub ddl2_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl2.SelectedIndexChanged Dim i As Integer = ddl2.SelectedIndex + 55 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub Protected Sub ddl3_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl3.SelectedIndexChanged Dim i As Integer = ddl3.SelectedIndex + 66 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub Protected Sub ddl4_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl4.SelectedIndexChanged Dim i As Integer = ddl4.SelectedIndex + 74 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub Protected Sub ddl5_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl5.SelectedIndexChanged Dim i As Integer = ddl5.SelectedIndex + 80
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
522
Visual Basic 2010
Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub Protected Sub ddl6_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl6.SelectedIndexChanged Dim i As Integer = ddl6.SelectedIndex + 97 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub Protected Sub ddl7_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl7.SelectedIndexChanged Dim i As Integer = ddl7.SelectedIndex + 121 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub Protected Sub ddl8_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl8.SelectedIndexChanged Dim i As Integer = ddl8.SelectedIndex + 140 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub Protected Sub ddl9_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl9.SelectedIndexChanged Dim i As Integer = ddl9.SelectedIndex + 158 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub Protected Sub ddl10_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl10.SelectedIndexChanged Dim i As Integer = ddl10.SelectedIndex + 178 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 23
Annuaire de sites web
523
Protected Sub ddl11_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl11.SelectedIndexChanged Dim i As Integer = ddl11.SelectedIndex + 185 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub Protected Sub ddl12_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl12.SelectedIndexChanged Dim i As Integer = ddl12.SelectedIndex + 228 Dim s As String = Str(i) s = Right(s, Len(s) - 1) s = "http://lem.korp.free.fr/annuaire/data/" + s + ".htm" Response.Write("window.open(‘" + s + "‘)") End Sub
Pour compléter cette page, vous allez inclure une image cliquable (image map). Pour cela, il suffit d’insérer un contrôle ImageMap (onglet Standard) sur la page web. L’image à utiliser se trouve à l’adresse http://lem.korp.free.fr/annuaire/titre.jpg. Affectez cette adresse à la propriété ImageUrl du contrôle ImageMap. Si vous avez suivi nos conseils, l’environnement de développement devrait maintenant ressemble à la Figure 23.5. Figure 23.5 L’image Map a été insérée sur la page.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
524
Visual Basic 2010
Vous allez maintenant affecter trois zones cliquables aux libellés "En savoir plus", "Joindre le Webmaster" et "Proposer un site". Pour ce faire, cliquez sur la propriété HotSpots. Un bouton contenant trois points de suspension apparaît en regard de la propriété HotSpots. Cliquez sur ce bouton. Une boîte de dialogue intitulée Éditeur de collections HotSpot s’affiche (voir Figure 23.6). Figure 23.6 Cet éditeur permet de définir des zones cliquables.
Cliquez sur la flèche située dans la partie droite du bouton Ajouter et sélectionnez RectangleHotSpot. Recommencez deux fois pour créer trois zones cliquables rectangulaires. Modifiez les propriétés de ces zones cliquables comme suit : Membre
Propriété
Valeur
RectangleHotSpot0
Bottom
144
RectangleHotSpot0
Left
25
RectangleHotSpot0
Right
144
RectangleHotSpot0
Top
124
RectangleHotSpot1
Bottom
144
RectangleHotSpot1
Left
171
RectangleHotSpot1
Right
340
RectangleHotSpot1
Top
119
RectangleHotSpot2
Bottom
144
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 23
Annuaire de sites web
Membre
Propriété
Valeur
RectangleHotSpot2
Left
366
RectangleHotSpot2
Right
500
RectangleHotSpot2
Top
122
525
Lancez l’application en cliquant sur l’icône Démarrer le débogage de la barre d’outils Standard et vérifiez que les trois zones textuelles sont cliquables (voir Figure 23.7). Figure 23.7 Les trois zones textuelles sont bien cliquables.
Pour réagir aux clics des utilisateurs, vous pouvez :
∑ ∑
afficher une page de votre choix ; générer un événement ImageMap.Click.
Pour afficher une page web lorsque l’utilisateur clique sur une zone HotSpot, affectez la valeur Navigate à la propriété HotSpotMode et l’URL cible à la propriété NavigateUrl du membre HotSpot correspondant (voir Figure 23.8). Pour générer un événement ImageMap.Click, affectez la valeur PostBack à la propriété HotSpotMode et une valeur String quelconque à la propriété PostBackValue du membre HotSpot correspondant (voir Figure 23.9).
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
526
Visual Basic 2010
Figure 23.8 Définition de l’URL cible pour le membre RectangleHotspot0.
Figure 23.9 Définition de la valeur à renvoyer lorsque le membre RectangleHotspot0 est cliqué.
Affectez les valeurs du tableau suivant aux trois HotSpots : Membre
Propriété
Valeur
RectangleHotSpot0
HotSpotMode
PostBack
RectangleHotSpot1
HotSpotMode
PostBack
RectangleHotSpot2
HotSpotMode
PostBack
RectangleHotSpot0
PostBackValue
0
RectangleHotSpot1
PostBackValue
1
RectangleHotSpot2
PostBackValue
2
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 23
Annuaire de sites web
527
Basculez sur l’éditeur de code. Sélectionnez ImageMap1 dans la liste déroulante Nom de la classe et Click dans la liste déroulante Nom de la méthode puis complétez la procédure ImageMap1_Click() comme suit : Protected Sub ImageMap1_Click(ByVal sender As Object, ByVal e As System.Web. „ UI.WebControls.ImageMapEventArgs) Handles ImageMap1.Click If e.PostBackValue = "0" Then Response.Write("window. „ open(‘http://lem.korp.free.fr/annuaire/data/plus.htm’)") If e.PostBackValue = "1" Then Response.Write("window. „ open(‘mailto:
[email protected]’)") If e.PostBackValue = "2" Then Response.Write("window. „ open(‘http://lem.korp.free.fr/annuaire/data/nouvsite.htm’)") End Sub
Si la valeur renvoyée par le contrôle HotSpot cliqué est "0", cela signifie que l’utilisateur a cliqué sur "En savoir plus". Dans ce cas, la page http://lem.korp.free.fr/annuaire/data/ plus.htm s’affiche dans une fenêtre annexe : If e.PostBackValue = "0" Then Response.Write("window.open „ (‘http://lem.korp.free.fr/annuaire/data/plus.htm’)")
Si la valeur renvoyée par le contrôle HotSpot cliqué est "1", cela signifie que l’utilisateur a cliqué sur "Joindre le Webmaster". Dans ce cas, la commande mailto: provoque l’ouverture d’une fenêtre de composition de message : If e.PostBackValue = "1" Then Response.Write("window. „ open(‘mailto:
[email protected]’)")
Enfin, si la valeur renvoyée par le contrôle HotSpot cliqué est "0", cela signifie que l’utilisateur a cliqué sur "Proposer un site". Dans ce cas, la page http://lem.korp.free.fr/annuaire/ data/nouvsite.htm s’affiche dans une fenêtre annexe : If e.PostBackValue = "2" Then Response.Write("window.open(‘http:// lem.korp.free.fr/annuaire/data/nouvsite.htm’)")
Le programme est totalement opérationnel. Vous pouvez l’exécuter en appuyant sur la touche F5. Tous les fichiers correspondants au projet Annuaire se trouvent dans le dossier Websites\Annuaire des sources de l’ouvrage. Pour mettre le site en ligne, lancez la commande Publier le site web dans le menu Générer. Cette commande affiche la boîte de dialogue représentée Figure 23.10.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
528
Visual Basic 2010
Figure 23.10 Boîte de dialogue de publication du site web.
Cliquez sur le bouton contenant trois points de suspension, à droite de la zone Emplacement cible. Une boîte de dialogue intitulée Publier le site web s’affiche. L’accès à votre site web se fait certainement en mode FTP. Cliquez sur l’icône Site FTP et remplissez les zones de texte nécessaires (voir Figure 23.11). Figure 23.11 Paramètres d’accès au serveur web.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
Chapitre 23
Annuaire de sites web
529
Il vous suffit maintenant de cliquer sur Ouvrir pour publier votre site web.Cette application est entièrement opérationnelle, mais sa maintenance laisse à désirer. En effet, tous les jours, des sites disparaissent ou changent d’adresse. Il est donc nécessaire d’effectuer des modifications fréquentes dans les 240 fichiers HTML. Ces modifications sont pénibles, car il faut à chaque fois : 1. Identifier le fichier à modifier. 2. Rapatrier ce fichier sur l’ordinateur local. 3. Effectuer la modification et éventuellement réorganiser la liste pour que les sites apparaissent dans un ordre alphabétique. 4. Renvoyer le fichier modifié sur le site web qui l’héberge. Pour faciliter la maintenance du site, nous allons transformer les 240 fichiers HTML en une base de données Access et utiliser un service web pour retrouver les enregistrements qui correspondent à la sélection de l’utilisateur.
Conversion des fichiers HTML en données Voici l’aspect d’un des 240 fichiers de données HTML. Ce fichier contient les informations qui s’affichent lorsque l’entrée Agences de presse est sélectionnée dans la liste déroulante Média, info. Média, info / Agences de presse FFAP www.agencesdepresse.fr Site de la Fédération française des agences de presse : présentation et „ annuaire. Maghreb, presse en ligne www.map.co.ma Site de l’Agence marocaine de presse : présentation, services et publications, „ actualités, presse, synthèses et analyses.
customer 27921 at Fri Mar 11 19:22:06 +0100 2011
Propriété de Albiri Sigue
530
Visual Basic 2010
Pour tous les sites référencés dans cette page, il est nécessaire d’extraire les informations suivantes :
∑ ∑ ∑ ∑
média, info et agences de presse entre les marqueurs et ; signet entre les marqueurs et ; URL entre les signets et ; texte entre les marqueurs et .
Ces informations feront l’objet de cinq champs dans la base de données MySQL. Pour les extraire, le plus simple consiste à utiliser une petite application Visual Basic. Après avoir copié/collé les 240 fichiers HTML dans un seul fichier texte, un nouveau projet reposant sur le modèle Application Windows Forms a été créé et la procédure Form1_Load() de ce projet a été complétée comme suit : Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles MyBase.Load Try FileOpen(1, "c:\data.txt", OpenMode.Input) FileOpen(2, "c:\champs.txt", OpenMode.Input) While Not EOF(1) ligne = LineInput(1) p = InStr(ligne, "") If p 0 Then Print #2, Mid(ligne, p + 4, Len(ligne) - p - 8) p = InStr(ligne, "") Print #2, Mid(ligne, p + 9, p2 - p - 10) p3 = InStr(p2, ligne, "
