Visual Basic 2010

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.



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





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



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



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


La boîte de dialogue Rechercher un dossier... 166


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



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



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


Étape 3 – Définition de l’éclairage.......... 438


É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


Rotation.................................................... 441


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



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



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





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.



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.



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).



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.



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.





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.



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



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).



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.



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.



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).



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).



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



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.



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.



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.



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.



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.



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



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.



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



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.



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.



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



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



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.



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



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



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 =, <>, <, <=, > et >= 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 b<>0 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



Chapitre 2


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



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



Chapitre 2


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)



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")



Chapitre 2


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.



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).



Chapitre 2


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.



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.



Chapitre 2

Info


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).



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).



Chapitre 2


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é.



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.



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.



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.



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.



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).



Chapitre 3


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.



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.



Chapitre 3

Info


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



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.



Chapitre 3


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.



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.



Chapitre 3


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).



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.



Chapitre 3


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 :



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.



Chapitre 3


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).



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.



Chapitre 3


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.



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.



Chapitre 3


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 "_".



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



Chapitre 3


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)



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}



Chapitre 3


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.



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 <= 10" End If End Sub

Il est également possible de définir une expression Lambda de type Sub sur une seule ligne de code, comme dans le code suivant : Dim monExpressionLambda = Sub(nombre As Integer) TextBox1.Text = nombre monExpressionLambda(12)

Dans cet exemple, l’appel de l’expression Lambda provoquera l’affichage de l’argument dans la zone de texte TextBox1.

Covariance et contravariance génériques Dans les versions antérieures de Visual Basic, les génériques se comportaient de façon invariante en ce qui concerne le sous-typage. Les conversions entre les types génériques présentant différents arguments de types n’étaient donc pas autorisées. Considérez le code suivant : Dim textboxCollection As IEnumerable(Of TextBox) = New List(Of TextBox) From „ {New TextBox} Dim ctrlCollection As IEnumerable(Of Control) = textboxCollection

Dans Visual Basic 2008, ce code produit une erreur : IEnumerable(Of TextBox) ne peut pas être converti en IEnumerable (Of Control)

Et pourtant, une valeur de type TextBox peut tout à fait être convertie en un contrôle ! De même, le code suivant n’est pas autorisé dans Visual Basic 2008 : Dim tbCollection As IList(Of TextBox) = New List(Of TextBox) From {New TextBox} Dim ctrlCollection As IList(Of Control) = tbCollection

Il produit une erreur de type InvalidCastException, car la deuxième ligne convertit un IList(Of TextBox) en un IList(Of Control). Si vous tentez d’écrire les deux codes précédents dans un programme Visual Basic 2010 qui cible le Framework .NET 4, le premier code sera autorisé mais pas le second. En effet les



Chapitre 3


63

IEnumerable(Of T) sont des interfaces "de sortie" alors que les IList(Of T) sont des interfaces "d’entrée-sortie". Dans les premiers, il n’est possible que de faire sortir des contrôles alors que dans les seconds, il est possible de faire sortir, mais aussi entrer des contrôles.

Dans Visual Studio 2010, l’infrastructure a été réécrite de la façon suivante : Interface IEnumerable(Of Out T) … End Interface Interface IList(Of T) … End Interface

Le mot Out dans IEnumerable(Of Out T) indique que si une méthode dans IEnumerable mentionne T, elle ne le fera qu’en sortie. Il est donc désormais possible d’effectuer un cast d’un IEnumerable(Of dérivé) en un IEnumerable(Of base) sans générer d’exception InvalidCastException. Cette nouvelle fonctionnalité porte le nom de covariance générique. Dans le même ordre d’idées, il est possible de retreindre "en entrée" un IComparer : Interface IComparer(Of In T) … End Interface

Il est donc possible de considérer un IComparer(Of Object) comme un IComparer(Of String) ! En effet, si un IComparer(Of T) peut comparer deux objets quelconques de type Object, il peut également comparer deux objets de type String. Cette nouvelle fonction nalité porte le nom de contravariance générique.

Prise en charge d’équivalence de type Avec Visual Basic 2010, vous pouvez désormais déployer une application dotée d’informations de type incorporé (et non de type importé) à partir d’un assembly PIA (Primary Interop Assembly). En utilisant des informations de type incorporé, l’application peut utiliser les types d’un runtime sans nécessiter de référence à l’assembly de runtime. Si différentes versions de l’assembly de runtime sont publiées, l’application peut fonctionner avec les différentes versions sans avoir à être recompilée.

Prise en charge dynamique Visual Basic crée une liaison avec les objets de langages dynamique tels que IronPython et IronRuby. Cette liaison se fait à l’aide de l’interface IDynamicMetaObjectProvider. Les classes DynamicObject et ExpandoObject constituent des exemples de classes qui implémentent l’interface IDynamicMetaObjectProvider.



64

Visual Basic 2010

Si un appel à liaison tardive est effectué vers un objet qui implémente l’interface IDynamicMetaObjectProvider, Visual Basic utilise cette interface pour créer une liaison avec l’objet dynamique. Si un appel à liaison tardive est effectué vers un objet qui n’implémente pas l’interface IDynamicMetaObjectProvider, ou si l’appel à l’interface IDynamicMetaObjectProvider

échoue, Visual Basic crée une liaison avec l’objet à l’aide des fonctions de liaison tardive de l’exécution Visual Basic. Vous en saurez plus à ce sujet en consultant le site CodePlex, à l’adresse http://dlr.codeplex.com/.

Programmation parallèle Aujourd’hui, le microprocesseur de la plupart des ordinateurs personnels et des stations de travail est doté de 2 ou 4 cœurs qui permettent à plusieurs threads de s’exécuter simultanément. Pour tirer parti de ces processeurs, vous pouvez paralléliser le code Visual Basic. Ainsi, le travail effectué par vos applications est distribué sur plusieurs cœurs et l’exécution du code est bien plus performante. N’ayez crainte, le code reste compatible avec les microprocesseurs dotés d’un seul cœur ! Visual Studio 2010 et le .NET Framework 4 améliorent grandement la prise en charge de la programmation parallèle en fournissant de nouvelles bibliothèques de classes. Par leur intermédiaire, il est "assez simple" d’écrire un code parallèle efficace. En particulier, la classe Parallel permet de répartir l’exécution de boucles For et For Each sur les différents cœurs disponibles. Vous pouvez également utiliser des tâches pour affecter des blocs de code à des cœurs différents. Vous en saurez plus à ce sujet en consultant le Chapitre 13.

Concepts avancés issus des versions précédentes de Visual Basic Cette section regroupe quelques innovations et concepts apparus dans les versions précédentes de Visual Basic (en particulier dans Visual Basic 2008) qu’il est bon d’avoir en tête pour utiliser Visual Basic 2010 aussi efficacement que possible.

Inférence de type Lorsque l’on parle de Visual Basic, on le qualifie souvent de "langage fortement typé". Cela signifie que les types de données utilisés décrivent de façon explicite les données



Chapitre 3


65

manipulées. À titre d’exemple, le langage PHP n’est pas fortement typé. Les instructions PHP suivantes sont ainsi tout à fait correctes : $maVariable = "mon texte"; // Un texte est affecté à la variable maVariable $maVariable = 5; // Puis la valeur entière 5 est affectée à cette même variable

Visual Basic n’autorise pas ce genre de largesse. Par contre, le compilateur de Visual Basic 2010 est en mesure de définir une variable typée de façon implicite, en examinant l’expression qui sert à l’initialiser. Ainsi, par exemple, ces deux instructions sont équivalentes : Dim monEntier = 3276 Dim monEntier as Integer = 3276

De même, les deux instructions suivantes sont équivalentes : Dim nom = "Michel" Dim nom As String = "Michel"

Info

L’inférence de type est initialisée par défaut. Si vous voulez la désactiver, utilisez l’instruction Option Infer Off.

Notez que l’inférence de type est également applicable aux tableaux. Par exemple, pour définir et initialiser un tableau contenant des Integer, vous écrirez quelque chose comme ceci : Dim Tableau = New Integer() {12, 25, 2}

Comme le montre la Figure 3.26, le compilateur affecte automatiquement à l’objet tableau le type tableau d’entiers. Figure 3.26 L’objet tableau a pour type tableau d’Integer.

Enfin, l’inférence de type peut être utilisée sur un retour d’appel de méthode (voir Figure 3.27). Figure 3.27 L’inférence de type va bien plus loin que la simple reconnaissance du type d’une donnée.



66

Visual Basic 2010

Le compilateur a vu que le retour de la fonction GetProcesses() était un tableau de Process. Ce type a donc été affecté à la variable mesprocesses.

Initialiseurs d’objets L’instruction With simplifie 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 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



Chapitre 3


67

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) 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 2008, 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.

Types anonymes Les déclarations d’objets contenant un ou plusieurs membres peuvent se faire sans spécifier leur type. Dans ce cas, un type anonyme, basé sur les types et noms des membres est créé.



68

Visual Basic 2010

Considérez le code suivant : Dim Employes = New With {.Nom = "Pierre Ledoyen", .Age = 27}

Étant donné qu’aucun type n’est précisé lors de la création de l’objet Employes, ce dernier sera de type anonyme. Il héritera de la classe Object et possèdera les propriétés spécifiées dans l’accolade (ici Nom et Age). Dès qu’un nouveau type anonyme a été défini, vous pouvez utiliser l’intellisense pour accéder à ses propriétés (voir Figure 3.28). Figure 3.28 Intellisense est actif.

Info

Les types anonymes ont un défaut : il est impossible d’y faire référence en tant que types, puisqu’ils n’ont pas de nom.

Méthodes d’extension Visual Basic 2010 permet d’étendre une classe, même si vous ne possédez pas le code de cette classe. Voyons comment procéder sur un exemple concret. Nous allons ajouter une méthode à la classe Ville (voir la section intitulée "Initialiseurs d’objets") pour connaître le nombre d’habitants de la ville spécifiée. Ajoutez un module à la solution avec la commande Ajouter un module dans le menu Projet. Donnez le nom MethExtensions.vb à ce module. Définissez enfin la fonction Population() comme suit : Public Function Population(ByVal uneVille As Ville) As Integer Select Case uneVille.Nom Case "Paris" Return 2153600 Case "Madrid" Return 3162304 Case Else Return 0 End Select End Function



Chapitre 3


69

Pour transformer ce code en une méthode d’extension de la classe Ville, il suffit de faire précéder l’instruction Function par . Comme vous pouvez le voir à la Figure 3.29, le terme Extension ne convient pas au compilateur. Figure 3.29 La fonction a été transformée en une extension de la classe Ville.

Pointez le terme souligné. Un point d’exclamation apparaît. Cliquez dessus et choisissez Modifiez ‘Extension’ en ‘Runtime.CompilerServices.Extension’ dans la liste (voir Figure 3.30) pour ajouter le NameSpace adéquat. Figure 3.30 Définition in extenso du terme Extension.

Cette fois-ci, la fonction est réellement devenue une extension de la classe Ville. Retournez dans le code du formulaire. La méthode Population est maintenant accessible par Intellisense (voir Figure 3.31). Figure 3.31 La méthode Population est bien accessible.

Génériques Les types génériques permettent de créer des classes, des procédures, des structures, des interfaces et des délégués qui manipulent des données dont le type n’est pas défini au départ.



70

Visual Basic 2010

Pour comprendre le fonctionnement des génériques, examinez le code ci-après : Private Sub echange(Of TypeDeDonnee)(ByRef donnee1 As TypeDeDonnee, „ ByRef donnee2 As TypeDeDonnee) Dim tampon As TypeDeDonnee tampon = donnee2 donnee2 = donnee1 donnee1 = tampon Console.Write("Après echange, donnee1 = ") Console.Write(donnee1) Console.Write(" et donnee2 = ") Console.WriteLine(donnee2) End Sub Sub Main() Dim int1 = 1 Dim int2 = 2 Dim st1 = "premier" Dim st2 = "deuxieme" echange(Of Integer)(Int1, int2) echange(Of String)(st1, st2) Console.Read() End Sub

La procédure echange est définie de façon générique (Of TypeDeDonnee), et deux paramètres génériques lui sont passés : Private Sub echange(Of TypeDeDonnee)(ByRef donnee1 As TypeDeDonnee, „ ByRef donnee2 As TypeDeDonnee)

Dans cette procédure, la variable générique tampon va permettre d’échanger les deux données passées en entrée : Dim tampon As TypeDeDonnee

Une fois l’échange effectué, les deux données s’affichent dans la fenêtre de texte : Console.Write("Après echange, donnee1 = ") Console.Write(donnee1) Console.Write(" et donnee2 = ") Console.WriteLine(donnee2)

La procédure principale appelle successivement la procédure echange en lui transmettant deux valeurs entières puis deux valeurs chaînes. Remarquez comment le type des variables est spécifié lors de l’appel : echange(Of Integer)(Int1, int2) echange(Of String)(st1, st2)



Chapitre 3


71

En utilisant une technique similaire, vous pouvez définir des classes, des structures, des interfaces et des délégués génériques. Les génériques offrent plusieurs avantages : ∑ ils sont fortement typés ; ∑ ils sont compatibles avec la fonctionnalité Intellisense de Visual Studio ; ∑ à l’exécution, ils sont plus rapides que des Objects ; ∑ les éventuelles erreurs sont détectées à la compilation et non à l’exécution.

Types Valeur Nullable Le type générique Nullable permet d’étendre les types valeur en vue d’accepter une valeur traditionnelle ou une valeur Null. Considérez le bloc de code suivant : Module Module1 Dim monInteger As Nullable(Of Integer) Sub Main() monInteger = Nothing Console.Write("monInteger.HasValue avant initialisation: ") Console.WriteLine(monInteger.HasValue) monInteger = 57 Console.Write("monInteger.HasValue après initialisation: ") Console.WriteLine(monInteger.HasValue) Console.Read() End Sub End Module

La variable monInteger est déclarée de type Integer Nullable : Dim monInteger As Nullable(Of Integer)

Si la valeur Nothing est affectée à la variable monInteger, la propriété HasValue renverra la valeur False. Si, par contre, une valeur non nulle est affectée à cette variable, la propriété HasValue renverra la valeur True (voir Figure 3.32). Figure 3.32 Illustration de type Valeur Nullable.



72

Visual Basic 2010

Dans Visual Basic 2010, trois syntaxes permettent de déclarer un type Nullable : Dim monInteger? As Integer Dim monInteger As Integer? Dim monInteger As Nullable(Of Integer)

Vous utiliserez :

∑ ∑

la propriété HasValue pour savoir si une variable de type Nullable n’est pas affectée ; la propriété Value pour récupérer la valeur de la variable Nullable.

Opérateur IIf L’opérateur IIf (Immediate If) affecte une valeur ou une autre en fonction du résultat d’un test : Dim Variable As Type = IIf(Condition, Valeur si vrai, Valeur si faux)

Par exemple, l’instruction suivante affecte la valeur 5 à la variable Resultat si a est supérieur à 0 et la valeur 6 dans le cas contraire : Dim Resultat as Integer = IIf(a > 0, 5, 6)

Dans Visual Basic 2010, vous pouvez indifféremment utiliser les opérateurs If et IIf pour parvenir au même résultat. L’instruction précédente devient donc : Dim Resultat as Integer = If(a > 0, 5, 6)

En combinant cette nouvelle écriture avec l’inférence de type, l’expression est encore simplifiée : Dim Resultat = IIf(a > 0, 5, 6)

Support étendu du code XML Visual Basic 2010 vous permet de définir des objets XML en exprimant littéralement leur contenu dans le code : Dim livres = Michel Martin CampusPress Ralph Steyer CampusPress



Chapitre 3


73

Comme vous pouvez le remarquer, aucun caractère terminateur de ligne n’est nécessaire lorsque vous définissez un objet contenant du code XML littéral. Quelques termes de vocabulaire qu’il est bon d’avoir à l’esprit avant de poursuivre la lecture sur le code XML :

∑ ∑

Les marqueurs XML sont appelés éléments ou nœuds. La racine d’un objet XML est l’élément le plus extérieur ( dans l’exemple précédent).

∑

Un attribut est une valeur incorporée à l’intérieur d’un élément (dans l’exemple précédent, Nom dans l’élément ).

∑

Les propriétés d’axe XML permettent d’accéder aux nœuds enfants, aux nœuds descendants et aux attributs des littéraux XML :

– l’axe enfant nomLittéral. donne accès à tous les enfants NomElément du littéral XML nomLittéral ;

– l’axe d’attribut nomLittéral.@NomAttribut donne accès aux attributs NomAttribut du littéral XML nomLittéral ;

– l’axe descendant nomLittéral… donne accès aux descendants du littéral XML nomLittéral, et ce, quel que soit leur niveau d’imbrication dans la structure XML :

– l’indexeur d’extension nomLittéral…(i) donne l’élément de rang i du descendant du littéral nomLittéral ;

– la valeur nomLittéral….Value donne la valeur String du premier élément du littéral XML nomLittéral. Info

Intellisense a été étendu pour fonctionner dans les éléments XML.

Délégués non stricts Pour ceux qui ne seraient pas encore familiers avec les délégués, nous allons commencer par introduire ces entités. Un délégué est un élément qui fait référence à une méthode (un pointeur de méthode en quelque sorte). Une fois initialisé, il suffit de l’invoquer pour appeler la méthode afférente. Voici un exemple de création et d’utilisation d’un délégué : Module Module1 Delegate Sub monDelegue()



74

Visual Basic 2010

Sub MaProcedure() System.Console.WriteLine("Ce texte est affiché par la Sub MaProcedure") System.Console.ReadLine() End Sub Sub Main() Dim Mondelegue As New monDelegue(AddressOf MaProcedure) Mondelegue() End Sub End Module

La première instruction crée le délégué MonDelegue : Delegate Sub monDelegue()

Le bloc d’instructions suivant définit la procédure MaProcedure() sur laquelle pointera le délégué. Cette procédure se contente d’afficher un texte en mode console et d’attendre l’appui sur la touche Entrée du clavier. Sub MaProcedure() System.Console.WriteLine("Ce texte est affiché par la Sub MaProcedure") System.Console.ReadLine() End Sub

La procédure principale initialise le délégué avec l’adresse de la procedure : Dim Mondelegue As New monDelegue(AddressOf MaProcedure)

Puis elle exécute la procédure via le délégué : Mondelegue()

De façon native, Visual Basic utilise des délégués pour lier les événements aux méthodes de traitement des objets. Ainsi par exemple, lorsque vous double-cliquez sur un bouton dans l’interface de conception de Visual Studio, un gestionnaire d’événements est automati quement créé et associé à l’événement clic par l’intermédiaire d’un délégué. Dans Visual Basic 2010, les paramètres transmis à une méthode événementielle pointée par un délégué peuvent être omis. Ainsi, par exemple, les deux instructions suivantes sont équivalentes : Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. EventArgs) Handles Button1.Click Private Sub Button1_Click() Handles Button1.Click

Cette facilité d’écriture est appelée "délégués non stricts" (relaxed delegates en anglais).



Chapitre 3


75

Expressions Lambda Par définition, 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))

Un autre exemple, un peu plus complexe : Sub ExecuteExpressionLambda(ByVal data As Integer, ByVal maFonction As Func „ (Of Integer, Boolean)) If maFonction(data) Then Console.WriteLine("L’expression Lambda a reçu la valeur 7") Else Console.WriteLine("L’expression Lambda n’a pas reçu la valeur 7") End If End Sub Sub Main() ExecuteExpressionLambda(7, Function(num) num = 7) Console.ReadLine() End Sub

Le premier bloc d’instructions définit la procédure ExecuteExpressionLambda() : Sub ExecuteExpressionLambda(ByVal data As Integer, ByVal maFonction As Func „ (Of Integer, Boolean))

Cette procedure admet deux arguments : la valeur entière data et la fonction maFonction (c’est l’expression Lambda), qui admet un argument entier et renvoie un argument booléen. Le code de maFonction() est élémentaire. Selon la valeur booléenne renvoyée, un message ou un autre s’affiche sur la console : If maFonction(data) Then Console.WriteLine("L’expression Lambda a reçu la valeur 7") Else Console.WriteLine("L’expression Lambda n’a pas reçu la valeur 7") End If



76

Visual Basic 2010

Il ne reste plus qu’à appeler la procédure ExecuteExpressionLambda() en lui transmettant la valeur et la fonction : ExecuteExpressionLambda(7, Function(num) num = 7)

Ici, la fonction se contente de tester si la valeur passée en argument est égale à 7.

Méthodes partielles Dans Visual Basic 2010, la définition d’une classe (ou d’une structure) peut être divisée en plusieurs déclarations partielles. À titre d’exemple, les deux instructions Partial Class ci-après définissent partiellement la classe maClasse. La première implémente la méthode meth1, et la deuxième la méthode meth2 Partial Public Public Sub End Sub End Class … Partial Public Public Sub End Sub End Class

Class maClasse meth1()

Class maClasse meth2()

Les différents éléments Partial peuvent se trouver dans le même fichier ou dans des fichiers différents.

Le langage LINQ LINQ est l’acronyme de Language INtegrated Query (langage d’interrogation intégré). Cette fonctionnalité est un véritable pas en avant : en utilisant une syntaxe proche de celle du langage SQL, il est désormais possible de manipuler des objets IEnumerable, du code XML, des Datasets et des bases de données SQL Server. Reportez-vous au Chapitre 27 pour savoir comment tirer parti de ces évolutions à travers les quatre principales techno logies associées :

∑ ∑ ∑ ∑

LINQ to Objects ; LINQ to XML ; LINQ to Dataset ; LINQ to SQL.

Dans ce chapitre, vous verrez que LINQ présente de nombreux avantages. Entre autres, il :

∑

simplifie l’écriture des requêtes ;



Chapitre 3

∑ ∑ ∑ ∑


77

utilise une syntaxe indépendante de la source de données ; facilite la vie du développeur ; gère les erreurs lors de la compilation (et non à l’exécution) ; supporte l’Intellisense et le débogage dans Visual Studio.

Techniques évoluées de Visual Studio 2005/2008 toujours d’actualité dans Visual Studio 2010 Cette section recense un certain nombre de techniques évoluées de Visual Studio 2005-2008/ Visual Basic 2005-2008, toujours utilisables dans Visual Studio 2010/Visual Basic 2010.

Alignement des contrôles Lorsque vous placez plusieurs contrôles sur une feuille, il est très simple de les aligner entre eux : cliquez sur le contrôle que vous voulez aligner, maintenez le bouton de la souris enfoncé et déplacez le contrôle horizontalement et/ou verticalement jusqu’à l’apparition des marques d’alignement (snap lines). Relâchez le bouton de la souris ; le contrôle est aligné (voir Figure 3.33). Figure 3.33 Alignement sur la partie inférieure d’un contrôle Label et d’un contrôle TextBox.

Menus Les contrôles MenuStrip et ContextMenuStrip remplacent les contrôles MainMenu et ContextMenu. Ces deux contrôles ont fait leur apparition dans la version 2 du Framework. Les menus peuvent désormais être composés de commandes traditionnelles (MenuItem), mais également de listes déroulantes (ComboBox) et de zones de texte (TextBox), et ce, à un quelconque niveau d’indentation (voir Figure 3.34).



78

Visual Basic 2010

Figure 3.34 Les trois types d’entrées d’un menu Visual Basic.

Pour définir rapidement les menus standard d’une application, il suffit désormais de cliquer doit sur la barre d’un contrôle MenuStrip et de sélectionner Insérer des éléments standard dans le menu contextuel (voir Figure 3.35). Figure 3.35 Cette commande augmentera sensiblement votre productivité.

Les commandes de menu que l’on rencontre le plus traditionnellement sont alors automatiquement ajoutées (voir Figure 3.36). Il ne vous reste plus qu’à jouer de la touche Suppr pour supprimer les commandes inutiles et à ajouter vos propres commandes. Les menus et commandes de menu peuvent apparaître horizontalement ou verticalement en utilisant les valeurs (Horizontal, Vertical90 ou Vertical270) de la propriété Text Direction (voir Figure 3.37).



Chapitre 3


79

Figure 3.36 Les menus traditionnels ont été mis en place d’un simple clic de souris.

Figure 3.37 Affichage vertical de la commande de menu Fichier.

Lorsque vous cliquez sur un contrôle MenuStrip dans la feuille, une petite flèche apparaît dans sa partie supérieure droite. Il suffit de cliquer dessus pour accéder aux propriétés les plus courantes (voir Figure 3.38). Figure 3.38 Cette nouveauté se révèle très pratique à l’utilisation.



80

Visual Basic 2010

Pour terminer, signalons qu’il est très simple d’associer une icône à chaque commande de menu : 1. Sélectionnez la commande dans la feuille de conception. 2. Cliquez sur la propriété Image dans la fenêtre des propriétés pour faire apparaître un bouton contenant trois points de suspension. 3. Cliquez sur ce bouton et désignez l’image en utilisant les ressources locales ou le fichier de ressources associé au projet (voir Figure 3.39). Figure 3.39 Association d’une icône à une commande de menu.

Vous trouverez un exemple d’utilisation des contrôles MenuStrip et ContextMenuStrip au Chapitre 6.

Barres d’outils Le contrôle ToolStrip succède dignement au contrôle ToolBar. Il manipule des éléments bien plus diversifiés que son prédécesseur (voir Figure 3.40). Pour ajouter les icônes que l’on retrouve traditionnellement dans une barre d’outils, cliquez droit sur le contrôle ToolStrip puis cliquez sur la commande Insérer des éléments standard (voir Figure 3.41). Le contrôle StatusStrip est le pendant Visual Basic 2010 du contrôle StatusBar. Il peut contenir un ou plusieurs StatusLabel, ProgressBar, DropDownButton et/ou SplitButton.

Info

Les contrôles StatusLabel peuvent être transformés en des liens hypertextes grâce à la propriété IsLink. Vous les utiliserez par exemple pour mettre à jour l’application d’un simple clic de l’utilisateur.



Chapitre 3


81

Figure 3.40 De nombreux types d’éléments peuvent être insérés dans un ToolStrip.

Figure 3.41 Cette barre d’outils a été complétée en deux clics de souris.

Vous trouverez un exemple d’utilisation des contrôles ToolStrip et StatusStrip au Chapitre 7.

Info-bulles Le contrôle NotifyIcon fait son apparition. Grâce à lui, vous pouvez afficher une info-bulle dans la barre de notification de Windows (également appelée Systray). Pour cela, vous devez, dans un premier temps, renseigner quelques propriétés :

∑

Icône dans la zone de notification : NotifyIcon1.Icon = SystemIcons.Asterisk

∑

Titre de l’info-bulle : NotifyIcon1.BalloonTipTitle = "titre du ballon"



82

∑

Visual Basic 2010

Texte affiché dans l’info-bulle : NotifyIcon1.BalloonTipText = "texte du ballon"

∑

Icône dans l’info-bulle : NotifyIcon1.BalloonTipIcon = ToolTipIcon.Info

Ces propriétés étant initialisées, rendez l’info-bulle visible : NotifyIcon1.Visible = True

Puis appelez la méthode ShowBalloonTip() en précisant le nombre de secondes d’affichage de l’info-bulle : NotifyIcon1.ShowBalloonTip(20)

La Figure 3.42 présente le résultat de l’exécution de ces quelques lignes de code. Figure 3.42 Quelques instructions suffisent pour afficher cette info-bulle.

Zone de texte avec marque de saisie Le contrôle MaskedTextBox facilite la saisie de données en utilisant un masque de saisie. Il suffit pour cela de choisir un des masques prédéfinis ou de créer le vôtre en cliquant sur le bouton contenant trois points de suspension de la propriété Mask (voir Figure 3.43). Figure 3.43 Masque de saisie de date, au format court.



Chapitre 3


83

Fenêtre des tâches Lorsque vous insérez un contrôle "complexe" dans une feuille, une petite flèche orientée vers la droite s’affiche dans sa partie supérieure droite. En cliquant dessus, vous avez directement accès aux propriétés et tâches les plus courantes associées à ce contrôle (voir Figure 3.44). Figure 3.44 Propriétés et tâches associées au contrôle DataGridView.

Navigateur web Le contrôle WebBrowser fait partie du jeu de composants par défaut (il n’est plus nécessaire d’importer le composant AxWebBrowser. Vous trouverez un exemple d’utilisation de ce contrôle au Chapitre 21.

Refactoring Le refactoring est une fonctionnalité très utile pour les programmeurs. Il permet d’extraire un code, de déclarer automatiquement des variables, de modifier le nom d’un symbole (et bien d’autres choses encore) en quelques clics de souris. Voyons comment mettre en œuvre cette fonctionnalité en raisonnant sur le code suivant : Public Class Form1 Sub calcul(ByVal i As Integer) ‘une ou plusieurs lignes de code End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click Dim i As Integer For i = 1 To 10 calcul(i) Next End Sub End Class



84

Visual Basic 2010

Ce code est un modèle de simplicité : la procédure événementielle Button1_Click() appelle dix fois de suite une procédure de calcul. Supposons que vous vouliez modifier le nom de la procédure. Placez le pointeur au-dessus d’un des mots "calcul", cliquez droit et choisissez Renommer dans le menu contextuel (voir Figure 3.45). Il ne vous reste plus qu’à choisir le nouveau nom dans la boîte de dialogue Renommer (voir Figure 3.46). Figure 3.45 Accès à la commande Renommer.

Figure 3.46 Choix du nouveau nom de la procédure.

Extraits En quelques clics de souris, les extraits (snippets) permettent d’insérer des blocs de code prédéfinis dans l’éditeur. Fini les recherches interminables pour retrouver l’extrait de code qui vous aidera à définir l’action que vous voulez accomplir ! Pour insérer un extrait, cliquez du bouton droit dans l’éditeur de code et sélectionnez la commande Insérer un extrait (voir Figure 3.47). Figure 3.47 Insertion d’un extrait.



Chapitre 3


85

Choisissez un dossier, un sous-dossier, puis un extrait. Le code est alors inséré dans la feuille de l’application, à l’emplacement du point d’insertion (voir Figure 3.48). Figure 3.48 Insertion du snippet Notions de base/Mathématiques/ Calculer le remboursement mensuel d’un emprunt.

ce Astu

Les amateurs de raccourcis clavier peuvent également appuyer sur Ctrl+K, puis sur Ctrl+X pour simuler la commande Insérer un extrait dans le menu contextuel de la fenêtre de code.

Pour terminer la définition de l’extrait, il vous suffit de modifier les paramètres qui apparaissent en caractères surlignés. Même s’ils représentent une base de départ intéressante, les extraits proposés dans Visual Studio sont assez restreints ; tôt ou tard, vous éprouverez le besoin de définir vos propres extraits de code. Pour cela, il vous suffit de définir un fichier XML contenant la description de l’extrait de code. Voyons comment procéder. Par défaut, Visual Basic 2010 stocke ses extraits dans le dossier Program Files\Microsoft Visual Studio 10.0\VB\Snippets\1036. Voici, à titre d’exemple, le contenu du fichier CalculateaMonthlyPaymentonaLoan.snippet, utilisé dans les lignes précédentes pour insérer l’extrait Calculer le remboursement mensuel d’un emprunt :
Calculer le remboursement mensuel d’un emprunt Microsoft Corporation Calcule le montant des remboursements mensuels „ d’un emprunt. mathPayLoan
System



86

Visual Basic 2010

Microsoft.VisualBasic annualInterestRate Double Remplacez par un Double pour le taux d’intérêt annuel „ (p. ex. 0,05 pour 5 %). .05 numberOfPayments Double Remplacez par le code qui retourne un Double pour le nombre „ total de versements mensuels. 36 loanAmount Double Remplacez par le code qui retourne un Double pour le montant „ de l’emprunt. 1000

Examinons les éléments contenus dans ce code :

∑

Le nom de l’extrait apparaît entre les balises et : Calculer le remboursement mensuel d’un emprunt

∑

La description de l’extrait apparaît entre les balises et : Calcule le montant des remboursements mensuels d’un emprunt. „



Chapitre 3

∑


87

Le bloc de code situé entre les balises et définit les Assembly utilisés par l’extrait. Ainsi, le cas échéant, une clause Imports sera ajoutée au début du code : System Microsoft.VisualBasic

Le bloc de code situé entre les balises et définit les variables qui doivent être ajustées par le programmeur (identificateur, type, info-bulle et valeur par défaut) : annualInterestRate Double Remplacez par un Double pour le taux d’intérêt annuel „ (p. ex. 0,05 pour 5 %). .05 …

Enfin, les dernières instructions définissent le code de l’extrait (les différentes variables sont repérées par leur champ ID et sont encadrées par des caractères "$") :

Vous avez maintenant tous les éléments nécessaires pour créer vos propres extraits. Pour les rendre accessibles, donnez-leur l’extension .snippet et stockez-les dans le dossier Program Files\Microsoft Visual Studio 10.0\VB\Snippets\1036.

Info

Dans les versions précédentes de Visual Studio, les snippets n’étaient disponibles que dans les éditeurs de code C# et Visual Basic. Désormais, cette fonctionnalité est étendue au code HTML/ASP.NET et au JavaScript.



88

Visual Basic 2010

Documenter le code en XML Il est fondamental de bien documenter votre code si vous travaillez en équipe ou que vous développiez un projet de grande envergure dont le temps d’écriture dépasse les six mois. Visual Basic automatise la création de documentation au format XML. Voyons comment mettre en œuvre cette fonctionnalité. Sur la ligne qui précède une déclaration Sub ou Function, insérez trois apostrophes consécutives. Un bloc XML est automatiquement créé (voir Figure 3.49). Il ne reste plus qu’à remplir les différents champs pour obtenir une documentation XML digne de programmeurs professionnels. Figure 3.49 Ces commentaires XML ont été créés par Visual Studio.

Un fichier XML est automatiquement généré lors de la compilation du programme. Par exemple, pour le gabarit de commentaires créé à la Figure 3.49, le fichier XML généré est le suivant : WindowsApplication1



Chapitre 3


89

Ces types de données sont facilement récupérables dans de nombreux programmes. En prenant quelques instants pour documenter tous les passages complexes de vos programmes, vous en assurerez la pérennité à moindres frais.

L’espace de nom My L’espace de nom (NameSpace) My est apparu dans Visual Basic 2005. Il est entièrement compatible Visual Basic 2010. Son approche résolument pratique facilite la vie du programmeur. Les éléments contenus dans ce nouvel espace de nom peuvent être répartis dans deux catégories :

∑

Raccourcis vers les classes du Framework : accès rapide et intuitif aux classes de base de la BCL (Base Class Library) du .NET Framework.

∑

Éléments dynamiques créés lors de la définition de l’interface et/ou de l’exécution du code : accès aux formulaires, contrôles, paramètres, ressources et services web créés lors de la conception ou de l’exécution de l’application.

Comme le montre la Figure 3.50, l’espace de nom My se décompose en plusieurs branches indépendantes. Figure 3.50 Structure de l’espace de nom My.

Dans cette section, nous allons vous montrer comment tirer parti de ce nouvel espace de nom en développant plusieurs petites applications qui exploitent les propriétés, procédures et fonctions afférentes au principaux objets qui le composent.



90

Visual Basic 2010

My.Application L’objet My.Application donne accès à des méthodes, propriétés et événements en rapport avec l’application en cours d’exécution et son environnement. Test des possibilités de l’objet My.Application Pour vous faire une idée des possibilités de l’objet My.Application, définissez une nouvelle application Windows Forms et donnez-lui le nom TestMyApplication. Affectez la valeur Test de l’objet My.Application à la propriété Text de l’objet Form1. Ajoutez un objet Label. Double-cliquez sur une partie inoccupée de la feuille et testez les fonctions et propriétés de l’objet My.Application dans la procédure Form1_Load() (voir Figure 3.51). Figure 3.51 Intellisense facilite la saisie du code.

La Figure 3.52 donne un exemple d’exécution de l’application. La propriété testée est My.Application.Info.DirectoryPath. Figure 3.52 My.Application.Info. DirectoryPath renvoie

le chemin complet de l’application.

Paramètres de la ligne de commande Les éventuels paramètres passés au programmes lors de son exécution (nom d’un fichier, valeur numérique, etc.) sont récupérés dans l’objet My.Application.CommandLineArgs. Pour vous montrer comment utiliser cet objet, vous allez définir une mini-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 RecupParam à l’application et validez. Affectez la valeur Paramètres de la ligne de commande à la propriété



Chapitre 3


91

Text de la feuille. Ajoutez un contrôle Label, affectez la valeur False à sa propriété AutoSize et redimensionnez le contrôle de sorte qu’il occupe la plus grande partie de la feuille

(voir Figure 3.53). Figure 3.53 La feuille de l’application en mode Édition.

Double-cliquez sur une partie inoccupée 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 Label1.Text = LigneCom() End Sub

L’unique instruction de cette procédure affecte la valeur renvoyée par la fonction LigneCom() à la propriété Text du contrôle Label1. Définissez la fonction LigneCom() comme suit : Private Function LigneCom() As String Dim i = 0 Dim st = "" For Each s As String In My.Application.CommandLineArgs i = i + 1 st = st + "argument " + Str(i) + " : " + s.ToString + Chr(13) Next If st = "" Then st = "Aucun paramètre n’a été passé à l’application." Return st End Function



92

Visual Basic 2010

Après avoir déclaré les deux variables utilisées dans la fonction : Dim i As Integer = 0 Dim st As String = ""

une boucle For Each Next parcourt les éventuels paramètres passés à l’application : For Each s As String In My.Application.CommandLineArgs … Next

À l’intérieur de la boucle, l’index de parcours est incrémenté : i = i + 1

Et la chaîne résultat est mise à jour avec le paramètre en cours : st = st + "argument " + Str(i) + " : " + s.ToString + Chr(13)

Si la chaîne est vide, cela signifie qu’aucun paramètre n’a été passé à l’application. La chaîne résultat est alors initialisée avec un texte indiquant l’absence de paramètre : If st = "" Then st = "Aucun paramètre n’a été passé à l’application."

La chaîne résultat est alors retournée par la fonction LigneCom() : Return st

Lancez le programme en appuyant sur la touche F5. Un message indique qu’aucun paramètre n’a été passé à l’application (voir Figure 3.54). Figure 3.54 Un message indique l’absence de paramètre.

Copiez le fichier Projects\RecupParam\bin\Debug\RecupParam.exe dans un dossier plus facile à atteindre (par exemple dans le dossier C:\test). Déroulez le menu Démarrer et entrez la commande représentée Figure 3.55.



Chapitre 3


93

Figure 3.55 Exécution du programme avec trois paramètres.

Info

Si vous travaillez sous Windows XP, lancez la commande Exécuter dans le menu Démarrer et tapez la commande de la Figure 3.55 dans la boîte de dialogue Exécuter.

La Figure 3.56 montre que les trois paramètres ont bien été récupérés par l’application. Figure 3.56 Les trois paramètres sont listés dans le contrôle Label.



94

Visual Basic 2010

My.Application.Info L’objet My.Application.Info est très intéressant. Comme le montre le tableau ci-après, il donne accès à des propriétés qui décrivent l’application en cours d’exécution. Propriété

Description

AssemblyName

Nom, sans extension, de l’assembly de l’application

CompanyName

Nom de société associé à l’application

Copyright

Note de copyright associée à l’application

Description

Description associée à l’application

DirectoryPath

Dossier à partir duquel l’application s’exécute

LoadedAssemblies

Collection de tous les assemblies chargés par l’application

ProductName

Nom de l’application

StackTrace

Trace de la pile de l’application

Title

Titre de l’application

Trademark

Marque déposée de l’application

Version

Numéro de version de l’application

WorkingSet

Quantité de mémoire physique associée au processus en cours d’exécution

Pour définir ces informations, vous pouvez initialiser les propriétés correspondantes dans le code de l’application : My.Application.Info.ProductName = "Nom de l’application" My. Application.Info.Version = "Numéro de version" My.Application.Info.Copyright = "Informations de copyright" My.Application.Info.CompanyName = "Nom de la société à l’origine de l’application" My.Application.Info.Description = "Description de l’application"

Mais il est bien plus pratique d’utiliser la méthode suivante : 1. Lancez la commande Propriétés de Projet1 du menu Projet. Cette commande affiche un nouvel onglet dans l’interface (voir Figure 3.57). 2. Cliquez sur le bouton Informations de l’Assembly et remplissez la boîte de dialogue représentée à la Figure 3.58.

1. Dans la commande de menu Propriétés de Projet, «Projet» représente le nom de votre projet (par exemple, Windows Application1 par défaut pour une application Windows).



Chapitre 3


95

Figure 3.57 Cet onglet donne accès aux informations relatives à l’application.

Figure 3.58 Personnalisez l’Assembly de l’application dans cette boîte de dialogue.

Boîte de dialogue "A propos" Définissez une nouvelle application Windows Forms et nommez-la AutoApropos. Lancez la commande Propriétés de projet du menu Projet, cliquez sur Informations de l’assembly et paramétrez la boîte de dialogue Informations de l’assembly comme montré à la Figure 3.59.



96

Visual Basic 2010

Figure 3.59 Un exemple de paramétrage.

Ajoutez une boîte de dialogue "A propos" au projet. Pour cela, lancez la commande Ajouter un formulaire Windows, du menu Projet, sélectionnez Boîte de dialogue A propos de, dans la boîte de dialogue Ajouter un nouvel élément (voir Figure 3.60), et validez en cliquant sur Ajouter. Figure 3.60 Ajout d’une boîte de dialogue "A propos" au projet.

Ajoutez un bouton de commande dans la feuille principale de l’application. Affectez la valeur Apropos à sa propriété Name et la valeur A propos à sa propriété Text. Doublecliquez sur ce bouton et complétez la procédure Apropos_Click() comme suit :



Chapitre 3


97

Private Sub APropos_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles APropos.Click AboutBox1.Show() End Sub

Exécutez le projet en appuyant sur la touche F5 et cliquez sur le bouton A propos. Comme le montre la Figure 3.61, les champs de la boîte de dialogue A propos ont été automati quement renseignés. Figure 3.61 Tous les renseignements sont issus de la boîte de dialogue Informations de l’assembly.

Cette application se trouve dans le dossier Projects\AutoApropos des sources de l’ouvrage.

My.Computer L’objet My.Computer fournit des méthodes, propriétés et événements permettant de manipuler des composants en rapport avec l’ordinateur et ses périphériques : horloge système, clavier, système audio, système graphique, etc. L’objet My.Computer compte douze membres :

∑ ∑ ∑ ∑ ∑

Audio ; Clipboard ; Clock ; FileSystem ; Info ;



98

Visual Basic 2010

∑ ∑ ∑ ∑ ∑ ∑ ∑

Keyboard ; Mouse ; Name ; Network ; Ports ; Registry ; Screen. Nous allons passer en revue leurs possibilités dans les pages suivantes. Lecture de sons WAV

La procédure My.Computer.Audio.Play permet de lire un son en tâche de fond. Supposons que le son "ExtraitSonore.wav" se trouve à la racine du disque C:. Vous pourrez utiliser une des trois instructions suivantes : My.Computer.Audio.Play("c:\ExtraitSonore.wav", AudioPlayMode.Background) My.Computer.Audio.Play("c:\ExtraitSonore.wav", AudioPlayMode.BackgroundLoop) My.Computer.Audio.Play("c:\ExtraitSonore.wav", AudioPlayMode.WaitToComplete)

La première instruction joue le son en tâche de fond, sans bloquer l’exécution du programme. Ce son peut être arrêté à tout moment en invoquant la procédure Stop() : My.Computer.Audio.Stop

La deuxième instruction est semblable à la première, à ceci près que le son se joue en boucle jusqu’à ce qu’il soit arrêté par la procédure Stop(). La troisième instruction bloque l’exécution du programme jusqu’à ce que le son soit entièrement joué.

Info

Si le deuxième paramètre n’est pas spécifié, le son est joué en tâche de fond.

Windows utilise une pléiade de "sons système" afin de faciliter l’identification d’événements tels que la réception d’e-mails, la fin d’une opération qui s’exécute en tâche de fond, la connexion et la déconnexion de périphériques, etc. Pour avoir une idée plus précise des sons disponibles, lancez la commande Panneau de configuration du menu Démarrer. Tapez sons dans la case de recherche (dans la partie supérieure droite de la boîte de dialogue) puis cliquez sur Modifier les sons système. Les sons associés aux événements système sont regroupés sous l’onglet Sons (voir Figure 3.62).



Chapitre 3


99

Figure 3.62 Association événements/sons système.

Info

Si vous utilisez Windows XP, vous devrez cliquer sur Sons, voix et périphériques audio, puis sur Sons et périphériques audio dans le Panneau de configuration pour parvenir au même résultat.

Pour modifier une association, sélectionnez un événement, cliquez sur Parcourir et choisissez un son système dans la boîte de dialogue Parcourir (voir Figure 3.63). Figure 3.63 Affectation d’un nouveau son système à l’événement Déconnecter le périphérique.



100

Visual Basic 2010

Pour jouer un son système, vous utiliserez la procédure PlaySystemSound() en précisant le nom du son à jouer : My.Computer.Audio.PlaySystemSound(System.Media.SystemSounds.Asterisk)

Les sons système accessibles par le biais de l’objet System.Media.SystemSounds sont les suivants :

∑ ∑ ∑ ∑ ∑

Asterisk ; Beep ; Exclamation ; Hand ; Question. Cependant, rien ne vous empêche d’accéder aux autres sons système en piochant dans le dossier Windows\Média. Presse-papiers

L’objet My.Computer.Clipboard permet de lire et d’écrire dans le presse-papiers de Windows. Vous utiliserez essentiellement les procédures et fonctions suivantes : Procédure

Action

SetText()

Place le texte spécifié dans le presse-papiers.

SetImage()

Place l’image spécifiée dans le presse-papiers.

SetAudio()

Place le son spécifié dans le presse-papiers.

ContainsText

Teste si le presse-papiers contient du texte.

ContainsImage

Teste si le presse-papiers contient une image.

ContainsAudio

Teste si le presse-papiers contient un son audio.

GetText

Renvoie le contenu texte du presse-papiers.

GetImage

Renvoie l’image contenue dans le presse-papiers.

GetAudio

Renvoie le son placé dans le presse-papiers.

Reportez-vous au Chapitre 5 pour examiner un exemple pratique d’utilisation de l’objet My.Computer.Clipboard. Accès à l’horloge système L’objet My.Computer.Clock donne accès à l’horloge système. Vous utiliserez les trois f onctions suivantes :



Chapitre 3


Fonction

Action

GmtTime

Renvoie la date et l’heure GMT. Équivalente à la propriété System.DateTime. UtcNow.

LocalTime

Date et heure locales système. Équivalente à la propriété DateTime.Now.

TickCount

Compteur de temps système, incrémenté toutes les millisecondes depuis le démarrage de l’ordinateur.

101

Définissez une nouvelle application Windows Forms que vous nommerez My Computer Clock. Ajoutez trois contrôles Label et trois contrôles Button à cette application. Modifiez les propriétés de ces contrôles comme suit : Contrôle

Propriété

Valeur

Form1

Text

Test de l’objet My.Computer.Clock

Label1

Text

Label2

Text

Label3

Text

Button1

Text

Date et heure GMT

Button2

Text

Date et heure locales

Button3

Text

Timer système

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 Label1.Text = "Date et heure GMT : " + My.Computer.Clock.GmtTime.ToString End Sub

L’unique instruction de cette procédure convertit en une chaîne la valeur renvoyée par la fonction GmtTime() et l’affecte à la propriété Text du contrôle Label1. Double-cliquez sur le deuxième 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 Label2.Text = "Date et heure locale : " + My.Computer.Clock.LocalTime.ToString End Sub



102

Visual Basic 2010

Cette procédure est très proche de la précédente, mais ici, la fonction invoquée est LocalTime(). Double-cliquez enfin 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 Label3.Text = "Timer système : " + My.Computer.Clock.TickCount.ToString End Sub

Ici, la fonction invoquée est TickCount(). La valeur renvoyée est un Integer. Elle est donc convertie en un String avant d’être affectée à la propriété Text du contrôle Label3. Vous trouverez un autre exemple d’utilisation de l’objet My.Computer.Clock au Chapitre 8 dédié à l’affichage d’une horloge graphique et à la mise en place d’un économiseur d’écran personnalisé. Lecture/écriture dans des fichiers L’objet My.Computer.FileSystem propose plusieurs procédures et fonctions pour lire ou écrire dans un fichier. Fonction

Action

My.Computer.FileSystem.ReadAllText(Nom du fichier)

Lit un fichier texte.

My.Computer.FileSystem.ReadAllText(Nom du fichier, Type d’encodage)

Lit un fichier texte encodé.

My.Computer.FileSystem.ReadAllBytes(Nom du fichier)

Lit un fichier binaire.

My.Computer.FileSystem.WriteAllText (Nom du fichier, Chaîne, False)

Écrit dans un fichier texte.

My.Computer.FileSystem.WriteAllText (Nom du fichier, Chaîne, True)

Écrit à la fin d’un fichier texte.

My.Computer.FileSystem.WriteAllBytes(Nom du fichier, Données, Écrit dans un fichier binaire. True)

Voyons comment utiliser ces nouvelles procédures et fonctions du Framework .NET 4 au travers d’un exemple concret. Un bloc-notes en quatre lignes de code 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 Mémo2 à la nouvelle



Chapitre 3


103

application. Ajoutez un contrôle TextBox et deux contrôles Button à la feuille de l’application. Modifiez les propriétés de ces contrôles comme suit : Contrôle

Propriété

Valeur

Form1

Text

Accès à un fichier texte

TextBox1

Multiline

True

TextBox1

(Name)

Mémo

TextBox1

ScrollBars

Vertical

Button1

Text

Effacer

Button2

Text

Quitter

Double-cliquez sur un endroit 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 Mémo.Text = My.Computer.FileSystem.ReadAllText("c:\memo.txt") End Sub

L’unique instruction de cette procédure effectue les actions suivantes :

∑ ∑ ∑ ∑

ouverture du fichier texte c:\memo.txt en lecture ; lecture de toutes les lignes qui le composent ; affectation des données lues à la propriété Text du contrôle Mémo ; fermeture du fichier c:\memo.txt.

À titre d’information, voici les instructions équivalentes, sans recourir à l’objet My.Computer. FileSystem : dim tout as String = "" 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



104

Visual Basic 2010

Avouez qu’il est bien plus agréable de mettre en œuvre un objet My.Computer.FileSystem ! 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 Mémo.Text = "" End Sub

L’action effectuée par cette procédure est très simple à comprendre : elle efface le contenu du contrôle Mémo. Enfin, double-cliquez sur le deuxième 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 My.Computer.FileSystem.WriteAllText("c:\memo.txt", Mémo.Text, False) End End Sub

La première instruction effectue trois actions :

∑ ∑ ∑

ouverture du fichier texte c:\memo.txt en écriture ; copie du contenu du contrôle Mémo dans le fichier texte ; fermeture du fichier c:\memo.txt.

Voici, à titre de comparaison, les instructions équivalentes, sans recourir à l’objet My.Computer.FileSystem : Try FileOpen(1, "c:\memo.txt", OpenMode.Output) Print(1, Mémo.Text) Catch Finally FileClose(1) End Try End

Après avoir écrit le contenu de la zone de texte dans le fichier, le programme utilise une instruction End pour mettre fin au programme. Voici le listing complet du programme. Tous les fichiers de la solution correspondante se trouvent dans le dossier Projects\Memo2 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



Chapitre 3


105

Mémo.Text = My.Computer.FileSystem.ReadAllText("c:\memo.txt") End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button1.Click Mémo.Text = "" End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click My.Computer.FileSystem.WriteAllText("c:\memo.txt", Mémo.Text, False) End End Sub End Class

Lecture dans un fichier texte délimité La plupart des applications qui manipulent des données tabulaires (Microsoft Excel par exemple) sont en mesure de stocker ces données dans des fichiers texte délimités. Visual Basic utilise une technique particulière pour accéder à ces fichiers. Pour rester pratiques, nous allons raisonner sur le fichier texte suivant : ,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

Info

Dans la suite, nous supposerons que ce fichier a pour nom "data.txt" et qu’il se trouve dans le dossier C:\test.

Définissez un nouveau projet de type Application Windows Forms et donnez-lui le nom LectDélim. Ajoutez un contrôle DataGridView dans la feuille de l’application. Affectez la valeur Lecture d’un fichier texte délimité à la propriété Text du contrôle Form1, et la valeur Dock à la propriété Dock du contrôle DataGridView1. 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 ‘ Définition du TextFieldParser



106

Visual Basic 2010

Using MyReader As New Microsoft.VisualBasic.FileIO.TextFieldParser „ ("c:\test\data.txt") ‘ Définition du type de champs et du délimiteur MyReader.TextFieldType = FileIO.FieldType.Delimited MyReader.SetDelimiters(",") ‘ Lecture des données et affichage Dim ligne As String() Dim i As Integer Dim s(0 To 5) As String DataGridView1.ColumnCount = 5 While Not MyReader.EndOfData Try ligne = MyReader.ReadFields() i = 0 Dim champ As String For Each champ In ligne i = i + 1 s(i) = champ Next DataGridView1.Rows.Add(New String() {s(1), s(2), s(3), s(4), s(5)}) Catch ex As Microsoft.VisualBasic.FileIO.MalformedLineException MsgBox("L’enregistrement " & ex.Message & _ "n’est pas valide. Il a été ignoré.") End Try End While End Using End Sub

Examinons les instructions contenues dans cette procédure. Le code repose sur une structure Using End Using dans laquelle on manipule un objet FileIO.TextFieldParser : Using MyReader As New Microsoft.VisualBasic.FileIO.TextFieldParser „ ("c:\test\data.txt") ... End Using

Cette simple instruction ouvre le fichier texte délimité c:\test\data.txt.

Info

Le mot-clé Using a fait son apparition dans le Framework .NET 2.0. Il permet de créer un bloc de code qui sera disposé (enlevé de la mémoire) lorsque son exécution sera terminée. Les programmeurs C# connaissent ce principe depuis belle lurette…



Chapitre 3


107

Le bloc d’instructions suivant spécifie le type du fichier et décrit le délimiteur utilisé entre les divers champs d’un enregistrement : MyReader.TextFieldType = FileIO.FieldType.Delimited MyReader.SetDelimiters(",")

La procédure se poursuit par la déclaration de quelques variables : Dim ligne As String() Dim i As Integer Dim s(0 To 5) As String

Le nombre de colonnes du contrôle DataGridView est alors fixé à 5 : DataGridView1.ColumnCount = 5

La lecture des enregistrements se fait à l’intérieur d’une boucle While End While qui prend fin lorsque toutes les données du fichier ont été lues : While Not MyReader.EndOfData ... End While

Pour lire un enregistrement, il suffit d’invoquer la fonction ReadFields() : Try ligne = MyReader.ReadFields()

L’extraction des champs se fait à l’aide d’une instruction For Each Next : For Each champ In ligne

Les champs lus sont stockés dans le tableau de String s : i = i + 1 s(i) = champ

Les données d’un enregistrement sont ensuite placées dans le contrôle DataGridView à l’aide de la procédure Add() : DataGridView1.Rows.Add(New String() {s(1), s(2), s(3), s(4), s(5)})

Si une erreur se produit pendant la lecture des enregistrements, elle est capturée par l’instruction Catch et provoque l’affichage d’un message d’erreur : Catch ex As Microsoft.VisualBasic.FileIO.MalformedLineException MsgBox("L’enregistrement " & ex.Message & _ "n’est pas valide. Il a été ignoré.") End Try



108

Visual Basic 2010

La Figure 3.64 représente l’exécution du programme LectDélim. Les virgules ont bien été interprétées comme délimiteurs de champs. Figure 3.64 Les données sont bien représentées sous une forme tabulaire.

Lecture de champs de longueur fixe Certains fichiers de données contiennent des champs de longueur fixe. Pour accéder à ce type de fichiers, vous utiliserez une instruction Using, comme dans la section précédente : Using MyReader As New Microsoft.VisualBasic.FileIO.TextFieldParser("c:\data. txt")

Vous indiquerez ensuite que les champs ont une longueur fixe : Microsoft.VisualBasic.FileIO.FieldType.FixedWidth

Puis vous définirez la longueur de chaque champ. Par exemple, si un enregistrement est constitué de trois champs de longueurs respectives 5, 12 et 6 caractères, vous écrirez : Reader.SetFieldWidths(5, 12, 6)

Info

Si un champ a une longueur variable, vous utiliserez la valeur "–1" dans la procédure SetFieldWidths(), par exemple : Reader.SetFieldWidths(5, 12, -1)

Comparaison de deux fichiers binaires 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 CompareBin à la nouvelle application. Ajoutez trois Label, deux TextBox et un Button à la feuille de l’application. Modifiez les propriétés de ces contrôles comme suit :



Chapitre 3


109

Contrôle

Propriété Valeur

Form1

Text

Comparaison de fichiers binaires

Label1

Text

Nom complet du premier fichier

Label2

Text

Nom complet du second fichier

Button

Text

Comparer

Label3

Text

Entrez le nom des deux fichiers binaires à comparer, puis cliquez sur Comparer.

Repositionnez ces contrôles pour obtenir un aspect visuel proche de la Figure 3.65. Figure 3.65 La feuille de l’application en mode Conception.

Double-cliquez sur le bouton Comparer 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 TextBox1.Text = "" Then Label3.Text = "Entrez le nom complet du premier fichier „ à comparer" If TextBox2.Text = "" Then Label3.Text = "Entrez le nom complet du second fichier „ à comparer" If My.Computer.FileSystem.FileExists(TextBox1.Text) = False Then Label3.Text „ = "Le premier fichier n’existe pas" If My.Computer.FileSystem.FileExists(TextBox2.Text) = False Then Label3.Text „ = "Le second fichier n’existe pas" If TextBox1.Text <> "" And TextBox2.Text <> "" And _ My.Computer.FileSystem.FileExists(TextBox1.Text) And _ My.Computer.FileSystem.FileExists(TextBox2.Text) Then Dim val1 As Byte() = My.Computer.FileSystem.ReadAllBytes(TextBox1.Text) Dim val2 As Byte() = My.Computer.FileSystem.ReadAllBytes(TextBox2.Text) Dim resultat As Boolean Dim i As Integer



110

Visual Basic 2010

If val1.Length <> val2.Length Then resultat = False Else resultat = True For i = 0 To val1.Length - 1 If val1(i) <> val2(i) Then resultat = False Next End If If resultat = True Then Label3.Text = "Les deux fichiers sont identiques" Else Label3.Text = "Les deux fichiers sont différents" End If End If End Sub

Le premier bloc d’instructions teste si l’utilisateur a bien entré deux noms de fichiers et, le cas échéant, si ces fichiers existent. Si une de ces conditions est mise en défaut, un message d’erreur apparaît dans le contrôle Label3 : If TextBox1.Text = "" Then Label3.Text = "Entrez le nom complet du premier fichier „ à comparer" If TextBox2.Text = "" Then Label3.Text = "Entrez le nom complet du second fichier à comparer" If My.Computer.FileSystem.FileExists(TextBox1.Text) = False Then Label3.Text „ = "Le premier fichier n’existe pas" If My.Computer.FileSystem.FileExists(TextBox2.Text) = False Then Label3.Text „ = "Le second fichier n’existe pas"

Si les quatre tests sont concluants : If TextBox1.Text <> "" And TextBox2.Text <> "" And _ My.Computer.FileSystem.FileExists(TextBox1.Text) And _ My.Computer.FileSystem.FileExists(TextBox2.Text) Then

les deux fichiers binaires sont lus et stockés dans les variables val1 et val2 : Dim val1 As Byte() = My.Computer.FileSystem.ReadAllBytes(TextBox1.Text) Dim val2 As Byte() = My.Computer.FileSystem.ReadAllBytes(TextBox2.Text)

Deux variables sont alors déclarées : resultat pour mémoriser le résultat de la comparaison, et i pour parcourir le contenu des fichiers binaires : Dim resultat As Boolean Dim i As Integer



Chapitre 3


111

Si les deux fichiers ont des tailles différentes, ils sont forcément différents : If val1.Length <> val2.Length Then resultat = False

Dans le cas contraire, tous les octets des deux fichiers sont comparés un à un. Dès qu’une différence est trouvée, la variable resultat est initialisée à False : Else resultat = True For i = 0 To val1.Length - 1 If val1(i) <> val2(i) Then resultat = False Next End If

Pour terminer, un message s’affiche dans le contrôle Label3 pour indiquer si les deux fichiers sont identiques ou différents. If resultat = True Then Label3.Text = "Les deux fichiers sont identiques" Else Label3.Text = "Les deux fichiers sont différents" End If

Accès aux dossiers particuliers de Windows L’objet My.Computer.FileSystem.SpecialDirectories donne accès aux dossiers particuliers de Windows : AllUsersApplicationData, CurrentUserApplicationData, Desktop, MyDocuments, MyMusic, MyPictures, ProgramFiles, Programs et Temp. Il est très simple de mettre en œuvre cet objet pour lire ou écrire des fichiers à l’emplacement souhaité. Par exemple, pour lire un hypothétique fichier texte data.txt situé dans le dossier Mes documents, vous utiliserez l’instruction suivante : Dim s As String = My.Computer.FileSystem.ReadAllText(My.Computer.FileSystem. SpecialDirectories.MyDocuments + "c:\memo.txt")

Manipulation de fichiers et de dossiers Au Chapitre 9, vous apprendrez à manipuler des fichiers et des dossiers en utilisant les instructions traditionnelles de Visual Basic, telles que File.Copy, File.Delete, Directory. CreateDirectory et Directory.Delete. Dans cette section, nous allons vous montrer comment employer leurs équivalents .NET 4. Liste des fichiers d’un dossier Pour obtenir la liste des fichiers contenus dans un dossier, il suffit de faire appel à la fonction My.Computer.FileSystem.GetFiles(). Le résultat est renvoyé sous la forme d’une collection de chaînes.



112

Visual Basic 2010

Dans sa forme la plus simple, la fonction GetFiles() admet un seul argument : le nom du dossier à parcourir. Pour étendre les possibilités de cette fonction, vous pouvez utiliser une seconde syntaxe mettant en jeu trois arguments : My.Computer.FileSystem.GetFiles(dossier, type_recherche, modèle)

où :

∑ ∑ ∑

dossier est le dossier dans lequel est effectuée la recherche. type_recherche peut limiter la recherche au dossier spécifié (valeur FileIO.Search Option.SearchTopLevelOnly) ou l’étendre aux éventuels sous-dossiers du dossier spécifié (valeur FileIO.SearchOption.SearchAllSubDirectories). modèle est un modèle de recherche pouvant contenir un ou plusieurs caractères de remplacement (? remplace un caractère, * remplace un nombre quelconque de caractères).

Pour illustrer la fonction GetFiles(), nous allons réaliser une petite application dans laquelle l’utilisateur visualisera le contenu d’un dossier de son choix. 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 ListeFichiers à l’application et validez en cliquant sur OK. Ajoutez les contrôles suivants dans la feuille de l’application :

∑ ∑ ∑

trois Button ; un FolderBrowserDialog (dossier Boîtes de dialogue, situé dans la Boîte à outils) ; un ListView.

Modifiez les propriétés de ces contrôles comme indiqué dans le tableau ci-après. Contrôle

Propriété

Valeur

Form1

Text

Liste des fichiers d’un dossier

Button1

Text

Dossier

Button2

Text

Enregistrer

Button3

Text

Quitter

ListView1

Dock

Top

Modifiez la disposition de ces contrôles pour obtenir une feuille semblable à la Figure 3.66.



Chapitre 3


113

Figure 3.66 La feuille de l’application en mode Conception.

Nous allons maintenant définir les procédures événementielles de l’application. 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 FolderBrowserDialog1.Description = "Sélectionnez un dossier" FolderBrowserDialog1.RootFolder = Environment.SpecialFolder.MyComputer FolderBrowserDialog1.ShowNewFolderButton = False ListView1.View = View.List ListView1.Sorting = SortOrder.Ascending End Sub

Cette procédure initialise les contrôles FolderBrowserDialog et ListView. La première instruction définit le texte affiché dans la boîte de dialogue : FolderBrowserDialog1.Description = "Sélectionnez un dossier"

La deuxième instruction définit le point de départ de l’arborescence, ici le dossier Poste de travail (My Computer) : FolderBrowserDialog1.RootFolder = Environment.SpecialFolder.MyComputer

La troisième instruction cache le bouton Nouveau dossier. Ainsi, l’utilisateur ne pourra pas créer un nouveau dossier dans l’arborescence des mémoires de masse : FolderBrowserDialog1.ShowNewFolderButton = False

La quatrième instruction définit le type d’affichage dans le contrôle ListView (vous avez le choix entre cinq représentations : Details, LargeIcon, List, SmallIcon et Title) : ListView1.View = View.List

Enfin, la dernière instruction demande que les fichiers listés soient classés par ordre croissant : ListView1.Sorting = SortOrder.Ascending



114

Visual Basic 2010

Vous allez maintenant écrire le code responsable de l’affichage de la boîte de dialogue commune Rechercher un dossier. Double-cliquez sur le bouton Dossier 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 FolderBrowserDialog1.ShowDialog() = Windows.Forms.DialogResult.OK Then ListView1.Clear() For Each fichier As String In My.Computer.FileSystem. GetFiles(FolderBrowserDialog1.SelectedPath) ListView1.Items.Add(fichier) Next End If End Sub

Si l’utilisateur sélectionne un dossier : If FolderBrowserDialog1.ShowDialog() = Windows.Forms.DialogResult.OK Then

le contenu du contrôle ListView est effacé : ListView1.Clear()

Une instruction For Each parcourt la liste des fichiers du dossier sélectionné : For Each fichier As String In My.Computer.FileSystem. GetFiles(FolderBrowserDialog1.SelectedPath)

et les fichiers trouvés sont ajoutés au contrôle ListView : ListView1.Items.Add(fichier)

Nous allons permettre à l’utilisateur de sauvegarder la liste des fichiers qui apparaissent dans le contrôle ListView. Double-cliquez sur le bouton Enregistrer 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 My.Computer.FileSystem.DeleteFile("C:\test\resultat.txt") Catch End Try For Each fichier As String In My.Computer.FileSystem.GetFiles(FolderBrowser „ Dialog1.SelectedPath)



Chapitre 3


115

fichier = fichier + vbCrLf My.Computer.FileSystem.WriteAllText ("C:\test\resultat.txt", fichier, True) Next End Sub

Le premier bloc d’instructions tente de supprimer le fichier c:\test\resultat.txt. Lors de la première exécution du programme, ce fichier n’existait pas. C’est la raison pour laquelle nous avons placé l’instruction qui efface le fichier dans une structure Try afin de capturer et d’annuler le message d’erreur : Try My.Computer.FileSystem.DeleteFile("C:\test\resultat.txt") Catch End Try

Le bloc d’instructions suivant parcourt le dossier sélectionné par l’utilisateur à l’aide d’une instruction For Each : For Each fichier As String In My.Computer.FileSystem. GetFiles(FolderBrowserDialog1.SelectedPath)

Chaque nom de fichier est suivi d’un retour à la ligne : fichier = fichier + vbCrLf

Puis la chaîne ainsi obtenue est copiée à la fin (troisième paramètre à True) du fichier texte c:\test\resultat.txt : My.Computer.FileSystem.WriteAllText ("C:\test\resultat.txt", fichier, True)

Double-cliquez sur le bouton Quitter et ajoutez une instruction End à la procédure Button3_Click() : Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) „ Handles Button3.Click End End Sub

Vous pouvez lancer l’application en appuyant sur la touche F5 du clavier. Une fois la feuille de l’application ouverte, cliquez sur Dossier et choisissez un dossier quelconque. Validez en cliquant sur OK. Les fichiers contenus dans le dossier apparaissent dans le contrôle ListView (voir Figure 3.67). Cliquez sur Enregistrer. Le fichier Résultat.txt contenant la liste des fichiers de la racine du disque C:\ est immédiatement créé (voir Figure 3.68).



116

Visual Basic 2010

Figure 3.67 Liste des fichiers contenus dans la racine du disque C:\.

Figure 3.68 Le fichier c:\test\resultat.txt contient la liste des fichiers de la racine du disque C:\.

Voici le listing complet de l’application. Les fichiers correspondants se trouvent dans le dossier Projects\ListeFichiers 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 FolderBrowserDialog1.Description = "Sélectionnez un dossier" FolderBrowserDialog1.RootFolder = Environment.SpecialFolder.MyComputer FolderBrowserDialog1.ShowNewFolderButton = False ListView1.View = View.List



Chapitre 3


117

ListView1.Sorting = SortOrder.Ascending End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs)Handles Button1.Click If FolderBrowserDialog1.ShowDialog() = Windows.Forms.DialogResult.OK Then ListView1.Clear() For Each fichier As String In My.Computer.FileSystem.GetFiles(Folder „ BrowserDialog1.SelectedPath) ListView1.Items.Add(fichier) Next End If End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button2.Click Try My.Computer.FileSystem.DeleteFile("C:\test\resultat.txt") Catch End Try For Each fichier As String In My.Computer.FileSystem.GetFiles(Folder „ BrowserDialog1.SelectedPath) fichier = fichier + vbCrLf My.Computer.FileSystem.WriteAllText _ ("C:\test\resultat.txt", fichier, True) Next End Sub Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles Button3.Click End End Sub End Class

Copie d’un fichier La méthode de base permettant de copier un fichier est My.Computer.FileSystem. CopyFile().

Par exemple, pour copier le fichier c:\test\data.txt dans le dossier c:\destination, vous utiliserez l’instruction suivante : My.Computer.FileSystem.CopyFile("c:\test\data.txt", "c:\destination")



118

Visual Basic 2010

Pour copier le fichier c:\test\data.txt dans le dossier c:\destination en lui donnant le nom data_sav.txt, servez-vous de l’instruction suivante : My.Computer.FileSystem.CopyFile("c:\test\data.txt", "c:\destination", "data_sav.txt")

Enfin, pour copier le fichier c:\test\data.txt dans le dossier c:\destination en lui donnant le nom data_sav.txt et en écrasant un éventuel fichier de même nom, optez pour l’instruction suivante : My.Computer.FileSystem.CopyFile("c:\test\data.txt", "c:\destination", "data_sav. „ txt", FileIO.UICancelOption.DoNothing)

Pour faire une copie d’un fichier dans le même dossier (par exemple pour dupliquer c:\test\ data.txt en le renommant c:\test\data2.txt), vous utiliserez l’une des instructions suivantes : My.Computer.FileSystem.CopyFile("C:\test\data.txt", "C:\test\data2.txt") My.Computer.FileSystem.CopyFile("C:\test\data.txt", "C:\test\data2.txt", True)

La première instruction produit une exception à l’exécution si le fichier cible existe déjà (voir Figure 3.69). Dans ce cas, la seconde exception l’écrase sans provoquer d’exception. Figure 3.69 La première instruction n’est pas en mesure d’écraser un fichier existant.

Copie de tous les fichiers correspondant à un modèle Pour copier tous les fichiers d’un dossier correspondant à un modèle, servez-vous de la fonction GetFiles() combinée à la fonction CopyFile(). Par exemple, pour copier tous les fichiers d’extension .jpg du dossier Mes Documents dans le dossier c:\data, employez les instructions suivantes : For Each fichier As String In My.Computer.FileSystem.GetFiles(My.Computer.File „ System.SpecialDirectories.MyDocuments, FileIO.SearchOption.SearchTopLevelOnly,



Chapitre 3


119

„ "*.jpg") My.Computer.FileSystem.CopyFile(fichier, "C:\data\") Next

Décomposons la première instruction. La fonction GetFiles() obtient la liste des fichiers d’extension .jpg du dossier Mes documents : My.Computer.FileSystem.GetFiles(My.Computer.FileSystem.SpecialDirectories. „ MyDocuments, FileIO.SearchOption.SearchTopLevelOnly, "*.jpg")

Cette liste est renvoyée par GetFiles() sous la forme d’une collection. Cette dernière est parcourue par l’intermédiaire d’une structure For Each In : For Each fichier As String In

La seconde instruction utilise la procédure CopyFile() pour copier chacun des éléments de la collection, c’est-à-dire chacun des fichiers dans le dossier c:\data : My.Computer.FileSystem.CopyFile(fichier, "C:\data\")

Test de l’existence d’un fichier Pour savoir si un fichier existe, il suffit d’invoquer la fonction My.Computer.FileSystem. FileExists(). La valeur renvoyée en retour est True si le fichier existe, et False dans le cas contraire. Test de l’existence d’un dossier Pour savoir si un dossier existe, il suffit d’invoquer la fonction My.Computer.FileSystem. DirectoryExists(). La valeur renvoyée en retour est True si le dossier existe, et False dans le cas contraire. Copie d’un dossier Pour copier le contenu d’un dossier, vous utiliserez la procédure My.Computer.FileSystem.CopyDirectory(). Par exemple, pour copier le contenu du dossier c:\data dans le dossier c:\data2, employez l’instruction suivante : My.Computer.FileSystem.CopyDirectory("C:\data", "data2", True)

Le troisième paramètre indique si les éventuels fichiers de même nom contenus dans le dossier de destination doivent (True) ou ne doivent pas (False) être écrasés par les fichiers provenant du dossier source.



120

Visual Basic 2010

Création d’un dossier Pour créer un nouveau dossier, vous utiliserez la procédure My.Computer.FileSystem. CreateDirectory(). Par exemple, pour créer le dossier c:\data\NouveauDossier, employez l’instruction suivante : My.Computer.FileSystem.CreateDirectory("C:\data\NouveauDossier")

Suppression d’un dossier Plusieurs syntaxes peuvent être utilisées pour supprimer un dossier :

∑

Suppression d’un dossier uniquement s’il est vide : My.Computer.FileSystem.DeleteDirectory("Nom du dossier", FileIO.DeleteDirectory „ Option.ThrowIfDirectoryNonEmpty)

∑

Envoi d’un dossier vers la Corbeille avec demande de confirmation : My.Computer.FileSystem.DeleteDirectory("Nom du dossier", FileIO.UIOption.AllDia„ logs, FileIO.RecycleOption.SendToRecycleBin, FileIO.UICancelOption.ThrowException)

∑ ∑

Suppression définitive d’un dossier : My.Computer.FileSystem.DeleteDirectory("Nom du dossier", FileIO.DeleteDirectory „ Option.DeleteAllContents)

Suppression définitive d’un dossier avec demande de confirmation : My.Computer.FileSystem.DeleteDirectory("Nom du dossier", FileIO.UIOption.AllDialogs, „ FileIO.DeleteDirectoryOption.DeletePermanently, FileIO.UICancelOption.ThrowException)

Modification du nom d’un fichier Pour modifier le nom d’un fichier, vous utiliserez la procédure My.Computer.FileSystem. RenameFile().

Par exemple, pour renommer le fichier c:\data.txt en data2.txt, employez l’instruction suivante : My.Computer.FileSystem.RenameFile("C:\data.txt", "data2.txt")

Modification du nom d’un dossier Pour modifier le nom d’un fichier, vous utiliserez la procédure My.Computer.FileSystem. RenameDirectory().

Par exemple, pour renommer le dossier c:\data en c:\data2, employez l’instruction suivante : My.Computer.FileSystem.RenameFile ("C:\data", "data2")



Chapitre 3


121

Suppression d’un fichier Pour supprimer un fichier, vous utiliserez la procédure My.Computer.FileSystem.DeleteFile(). Vous pouvez :

∑

Ne pas demander la confirmation à l’utilisateur : My.Computer.FileSystem.DeleteFile("Nom_du_fichier")

∑

Demander la confirmation à l’utilisateur : My.Computer.FileSystem.DeleteFile("Nom_du_fichier", FileIO.UIOption.AllDialogs, „ FileIO.RecycleOption.DeletePermanently, FileIO.UICancelOption.DoNothing)

∑

Envoyer le fichier supprimé vers la Corbeille : My.Computer.FileSystem.DeleteFile("Nom_du_fichier", FileIO.UIOption.AllDialogs, „ FileIO.RecycleOption.SendToRecycleBin)

Déplacement d’un dossier Pour déplacer un dossier ainsi que les fichiers et sous-dossiers qui le composent, vous utiliserez la procédure MoveDirectory() : My.Computer.FileSystem.MoveDirectory(DossierSource, DossierDestination) My.Computer.FileSystem.MoveDirectory(DossierSource, DossierDestination, True)

La première syntaxe copie le dossier source dans le dossier de destination sans écraser les éventuels fichiers/dossiers de même nom dans le fichier de destination. La seconde syntaxe écrase les éventuels fichiers/dossiers de même nom dans le dossier de destination. Chemin et nom d’un fichier Pour obtenir facilement le dossier et le nom d’un fichier à partir d’un chemin complet, tel que "c:\data\projets\Visual Basic 2010\livre.doc", employez les propriétés DirectoryName et Name d’un objet System.IO.FileInfo : Dim fichier As System.IO.FileInfo fichier = My.Computer.FileSystem.GetFileInfo("c:\data\projets\Visual Basic „ 2010\livre.doc") Dim dossier As String = fichier.DirectoryName Dim nom As String = fichier.Name Label1.Text = "Le chemin du fichier est " + dossier Label2.Text = "Le nom du fichier est " + nom

La première instruction définit l’objet System.IO.FileInfo fichier : Dim fichier As System.IO.FileInfo



122

Visual Basic 2010

La fonction GetFileInfo() est alors invoquée pour obtenir des informations sur le fichier spécifié en argument : fichier = My.Computer.FileSystem.GetFileInfo("c:\data\projets\Visual Basic 2010\ „ livre.doc")

Les variables String dossier et nom sont alors définies et initialisées avec les propriétés DirectoryName et Name de l’objet fichier : Dim dossier As String = fichier.DirectoryName Dim nom As String = fichier.Name

Il ne reste plus qu’à afficher ces deux valeurs sur la feuille – ici, par l’intermédiaire de deux contrôles Label : Label1.Text = "Le chemin du fichier est " + dossier Label2.Text = "Le nom du fichier est " + nom

Suppression de tous les fichiers d’un dossier Pour supprimer tous les fichiers d’un dossier, vous utiliserez la fonction GetFiles() combinée à la fonction DeleteFile(). À titre d’exemple, voici le code permettant de supprimer de façon permanente tous les fichiers du dossier Ma musique : For Each fichier As String In My.Computer.FileSystem.GetFiles(My.Computer.FileSystem. „ SpecialDirectories.MyMusic, FileIO.SearchOption.SearchAllSubDirectories, "*.*") My.Computer.FileSystem.DeleteFile(fichier, FileIO.UIOption.AllDialogs, FileIO.RecycleOption.DeletePermanently) Next

La première instruction parcourt tous les éléments de la collection renvoyée par la fonction GetFiles(), en étendant la recherche à tous les éventuels sous-dossiers du dossier Ma Musique (FileIO.SearchOption.SearchAllSubDirectories) et en sélectionnant tous les fichiers (*.*). La seconde instruction supprime de façon permanente chacun des fichiers sélectionnés dans la structure For Each In. Info

L’objet SpecialDirectories donne accès à plusieurs dossiers propres à indows : AllUsersApplicationData, CurrentUserApplicationData, Desktop, W MyDocuments, MyMusic, MyPictures, ProgramFiles, Programs et Temp. Pour permettre à l’utilisateur de sélectionner le dossier qu’il souhaite supprimer, il suffit d’insérer un contrôle FolderBrowserDialog dans l’application et d’utiliser sa propriété SelectedPath comme premier argument de la fonction GetFiles().



Chapitre 3


123

Déplacement d’un fichier Pour déplacer un fichier vers un autre dossier, vous pouvez combiner la fonction My.Computer.FileSystem.CopyFile() avec la fonction My.Computer.FileSystem.Delete File() ou bien utiliser une fonction dédiée : My.Computer.FileSystem.MoveFile(). Cette dernière fonction admet trois syntaxes : My.Computer.FileSystem.MoveFile(source, destination) My.Computer.FileSystem.MoveFile(source, destination,écrasement) My.Computer.FileSystem.MoveFile(source, destination, écrasement, exception)

où :

∑ ∑ ∑

source est le chemin complet du fichier à déplacer.

∑

exception indique si une éventuelle exception générée par la fonction MoveFile doit (FileIO.UICancelOption.THrowException) ou ne doit pas (FileIO.UICancelOption. DoNothing) être prise en compte.

destination est le chemin complet du fichier de destination. écrasement est une variable booléenne qui indique si un éventuel fichier ayant le même chemin que la destination doit (True) ou ne doit pas (False) être écrasé.

Par exemple, pour déplacer le fichier data.txt du dossier c:\ vers le dossier d:\data, employez l’instruction suivante : My.Computer.FileSystem.MoveFile("c:\data.txt", "d:\data\data.txt")

Info

Bien entendu, pour fonctionner, cette instruction nécessite la présence du fichier data.txt dans le dossier c:\ et l’absence du fichier data.txt dans le dossier d:\ data.

Pour déplacer le fichier data.txt du dossier c:\ vers le dossier d:\data et lui donner le nom data2.txt, vous utiliserez l’instruction suivante : My.Computer.FileSystem.MoveFile("c:\data.txt", "d:\data\data2.txt")

Info

Comme précédemment, pour fonctionner, cette instruction nécessite la présence du fichier data.txt dans le dossier c:\ et l’absence du fichier data2.txt dans le dossier d:\data.

Pour déplacer le fichier data.txt du dossier c:\ vers le dossier d:\data en écrasant l’éventuel fichier data.txt déjà présent, vous utiliserez l’instruction suivante : My.Computer.FileSystem.MoveFile("c:\data.txt", "d:\data\data2.txt", True)



124

Visual Basic 2010

Enfin, pour déplacer le fichier data.txt du dossier c:\ vers le dossier d:\data en ignorant tous les éventuels événements générés, employez l’instruction suivante : My.Computer.FileSystem.MoveFile("c:\data.txt", "d:\data", FileIO.UIOption.AllDialog, FileIO.UICancelOption.DoNothing)

Déplacement de tous les fichiers correspondant à un modèle Pour déplacer tous les fichiers d’un dossier correspondant à un modèle, vous utiliserez la fonction GetFiles() combinée à la fonction MoveFile(). Par exemple, pour déplacer tous les fichiers d’extension .txt du dossier Mes Documents vers le dossier c:\data, employez les instructions suivantes : For Each fichier As String In My.Computer.FileSystem.GetFiles(My.Computer.FileSystem. „ SpecialDirectories.MyDocuments, FileIO.SearchOption.SearchTopLevelOnly, "*.txt") My.Computer.FileSystem.MoveFile(fichier, "C:\data\") Next

Recherche de sous-dossiers Pour rechercher les sous-dossiers contenus dans un dossier, vous utiliserez la fonction My.Computer.FileSystem.GetDirectories(). À titre d’exemple, pour afficher les sous-dossiers du dossier c:\, employez les instructions suivantes : For Each dossier As String In My.Computer.FileSystem.GetDirectories("c:\") TextBox1.Text = TextBox1.Text & dossier & vbCrLf Next

Dans la première ligne, la fonction GetDirectories() renvoie une collection contenant le nom des sous-dossiers : My.Computer.FileSystem.GetDirectories("c:\")

Cette collection est décrite à l’aide d’une instruction For Each : For Each dossier As String In

La seconde ligne ajoute le nom du dossier pointé au texte affiché dans la zone de texte multiligne TextBox1. Remarquez l’utilisation du code &vbCrLf pour ajouter un passage à la ligne : TextBox1.Text = TextBox1.Text & dossier & vbCrLf

Deux paramètres complémentaires peuvent être utilisés avec la fonction GetDirectories() : My.Computer.FileSystem.GetDIrectories(NomDossier,InclureSousDossiers,Modèle)

où :



Chapitre 3

∑ ∑ ∑


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.



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() :



Chapitre 3


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



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.



Chapitre 3


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



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")



Chapitre 3


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.



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.



Chapitre 3

Info


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)



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é.



Chapitre 3


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é



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.



Chapitre 3

∑ ∑ ∑ ∑ ∑ ∑ ∑


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)



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.



Chapitre 3


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 :



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)



Chapitre 3


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.



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



Chapitre 3

TextBox5.Text TextBox6.Text TextBox7.Text TextBox8.Text End Sub


= = = =

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



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.



Chapitre 3


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)



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).



Chapitre 3


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



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.



Chapitre 3


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).



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.



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.





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 ;



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



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



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.



Chapitre 4


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



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.



Chapitre 4


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.



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



Chapitre 4


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.



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 :



Chapitre 4


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.



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.



Chapitre 4


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



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.



Chapitre 4


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.



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.



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



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



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,



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.



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.



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)



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.



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))



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



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



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.



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.



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



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



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



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



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 :



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).



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



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)



Chapitre 6


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)



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)



Chapitre 6


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



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



Chapitre 6


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.



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)



Chapitre 6


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



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



Chapitre 6


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é



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



Chapitre 6


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





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.



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.



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).



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.



Chapitre 7

Info


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.



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"



Chapitre 7


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



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) :



Chapitre 7


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



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



Chapitre 7


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).



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.



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.



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.



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).



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



Chapitre 8


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



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



Chapitre 8


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)



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)



Chapitre 8


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)



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.



Chapitre 8


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



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()



Chapitre 8


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.



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)



Chapitre 8


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



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.



Chapitre 8


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.



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



Chapitre 8


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.



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.



Chapitre 8


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



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 :



Chapitre 8


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.



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



Chapitre 8


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 :



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



Chapitre 8


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



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")



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.



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



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



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



Chapitre 9


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.



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.



Chapitre 9


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



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

<<

Button3

Text

<

Button4

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.



Chapitre 9


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)



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.



Chapitre 9


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



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)



Chapitre 9


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



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



Chapitre 9


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)



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)



Chapitre 9


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





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.



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.



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



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



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



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



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().



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()



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



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



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



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.



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



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



Chapitre 11


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.



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



Chapitre 11


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.



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



Chapitre 11


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.



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).



Chapitre 11


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.



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.



Chapitre 11


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")



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)



Chapitre 11


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



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



Chapitre 11


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")



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



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



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.



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")



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 :



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)



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.



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



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 :



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)



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).



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).



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.



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.



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.



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.



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.



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.



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


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



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



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.



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 :



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.



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



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



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.



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.



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.





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.



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 :



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



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



Chapitre 13


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



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



Chapitre 13


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



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.



Chapitre 13


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.



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



Chapitre 13


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



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.



Chapitre 13


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.



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



Chapitre 13


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()



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.



Chapitre 13


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 ...")



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 :



Chapitre 13


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) :



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)



Chapitre 13

Info


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.





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.



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.



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,



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.



Chapitre 14


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.



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 ;



Chapitre 14

∑


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.



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).



Chapitre 14


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.



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



Chapitre 14


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 :



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.



Chapitre 14


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)



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)



Chapitre 14


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



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.



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.



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


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


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


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


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.



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



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().



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



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.



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.



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.<br /> <br /> ∑<br /> <br /> 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).<br /> <br /> customer 27921 at Fri Mar 11 19:22:06 +0100 2011<br /> <br /> Propriété de Albiri Sigue <tag.tog@gmail.com><br /> <br /> <br /> <br /> 364<br /> <br /> Visual Basic 2010<br /> <br /> Voici le code source et l’interprétation HTML des huit fichiers à intégrer dans l’aide. Présentation.htm <html> <head> <title>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.



Chapitre 16


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



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.



Chapitre 16


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".



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.



Chapitre 16


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.



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



Chapitre 16


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).



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.



Chapitre 16


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.



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.



Chapitre 16


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.



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).



Chapitre 16


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.



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.



Chapitre 16


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.



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)



Chapitre 16


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 "/".





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…



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



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).



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.



Chapitre 17


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.



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.



Chapitre 17


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).



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.



Chapitre 17


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.



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



Chapitre 17


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



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)



Chapitre 17


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



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,



Chapitre 17


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



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()



Chapitre 17

Dim Dim Dim Dim


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)



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)



Chapitre 17


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





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 ;



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.



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



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.



Chapitre 18


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.



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



Chapitre 18


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.



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



Chapitre 18


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.



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



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.



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.



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 :



416

Visual Basic 2010

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)



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



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.



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.



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.



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.



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



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.



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).



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) :



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) :



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).



428

Visual Basic 2010

Figure 19.11 Tracé d’une courbe de Bézier cubique.

Info


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) :



Chapitre 19

Programmation WPF

429

Figure 19.12 Tracé d’une série de courbes de Bézier quadratique.


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) :



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 .



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) :



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.



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) :



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.



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).



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) :



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 :



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 :



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 :



440

Visual Basic 2010

Direction="-0.5,-0.25,-1"/>

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.



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) :



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.



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) :



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



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.



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.



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) :



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 :



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é



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 :



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.



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 :

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

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 :



454

Visual Basic 2010




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é.





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.





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.



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



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 :



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)



Chapitre 20


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.



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 :



Chapitre 20


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)



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.



Chapitre 20


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



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



Chapitre 20


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





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…



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



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.



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



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)



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.



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.



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



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 ;



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.



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





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.



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.



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).



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



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



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.



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é.



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

<script type="text/javascript"> //



Chapitre 22

Applications web

491

’V2953’)" style="color:Black" title="Accéder au mois précédent">< 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


492

Visual Basic 2010

doPostBack(‘Calendar1’,’2993’)" style="color:Black" title="12 mars">12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31 1 2


Chapitre 22

Applications web

493

doPostBack(‘Calendar1’,’3015’)" style="color:Black" title="3 avril">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.



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


ErrorMessage

Mot de passe incorrect


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.



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

<script type="text/javascript">


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(); } } // -->

<script src="/Validation/WebResource.axd?d=47DVMwHRgwJ4hLHX_KNOLA2&t= „ 632677332350339104" type="text/javascript">

<script src="/Validation/WebResource.axd?d=Wz9Zm5F54DyuwrZrXF6lVSs4U-rXbcq2FQWg8 rOU6bo1&t=632677332350339104" type="text/javascript"> <script type="text/javascript">
Entrez le mot de passe Mot de passe incorrect
<script type="text/javascript"> <script type="text/javascript">



Chapitre 22

Applications web

497


Remarquez le marqueur <script>, 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 : <script type="text/javascript">


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é


ControlToValidate

Nom du contrôle sur lequel porte le test


ValidationExpression

Expression à utiliser pour déterminer la validité

RequiredFieldValidator

ErrorMessage

Message affiché si le contrôle testé est laissé vide

RequiredFieldValidator

ControlToValidate


CompareValidator

ErrorMessage


CompareValidator

ControlToCompare

Nom du contrôle à comparer

CompareValidator

ControlToValidate


CompareValidator

ValueToCompare

Valeur à comparer au contrôle testé

RangeValidator

ErrorMessage


RangeValidator

ControlToValidate


RangeValidator

MaximumValue

Valeur maximale de la plage autorisée

RangeValidator

MinimumValue

Valeur minimale de la plage autorisée

CustomValidator

ErrorMessage


CustomValidator

ControlToValidate


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



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


ControlToValidate

Nom


ErrorMessage

Le champ nom est obligatoire


Display

None


ControlToValidate

Prénom


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.



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


<script src="/Validation2/WebResource.axd?d=XNrKvmDoFLmpiG2zLlYU1Q2& ;t=632677332350339104" type="text/javascript">

<script src="/Validation2/WebResource.axd?d=GL5x1ihVqlZQ2gwnk_76uttlZOupblijbcWV 4bo1x1I1&t=632677332350339104" type="text/javascript"> <script type="text/javascript">
Entrez votre nom

Entrez votre prénom



502

Visual Basic 2010

<script type="text/javascript"> <script type="text/javascript">



Chapitre 22

Applications web

503

„ "/wEWBALcj7ffBAKbueCABQLorN29BQKi4t3RCzVfDHdp0JB1/6P+QncAeBbQPm8p" />

Remarquez le marqueur <script>, associé au contrôle ValidationSummary et responsable de l’affichage de la boîte de message en cas de non-saisie des champs obligatoires : <script type="text/javascript">


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



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 à



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)



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



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)



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



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.



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.



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.



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



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")



Chapitre 23


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")



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")



Chapitre 23


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")



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")



Chapitre 23


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é")



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("<script>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)



Chapitre 23


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("<script>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("<script>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("<script>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("<script>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



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("<script>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("<script>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("<script>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("<script>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("<script>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("<script>window.open(‘" + s + "‘)") End Sub



Chapitre 23


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("<script>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("<script>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.



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



Chapitre 23


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).



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



Chapitre 23


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("<script>window. „ open(‘http://lem.korp.free.fr/annuaire/data/plus.htm’)") If e.PostBackValue = "1" Then Response.Write("<script>window. „ open(‘mailto:[email protected]’)") If e.PostBackValue = "2" Then Response.Write("<script>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("<script>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("<script>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("<script>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.



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.



Chapitre 23


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.



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, " 0 Then p2 = InStr(p, ligne, ">") Print #2, Mid(ligne, p + 9, p2 - p - 10) p3 = InStr(p2, ligne, "") If p <> 0 Then ligne = LineInput(1) Print #2, Mid(ligne, 1, Len(ligne) - 3) End If End While Catch Finally FileClose(1) FileClose(2) End Try End Sub



Chapitre 23


531

Cette procédure est élémentaire. Elle se contente de décrire toutes les lignes du fichier contenant l’assemblage des fichiers HTML (data.txt) et d’extraire les informations non HTML à inclure dans la base de données. À savoir le groupe, le sous-groupe, l’adresse URL, le titre du site et le commentaire. Voici, à titre d’exemple, un extrait du fichier data.txt :
Vie pratique / Petites annonces
@nnonces gratuites annonces. gulliver.com
Site de petites annonces gratuites pour les particuliers.
100 % motos d’occasion motocasion. tm.fr
Tous les mois en kiosque, Motoccasion est le numéro un dans l’offre de motos d’occasion en France. Sur le site, retrouvez annonces et photos.
1 2 3 business www.123b.com
Site de petites annonces classées : immobilier, véhicules, antiquités, œuvres d’art, décoration, avions et bateaux.
1 2 3 paf www.123paf.com
Petites annonces francophones classées : affaires, animaux et plantes, arts et déco, électronique, emplois, immobilier, informatique, tourisme, etc.
1 2 3 immo fr.123immo.com
Ce portail de l’immobilier vous permet de louer un appartement, une maison ou un studio, de vendre ou d’acheter un logement en France.
A comme annonces www.eucalyptech. com
Service gratuit de petites annonces francophones : animaux, automobiles, bonnes affaires, emplois, immobilier, rencontres, etc.
A2C, cap d’Agde www.a2c-bateaux. com
Cette société est spécialisée dans la vente de bateaux d’occasion en Méditerranée, de Marseille à Barcelone.
…

Et voici le fichier champs.txt généré par le programme : Vie pratique Petites annonces http://annonces.gulliver.com @nnonces gratuites Site de petites annonces gratuites pour les particuliers. http://motocasion.tm.fr 100 % motos d’occasion Tous les mois en kiosque, Motoccasion est le numéro un dans l’offre de motos d’occasion en France. Sur le site, retrouvez annonces et photos.



532

Visual Basic 2010

http://www.123b.com 1 2 3 business Site de petites annonces classées : immobilier, véhicules, antiquités, œuvres d’art, décoration, avions et bateaux. http://www.123paf.com 1 2 3 paf Petites annonces francophones classées : affaires, animaux et plantes, arts et déco, électronique, emplois, immobilier, informatique, tourisme, etc. http://fr.123immo.com 1 2 3 immo Ce portail de l’immobilier vous permet de louer un appartement, une maison ou un studio, de vendre ou d’acheter un logement en France. http://www.eucalyptech.com A comme annonces Service gratuit de petites annonces francophones : animaux, automobiles, bonnes affaires, emplois, immobilier, rencontres, etc. http://www.a2c-bateaux.com A2C, cap d’Agde Cette société est spécialisée dans la vente de bateaux d’occasion en Méditerranée, de Marseille à Barcelone. …

Après quelques remaniements, les données sont placées dans une feuille Excel et stockées sur le disque dans un fichier XLS (voir Figure 23.12). Figure 23.12 Un extrait du fichier de données au format Excel.

Ces données sont ensuite intégrées dans une base de données Access (voir Figure 23.13).



Chapitre 23


533

Figure 23.13 Les données sont intégrées dans la table data.

Définition du service web Pour accéder à ces données, nous allons définir un service web. Lancez la commande Nouveau/Site web dans le menu Fichier. Dans la liste déroulante Framework, choisissez .NET Framework 3.5. Dans le volet gauche, choisissez Visual Basic sous Modèles installés. Sélectionnez le modèle Service web ASP.NET, donnez le nom Service3 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 : _ _ _ Public Class Service Inherits System.Web.Services.WebService



534

Visual Basic 2010

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


Supprimez la fonction HelloWorld(), générée automatiquement par Visual Studio, et remplacez-la par la fonction AfficheSel() suivante : Public Function AfficheSel(ByVal demande As String) As DataSet Dim st As String = "" Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\annuaire.mdb" ConnexionOLE.ConnectionString = Connexion st = "Select * from data where [SousCar]=‘" & demande & "‘" da = New OleDbDataAdapter(st, ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") Return ds End Function

Cette fonction sera exploitée sur le Web (). Elle demande un argument de type String (la valeur sélectionnée dans une liste déroulante) et renvoie un DataSet : Public Function AfficheSel(ByVal demande As String) As DataSet

Les deux lignes suivantes établissent une connexion avec la base de données. Ici, il s’agit de la base Access c:\data\annuaire.mdb : Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\test\annuaire.mdb" ConnexionOLE.ConnectionString = Connexion

Pour afficher les enregistrements de la table data dont le champ SousCat est égal au paramètre passé à la WebMethod, nous allons utiliser la requête SQL suivante : st = "Select * from data where [SousCat]=‘" & demande & "‘"

L’interfaçage avec la table data se fera par l’intermédiaire d’un objet OleDbDataAdapter : da = New OleDbDataAdapter(st, ConnexionOLE)

Les deux instructions suivantes initialisent le DataSet ds avec l’OleDbDataAdapter da : ds = New DataSet() da.Fill(ds, "mytable")



Chapitre 23


535

Enfin, l’objet DataSet ds est retourné par la fonction : Return ds

Voici le code complet de la classe Service3 : 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


Public Function AfficheSel(ByVal demande As String) As DataSet Dim st As String = "" Connexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= „ c:\data\annuaire.mdb" ConnexionOLE.ConnectionString = Connexion st = "Select * from data where [SousCat]=‘" & demande & "‘" da = New OleDbDataAdapter(st, ConnexionOLE) ds = New DataSet() da.Fill(ds, "mytable") Return ds End Function End Class End Class

Appuyez sur la touche F5. La fonction AfficheSel() peut être testée (voir Figure 23.14). Cliquez sur le lien AfficheSel, entrez une valeur pour le paramètre (ici par exemple, nous allons entrer la valeur «Actualité, festivals») puis cliquez sur Appeler. Le résultat de la fonction AfficheTous() apparaît sous une forme XML (voir Figure 23.15).



536

Visual Basic 2010

Figure 23.14 Cette page permet de tester la fonction AfficheSel().

Figure 23.15 Résultat de la fonction AfficheSel().

Dans la barre de notification, une icône intitulée Serveur de développement ASP.NET indique que le service web est en cours d’exécution. Double-cliquez sur cette icône pour afficher une boîte de dialogue analogue à la Figure 23.16.



Chapitre 23


537

Figure 23.16 Dans cet exemple, le service web est accessible sur le port 51864.

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. Dupliquez le site web WebSites\Annuaire en WebSites\AnnuaireBD. Ouvrez site web AnnuaireBD. Cliquez du bouton droit sur l’entrée C:\…\AnnuaireBD 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 23.17). Figure 23.17 Accès au service web sur le port 51864.



538

Info

Visual Basic 2010

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.

Cliquez sur le bouton Aller à. Après quelques instants, la boîte de dialogue Ajouter une référence web se présente comme à la Figure 23.18. Figure 23.18 Le service Service3 est sur le point d’être intégré au projet web.

Cliquez sur Ajouter une référence. Le service web Service3 est maintenant référencé dans le projet. Vous pouvez donc utiliser sa méthode AfficheSel() (voir Figure 23.19). Figure 23.19 Le service web Service3 est référencé dans le projet.



Chapitre 23


539

Ajoutez un contrôle GridView dans la partie inférieure de la page (ce contrôle se trouve sous l’onglet Données de la Boîte à outils). La fenêtre de conception se présente comme à la Figure 23.20. Figure 23.20 Le contrôle GridView a été placé sur la page.

Nous allons maintenant modifier le contenu des procédures ddl1_SelectedIndexChanged() à ddl12_SelectedIndexChanged() pour interroger le service web. Voici, à titre d’exemple le contenu de la procédure ddl1_SelectedIndexChanged() : Protected Sub ddl1_SelectedIndexChanged(ByVal sender As Object, ByVal e As „ System.EventArgs) Handles ddl1.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub

La première instruction place la valeur sélectionnée par l’utilisateur dans l’objet String s : Dim s As String = ddl1.Text

L’objet localhost.Service objds est alors défini pour interfacer le service web : Dim objds As New localhost.Service

La valeur renvoyée par le service web est un Dataset. Pour le mémoriser, nous définissons l’objet Dataset ds : Dim ds As DataSet



540

Visual Basic 2010

La fonction AfficheSel() du service web est alors invoquée. L’objet renvoyé est stocké dans le Dataset ds : ds = objds.AfficheSel(s)

Il ne reste plus qu’à lier le contrôle GridView1 avec le Dataset ds : GridView1.DataSource = ds

Et à demander sa mise à jour : GridView1.DataBind()

Les procédures ddl2_SelectedIndexChanged() contiennent des instructions similaires.

à

ddl12_SelectedIndexChanged()

La Figure 23.21 représente le contenu du DataGrid renvoyé par le service web lorsque l’utilisateur sélectionne la valeur "Actualité, festivals" dans la liste déroulante Culture et arts. Figure 23.21 Un exemple d’affichage renvoyé par la méthode AfficheSel().

Voici le listing complet du site web AnnuaireBD. Les fichiers correspondants se trouvent dans le dossier WebSites\AnnuaireBD des sources de l’ouvrage. Imports system.data Partial Class _Default



Chapitre 23


541

Inherits System.Web.UI.Page 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") 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")



542

Visual Basic 2010

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") 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")



Chapitre 23


543

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") 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")



544

Visual Basic 2010

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") ddl8.Items.Add("Agences de presse") ddl8.Items.Add("Conseil, guides de marché") ddl8.Items.Add("DVD") ddl8.Items.Add("Journaux&mag en ligne : ddl8.Items.Add("Journaux&mag en ligne : ddl8.Items.Add("Journaux&mag en ligne : ddl8.Items.Add("Journaux&mag en ligne : ddl8.Items.Add("Journaux&mag en ligne : ddl8.Items.Add("Journaux&mag en ligne : ddl8.Items.Add("Journaux&mag en ligne : ddl8.Items.Add("Publicité") ddl8.Items.Add("Radioamateurs")

actualité") culturel") divers") enfants") informatique") musique") sport")



Chapitre 23


545

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") 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")



546

Visual Basic 2010

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é") 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")



Chapitre 23


547

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 Protected Sub ddl1_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl1.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl2_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl2.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl3_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl3.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub



548

Visual Basic 2010

Protected Sub ddl4_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl4.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl5_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl5.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl6_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl6.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl7_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl7.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl8_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl8.SelectedIndexChanged Dim s As String = ddl1.Text



Chapitre 23


549

Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl9_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl9.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl10_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl10.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl11_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl11.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s) GridView1.DataSource = ds GridView1.DataBind() End Sub Protected Sub ddl12_SelectedIndexChanged(ByVal sender As Object, ByVal e „ As System.EventArgs) Handles ddl12.SelectedIndexChanged Dim s As String = ddl1.Text Dim objds As New localhost.Service Dim ds As DataSet ds = objds.AfficheSel(s)



550

Visual Basic 2010

GridView1.DataSource = ds GridView1.DataBind() End Sub 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("<script>window. „ open(‘http://lem.korp.free.fr/annuaire/data/plus.htm’)") If e.PostBackValue = "1" Then Response.Write("<script>window. „ open(‘mailto:[email protected]’)") If e.PostBackValue = "2" Then Response.Write("<script>window. „ open(‘http://lem.korp.free.fr/annuaire/data/nouvsite.htm’)") End Sub End Class



24 Favoris web Dans ce chapitre, vous allez apprendre à mémoriser vos sites web préférés. Les sites sont accessibles à travers une à huit listes déroulantes. Un simple clic permet d’afficher l’un des sites mémorisés. Un outil de personnalisation permet de modifier, de compléter ou de supprimer les éléments mémorisés. Reportez-vous si nécessaire au Chapitre 7 pour connaître les modalités d’utilisation du contrôle ToolStrip et au Chapitre 21 pour avoir des informations complémentaires sur l’utilisation du contrôle WebBrowser.

Mise en place du projet 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 définissez le nouveau projet SuperNavigateur fondé sur le modèle Application Windows Forms.



552

Visual Basic 2010

Ajoutez les contrôles suivants au projet : un MenuStrip, un ToolStrip, un Panel contenant huit Label et huit ComboBox, un WebBrowser. Complétez le contrôle ToolStrip en lui ajoutant un Label et un TextBox (voir Figure 24.1). Figure 24.1 Quelques clics souris suffisent pour compléter le contrôle ToolStrip.

Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant : Contrôle

Propriété

Valeur

Label dans ToolStrip

Text

Adresse

ToolStrip

Dock

Top

TextBox dans ToolStrip

Text

Panel1

Dock

Top

Label2 à Label8 dans Panel1

Text

Non utilisé

Label2 à Label8 dans Panel1

Enabled

False

ComboBox1 à ComboBox8 dans Panel1

Text

ComboBox2 à ComboBox8 dans Panel1

Enabled

False

WebBrowser1

Dock

Fill

Définissez les commandes de menu suivantes :

∑ ∑

Outils > Cacher la barre de navigation ; Outils > Cacher les sites ;



Chapitre 24

∑ ∑

Favoris web

553

Outils > Personnaliser ; Aide > Aide SuperNavigateur.

Déplacez et redimensionnez les contrôles pour obtenir la disposition de la Figure 24.2. Figure 24.2 La fenêtre principale de l’application Super Navigateur en mode Édition.

Avant de poursuivre, ouvrez le Bloc-notes de Windows et saisissez le code suivant : Encyclopédies Encarta http://encarta.msn.fr/ Encyclopédies Hachette http://www.ehmelhm.hachette-multimedia.fr/infos/accueil Encyclopédies Quid http://www.quid.fr/ Enfants Les Tibidous http://www.tibidous.com/ Enfants Toupty.com http://www.toupty.com Enfants Chez Spiderman



554

Visual Basic 2010

http://spiderman.2.free.fr Journaux Le Monde http://www.lemonde.fr/ Journaux Le Nouvel Obs http://quotidien.nouvelobs.com/ Journaux L’express http://www.lexpress.fr/Express/

Sauvegardez ce fichier sous le nom data.txt et placez-le dans le dossier bin\debug de l’application SuperNavigateur. Ce fichier décrit dix sites d’intérêt général. Chaque site nécessite quatre informations :

∑ ∑ ∑ ∑

un nom de catégorie ; le nom du site ; l’adresse URL du site ; un éventuel commentaire qui donne des informations sur le site.

Définition des procédures de traitement Lancez la commande Code dans le menu Affichage ou appuyez sur F7. Ajoutez les déclarations suivantes dans la partie supérieure du listing : Dim Dim Dim Dim Dim Dim Dim Dim Dim Dim Dim Dim Dim Dim Dim Dim

i, j As Integer data(4, 100) As String ‘Tableau de données NbData As Integer ‘Nombre de références dans les onglets NDparListe(8) As Integer s As String NbListes As Integer NomListes(8) As String l1 As New Collections.ArrayList(20) l2 As New Collections.ArrayList(20) l3 As New Collections.ArrayList(20) l4 As New Collections.ArrayList(20) l5 As New Collections.ArrayList(20) l6 As New Collections.ArrayList(20) l7 As New Collections.ArrayList(20) l8 As New Collections.ArrayList(20) bis As Boolean



Chapitre 24

Favoris web

555

Le tableau data sera utilisé pour mémoriser les données du fichier data.txt. Ce tableau peut enregistrer jusqu’à cent sites : Dim data(4, 100) As String ‘Tableau de données

Les collections l1 à l8 permettront de remplir les listes déroulantes ComboBox1 à ComboBox8. Chaque collection a par défaut une capacité de vingt éléments : Dim l1 As New Collections.ArrayList(20) … Dim l8 As New Collections.ArrayList(20)

Sélectionnez Form1 dans le fenêtre Propriétés, cliquez sur l’icône Événements, doublecliquez 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 MAJListes() ‘Initialisation et affichage des listes déroulantes End Sub

Cette procédure se contente d’invoquer MAJListes()pour initialiser les listes déroulantes : MAJListes()

Vous allez maintenant définir la procédure Form1_Activated(). Cette procédure sera exécutée chaque fois que la deuxième fenêtre de l’application redonnera le contrôle à la première. Sélectionnez Form1 dans le fenêtre Propriétés, cliquez sur l’icône Événements, double-cliquez sur l’événement Activated et complétez la procédure Form1_Activated() comme suit : Private Sub Form1_Activated(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Activated MAJListes() End Sub

Tout comme Form1_Load(), Form1_Activated() fait appel à la procédure MAJListes() pour remettre à jour les listes déroulantes en sortie de personnalisation. Il ne reste plus qu’à définir MAJListes() pour rendre ces deux procédures opérationnelles : Public Sub MAJListes() ‘Lecture du fichier de données i = 1 Try FileOpen(1, "data.txt", OpenMode.Input) While Not EOF(1) data(1, i) = LineInput(1)



556

Visual Basic 2010

data(2, i) = LineInput(1) data(3, i) = LineInput(1) data(4, i) = LineInput(1) i = i + 1 End While Catch Finally NbData = i - 1 FileClose(1) End Try ‘Comptage du nombre de listes déroulantes s = "" NbListes = 0 j = -1 For i = 1 To NbData j = j + 1 If data(1, i) <> s Then If NbListes <> 0 Then NDparListe(NbListes) = j j = 0 End If s = data(1, i) NbListes = NbListes + 1 NomListes(NbListes) = s End If Next NDparListe(NbListes) = j + 1 ‘Initialisation des listes déroulantes l1.Clear() For i = 1 To NDparListe(1) l1.Add(data(2, i)) Next i Label2.Enabled = True Label2.Text = NomListes(1) ComboBox1.DataSource = l1 ComboBox1.Enabled = True ComboBox1.Text = "Choisissez une entrée" If NbListes >= 2 Then l2.Clear() For i = 1 To NDparListe(2) l2.Add(data(2, i + NDparListe(1))) Next i Label3.Enabled = True Label3.Text = NomListes(2)



Chapitre 24

Favoris web

557

ComboBox2.DataSource = l2 ComboBox2.Enabled = True ComboBox2.Text = "Choisissez une entrée" End If If NbListes >= 3 Then l3.Clear() For i = 1 To NDparListe(3) l3.Add(data(2, i + NDparListe(1) + NDparListe(2))) Next i Label4.Enabled = True Label4.Text = NomListes(3) ComboBox3.DataSource = l3 ComboBox3.Enabled = True ComboBox3.Text = "Choisissez une entrée" End If If NbListes >= 4 Then l4.Clear() For i = 1 To NDparListe(4) l4.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3))) Next i Label5.Enabled = True Label5.Text = NomListes(4) ComboBox4.DataSource = l4 ComboBox4.Enabled = True ComboBox4.Text = "Choisissez une entrée" End If If NbListes >= 5 Then l5.Clear() For i = 5 To NDparListe(5) l5.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3) „ + NDparListe(4))) Next i Label6.Enabled = True Label6.Text = NomListes(5) ComboBox5.DataSource = l5 ComboBox5.Enabled = True ComboBox5.Text = "Choisissez une entrée" End If If NbListes >= 6 Then l6.Clear() For i = 1 To NDparListe(6) l6.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3) „ + NDparListe(4) + DparListe(5)))



558

Visual Basic 2010

Next i Label7.Enabled = True Label7.Text = NomListes(6) ComboBox6.DataSource = l6 ComboBox6.Enabled = True ComboBox6.Text = "Choisissez une entrée" End If If NbListes >= 7 Then l7.Clear() For i = 1 To NDparListe(7) l7.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3) „ + NDparListe(4) + DparListe(5) + NDparListe(6))) Next i Label8.Enabled = True Label8.Text = NomListes(7) ComboBox7.DataSource = l7 ComboBox7.Enabled = True ComboBox7.Text = "Choisissez une entrée" End If If NbListes >= 8 Then l8.Clear() For i = 1 To NDparListe(8) l8.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3) „ + NDparListe(4) + DparListe(5) + NDparListe(6) + NDparListe(7))) Next i Label9.Enabled = True Label9.Text = NomListes(8) ComboBox8.DataSource = l8 ComboBox8.Enabled = True ComboBox8.Text = "Choisissez une entrée" End If End Sub

Bien qu’assez longue, cette procédure est très simple. Le premier bloc d’instructions lit le fichier texte data.txt et stocke son contenu dans le tableau data() : i = 1 Try FileOpen(1, "data.txt", OpenMode.Input) While Not EOF(1) data(1, i) = LineInput(1) data(2, i) = LineInput(1) data(3, i) = LineInput(1) data(4, i) = LineInput(1) i = i + 1



Chapitre 24

Favoris web

559

End While Catch Finally NbData = i - 1 FileClose(1) End Try

Aucun chemin n’étant précisé dans l’instruction FileOpen(), le fichier data.txt doit se trouver dans le même dossier que l’exécutable, c’est-à-dire dans le dossier bin : FileOpen(1, "data.txt", OpenMode.Input)

Remarquez la structure Try Catch Finally End Try. Si le fichier data.txt n’existe pas, aucune erreur ne sera générée à l’exécution du programme. En revanche, les listes déroulantes ne pourront pas être initialisées. Le deuxième bloc d’instructions se poursuit par le comptage du nombre de listes déroulantes à afficher : s = "" NbListes = 0 j = -1 For i = 1 To NbData j = j + 1 If data(1, i) <> s Then If NbListes <> 0 Then NDparListe(NbListes) = j j = 0 End If s = data(1, i) NbListes = NbListes + 1 NomListes(NbListes) = s End If Next NDparListe(NbListes) = j + 1

La technique utilisée est très simple. Elle consiste à comparer le nom de catégorie de chaque donnée. Si le nom actuel est différent du précédent, une nouvelle liste déroulante doit être implémentée : If data(1, i) <> s Then If NbListes <> 0 Then

Le nombre de listes à implémenter est mémorisé dans la variable NbListes, le nom de chaque liste déroulante dans le tableau NomListes(), et le nombre d’entrées dans chaque liste dans le tableau NDparListe() :



560

Visual Basic 2010

NDparListe(NbListes) = j … NbListes = NbListes + 1 NomListes(NbListes) = s

Chacun des blocs d’instructions suivants initialise une des huit listes déroulantes. Par exemple, pour la troisième liste déroulante : If NbListes >= 3 Then l3.Clear() For i = 1 To NDparListe(3) l3.Add(data(2, i + NDparListe(1) + NDparListe(2))) Next i Label4.Enabled = True Label4.Text = NomListes(3) ComboBox3.DataSource = l3 ComboBox3.Enabled = True ComboBox3.Text = "Choisissez une entrée" End If

Le contenu de la liste déroulante est réinitialisé : l3.Clear()

Puis une boucle For Next ajoute chacune des données à la collection l3 : For i = 1 To NDparListe(3) l3.Add(data(2, i + NDparListe(1) + NDparListe(2))) Next i

Le label correspondant à la liste est alors activé et initialisé : Label4.Enabled = True Label4.Text = NomListes(3)

De même pour la liste déroulante : ComboBox3.DataSource = l3 ComboBox3.Enabled = True ComboBox3.Text = "Choisissez une entrée"

Lorsque nous sommes arrivés à ce point, les listes déroulantes s’activent et se remplissent automatiquement au lancement de l’application. Nous allons maintenant définir les procédures de traitement des commandes de menu. Déroulez le menu Outils et double-cliquez sur la commande Cacher la barre de navigation. Complétez la procédure CacherLaBarreDeNavigationToolStripMenuItem_Click() comme suit :



Chapitre 24

Favoris web

561

Private Sub CacherLaBarreDeNavigationToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles CacherLaBarreDeNavigation„ ToolStripMenuItem.Click If CacherLaBarreDeNavigationToolStripMenuItem.Text = "Cacher la barre de „ navigation" Then ToolStrip1.Visible = False CacherLaBarreDeNavigationToolStripMenuItem.Text = "Afficher la barre de „ navigation" Else ToolStrip1.Visible = True CacherLaBarreDeNavigationToolStripMenuItem.Text = "Cacher la barre de „ navigation" End If End Sub

Cette procédure repose sur une instruction If Then Else. Si le texte affiché dans le menu est "Cacher la barre de navigation" : If CacherLaBarreDeNavigationToolStripMenuItem.Text = "Cacher la barre de navigation" Then

la barre de navigation doit être cachée : ToolStrip1.Visible = False

et la commande de menu, changée en "Afficher la barre de navigation" : CacherLaBarreDeNavigationToolStripMenuItem.Text = "Afficher la barre de navigation"

Dans le cas contraire, la barre de navigation doit être affichée : ToolStrip1.Visible = Trueet la commande de menu, changée en "Cacher la barre de navigation" : CacherLaBarreDeNavigationToolStripMenuItem.Text = "Cacher la barre de navigation"

Déroulez le menu Outils et double-cliquez sur la commande Cacher les sites. Complétez la procédure CacherLesSItesToolStripMenuItem_Click() comme suit : Private Sub CacherLesSitesToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles CacherLesSitesToolStripMenuItem.Click If CacherLesSitesToolStripMenuItem.Text = "Cacher les sites" Then Panel1.Visible = False CacherLesSitesToolStripMenuItem.Text = "Montrer les sites" Else Panel1.Visible = True



562

Visual Basic 2010

CacherLesSitesToolStripMenuItem.Text = "Cacher les sites" End If End Sub

Si le texte affiché dans le menu est "Cacher les sites" : If CacherLesSitesToolStripMenuItem.Text = "Cacher les sites" Then

le contrôle Panel1 doit être caché : Panel1.Visible = False

et la commande de menu, modifiée en "Monter les sites" : CacherLesSitesToolStripMenuItem.Text = "Montrer les sites"

Dans le cas contraire, le contrôle Panel1 doit être rendu visible : Else Panel1.Visible = True

et la commande de menu, changée en "Cacher les sites" : CacherLesSitesToolStripMenuItem.Text = "Cacher les sites"

Déroulez le menu Outils et double-cliquez sur la commande Personnaliser. Complétez la procédure PersonnaliserToolStripMenuItem_Click() comme suit : Private Sub PersonnaliserToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles PersonnaliserToolStripMenuItem.Click ‘ Ajout, suppression et modification de sites Form2.Show() End Sub

La seule instruction de cette procédure provoque l’affichage de la feuille Form2. Pour terminer le code attaché à cette première feuille, vous allez maintenant donner vie au contrôle WebBrowser1. Sélectionnez l’objet ToolStripTextBox1 dans la fenêtre des propriétés, cliquez sur l’icône Événements et double-cliquez sur l’événement KeyDown. Complétez la procédure ToolStripTextBox1_KeyDown() comme suit : Private Sub ToolStripTextBox1_KeyDown(ByVal sender As System.Object, ByVal e „ As System.Windows.Forms.KeyEventArgs) Handles ToolStripTextBox1.KeyDown If (e.KeyCode = 13) Then WebBrowser1.Navigate(ToolStripTextBox1.Text) End If End Sub



Chapitre 24

Favoris web

563

Si la touche sur laquelle on a appuyé est la touche Entrée : If (e.KeyCode = 13) Then

la page dont l’URL est spécifiée dans la zone de texte ToolStripTextBox1 apparaît : WebBrowser1.Navigate(ToolStripTextBox1.Text)

Double-cliquez sur la première liste déroulante 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 WebBrowser1.Navigate(DonneURL(ComboBox1.Text)) End Sub

Lorsqu’une entrée est sélectionnée dans la première liste déroulante, la page correspondante s’affiche dans le contrôle WebBrowser1. L’URL de la page sélectionnée est calculée par la fonction DonneURL(), dont voici le code : Public Function DonneURL(ByVal s As String) As String Dim ds As String FileOpen(1, "data.txt", OpenMode.Input) While Not EOF(1) ds = LineInput(1) If ds = s Then DonneURL = LineInput(1) End While FileClose(1) End Function

L’entrée sélectionnée par l’utilisateur est passée en paramètre à la fonction : Public Function DonneURL(ByVal s As String) As String

Une boucle While End While parcourt l’ensemble des lignes du fichier data.txt à la recherche de la chaîne passée. Lorsque cette valeur est trouvée, l’URL se trouve sur la ligne suivante. Il suffit d’utiliser une instruction LineInput() pour l’obtenir : While Not EOF(1) ds = LineInput(1) If ds = s Then DonneURL = LineInput(1) End While

Les procédures événementielles ComboBox2_SelectedIndexChanged() à ComboBox8_SelectedIndexChanged() sont identiques à la procédure ComboBox1_SelectedIndexChanged(), à ceci près qu’elles communiquent à la procédure DonneURL() les valeurs sélectionnées dans les listes déroulantes ComboBox2 à ComboBox8.



564

Visual Basic 2010

Voici le listing complet de la feuille principale de l’application SuperNavigateur. Les fichiers correspondants se trouvent dans le dossier Projects\SuperNavigateur des sources de l’ouvrage. Public Class Form1 Dim i, j As Integer Dim data(4, 100) As String ‘Tableau de données Dim NbData As Integer ‘Nombre de références dans les onglets Dim NDparListe(8) As Integer Dim s As String Dim NbListes As Integer Dim NomListes(8) As String Dim l1 As New Collections.ArrayList(20) Dim l2 As New Collections.ArrayList(20) Dim l3 As New Collections.ArrayList(20) Dim l4 As New Collections.ArrayList(20) Dim l5 As New Collections.ArrayList(20) Dim l6 As New Collections.ArrayList(20) Dim l7 As New Collections.ArrayList(20) Dim l8 As New Collections.ArrayList(20) Dim bis As Boolean Public Sub MAJListes() ‘Lecture du fichier de données i = 1 Try FileOpen(1, "data.txt", OpenMode.Input) While Not EOF(1) data(1, i) = LineInput(1) data(2, i) = LineInput(1) data(3, i) = LineInput(1) data(4, i) = LineInput(1) i = i + 1 End While Catch Finally NbData = i - 1 FileClose(1) End Try ‘Comptage du nombre de listes déroulantes s = "" NbListes = 0 j = -1



Chapitre 24

Favoris web

565

For i = 1 To NbData j = j + 1 If data(1, i) <> s Then If NbListes <> 0 Then NDparListe(NbListes) = j j = 0 End If s = data(1, i) NbListes = NbListes + 1 NomListes(NbListes) = s End If Next NDparListe(NbListes) = j + 1 ‘Initialisation des listes déroulantes l1.Clear() For i = 1 To NDparListe(1) l1.Add(data(2, i)) Next i Label1.Enabled = True Label1.Text = NomListes(1) ComboBox1.DataSource = l1 ComboBox1.Enabled = True ComboBox1.Text = "Choisissez une entrée" If NbListes >= 2 Then l2.Clear() For i = 1 To NDparListe(2) l2.Add(data(2, i + NDparListe(1))) Next i Label2.Enabled = True Label2.Text = NomListes(2) ComboBox2.DataSource = l2 ComboBox2.Enabled = True ComboBox2.Text = "Choisissez une entrée" End If If NbListes >= 3 Then l3.Clear() For i = 1 To NDparListe(3) l3.Add(data(2, i + NDparListe(1) + NDparListe(2))) Next i Label3.Enabled = True Label3.Text = NomListes(3)



566

Visual Basic 2010

ComboBox3.DataSource = l3 ComboBox3.Enabled = True ComboBox3.Text = "Choisissez une entrée" End If If NbListes >= 4 Then l4.Clear() For i = 1 To NDparListe(4) l4.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3))) Next i Label4.Enabled = True Label4.Text = NomListes(4) ComboBox4.DataSource = l4 ComboBox4.Enabled = True ComboBox4.Text = "Choisissez une entrée" End If If NbListes >= 5 Then l5.Clear() For i = 5 To NDparListe(5) l5.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3) „ + NDparListe(4))) Next i Label5.Enabled = True Label5.Text = NomListes(5) ComboBox5.DataSource = l5 ComboBox5.Enabled = True ComboBox5.Text = "Choisissez une entrée" End If If NbListes >= 6 Then l6.Clear() For i = 1 To NDparListe(6) l6.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3) „ + NDparListe(4) + NDparListe(5))) Next i Label6.Enabled = True Label6.Text = NomListes(6) ComboBox6.DataSource = l6 ComboBox6.Enabled = True ComboBox6.Text = "Choisissez une entrée" End If If NbListes >= 7 Then



Chapitre 24

Favoris web

567

l7.Clear() For i = 1 To NDparListe(7) l7.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3) „ + NDparListe(4) + NDparListe(5) + NDparListe(6))) Next i Label7.Enabled = True Label7.Text = NomListes(7) ComboBox7.DataSource = l7 ComboBox7.Enabled = True ComboBox7.Text = "Choisissez une entrée" End If If NbListes >= 8 Then l8.Clear() For i = 1 To NDparListe(8) l8.Add(data(2, i + NDparListe(1) + NDparListe(2) + NDparListe(3) „ + NDparListe(4) + NDparListe(5) + NDparListe(6) + NDparListe(7))) Next i Label8.Enabled = True Label8.Text = NomListes(8) ComboBox8.DataSource = l8 ComboBox8.Enabled = True ComboBox8.Text = "Choisissez une entrée" End If End Sub Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load ‘frmForm1 = Me ‘Déclaration du formulaire 1 MAJListes() ‘Initialisation et affichage des listes déroulantes End Sub Private Sub Form1_Activated(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles MyBase.Activated MAJListes() End Sub Private Sub CacherLaBarreDeNavigationToolStripMenuItem_Click(ByVal sender „ As System.Object, ByVal e As System.EventArgs)



568

Visual Basic 2010

Handles CacherLaBarreDeNavigationToolStripMenuItem.Click If CacherLaBarreDeNavigationToolStripMenuItem.Text = "Cacher la barre de „ navigation" Then ToolStrip1.Visible = False CacherLaBarreDeNavigationToolStripMenuItem.Text = "Afficher la barre „ de navigation" Else ToolStrip1.Visible = True CacherLaBarreDeNavigationToolStripMenuItem.Text = "Cacher la barre „ de navigation" End If End Sub Private Sub CacherLesSitesToolStripMenuItem_Click(ByVal sender As System. „ Object, ByVal e As System.EventArgs) Handles CacherLesSitesToolStripMenuItem.Click If CacherLesSitesToolStripMenuItem.Text = "Cacher les sites" Then Panel1.Visible = False CacherLesSitesToolStripMenuItem.Text = "Montrer les sites" Else Panel1.Visible = True CacherLesSitesToolStripMenuItem.Text = "Cacher les sites" End If End Sub Private Sub PersonnaliserToolStripMenuItem_Click(ByVal sender As System. „ Object, ByVal e As System.EventArgs) Handles PersonnaliserToolStripMenuItem.Click ‘ Ajout, suppression et modification de sites Form2.Show() End Sub Private Sub ToolStripTextBox1_KeyDown(ByVal sender As System.Object, ByVal e „ As System.Windows.Forms.KeyEventArgs) Handles ToolStripTextBox1.KeyDown If (e.KeyCode = 13) Then WebBrowser1.Navigate(ToolStripTextBox1.Text) End If End Sub



Chapitre 24

Favoris web

569

Public Function DonneURL(ByVal s As String) As String Dim ds As String Dim res As String = "" FileOpen(1, "data.txt", OpenMode.Input) While Not EOF(1) ds = LineInput(1) If ds = s Then res = LineInput(1) End While FileClose(1) Return res End Function Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged WebBrowser1.Navigate(DonneURL(ComboBox1.Text)) End Sub Private Sub ComboBox2_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox2.SelectedIndexChanged WebBrowser1.Navigate(DonneURL(ComboBox2.Text)) End Sub Private Sub ComboBox3_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox3.SelectedIndexChanged WebBrowser1.Navigate(DonneURL(ComboBox3.Text)) End Sub Private Sub ComboBox4_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox4.SelectedIndexChanged WebBrowser1.Navigate(DonneURL(ComboBox4.Text)) End Sub Private Sub ComboBox5_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox5.SelectedIndexChanged



570

Visual Basic 2010

WebBrowser1.Navigate(DonneURL(ComboBox5.Text)) End Sub Private Sub ComboBox6_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox6.SelectedIndexChanged WebBrowser1.Navigate(DonneURL(ComboBox6.Text)) End Sub Private Sub ComboBox7_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox7.SelectedIndexChanged WebBrowser1.Navigate(DonneURL(ComboBox7.Text)) End Sub Private Sub ComboBox8_SelectedIndexChanged(ByVal sender As System.Object, „ ByVal e As System.EventArgs) Handles ComboBox8.SelectedIndexChanged WebBrowser1.Navigate(DonneURL(ComboBox8.Text)) End Sub Private Sub Form1_Resize(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Resize Dim largeur As String = Me.Width ToolStripTextBox1.Size = New System.Drawing.Size(largeur - 70, 21) ‘Me.Width „ - 200 End Sub Private Sub AideSuperNavigateurToolStripMenuItem_Click(ByVal sender As „ System.Object, ByVal e As System.EventArgs) Handles AideSuperNavigateurToolStripMenuItem.Click Help.ShowHelpIndex(Me, " AideSN.chm") End Sub End Class

Vous allez maintenant insérer une deuxième feuille dans l’application. Lancez la commande Ajouter un formulaire Windows dans le menu Projet. Choisissez le modèle Windows Form, appelez le formulaire Form2.vb et validez.



Chapitre 24

Favoris web

571

Basculez sur la deuxième feuille de l’application. Ajoutez un contrôle ToolStrip et un contrôle DataGridView à la feuille. Ajoutez un ToolStripLabel, un ToolStripTextBox et un ToolStripButton au contrôle ToolStrip. Modifiez les propriétés de ces objets comme indiqué dans le tableau suivant : Contrôle

Propriété

Valeur

Form1

Text

Personnalisation du navigateur

ToolStrip1

Dock

Top

ToolStripLabel1

Text

Cellule en cours

ToolStripTextBox1

Text

TextBox1

Size.Width

Left, Right, Top

ToolStripButton1

Text

Quitter

AxMSFlexGrid1

Dock

Fill

Cliquez sur le contrôle DataGridView1 puis sur les points de suspension à la suite de la propriété Columns. Une boîte de dialogue intitulée Modifier les colonnes s’affiche (voir Figure 24.3). Figure 24.3 Pour l’instant, l’objet DataGridView ne contient aucune colonne.

Cliquez sur Ajouter. Une nouvelle boîte de dialogue intitulée Ajouter une colonne apparaît (voir Figure 24.4).



572

Visual Basic 2010

Figure 24.4 Cette boîte de dialogue permet de définir de nouvelles colonnes dans le contrôle DataGridView.

Vous allez définir quatre colonnes en entrant les valeurs suivantes dans les zones de texte Nom, Type et Texte de l’en-tête et en cliquant sur Ajouter : Nom

Type

Texte de l’en-tête

Onglet

DataGridViewTextBoxColum

Onglet

NomDuSite


Nom du site

URL


URL

Commentaire


Commentaire

Si vous avez suivi nos indications, la boîte de dialogue Modifier les colonnes soit maintenant se présenter comme à la Figure 24.5. Figure 24.5 Quatre colonnes ont été définies dans le contrôle DataGridView.



Chapitre 24

Favoris web

573

Disposez et redimensionnez ces contrôles pour obtenir un aspect visuel proche de la Figure 24.6. Figure 24.6 La deuxième feuille de l’application en mode Édition.

Définissez les objets utilisés par cette deuxième feuille en tête de listing : Dim Dim Dim Dim

i As Integer data(4, 100) As String ‘Tableau de données NbData As Integer ‘Nombre de références dans les onglets DimCol As Integer

Basculez sur l’onglet Form2.db [Design]. Sélectionnez l’objet Form2 dans la fenêtre Propriétés, cliquez sur Événements, double-cliquez sur l’événement Load et complétez la procédure Form2_Load() comme suit : Private Sub Form2_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load ‘Lecture du fichier de données Dim s1, s2, s3, s4 As String Try FileOpen(1, "data.txt", OpenMode.Input) Do s1 = LineInput(1) s2 = LineInput(1) s3 = LineInput(1) s4 = LineInput(1) DataGridView1.Rows.Add(New String() {s1, s2, s3, s4}) Loop Until EOF(1) Catch Finally FileClose(1) End Try End Sub



574

Visual Basic 2010

La première instruction définit les quatre variables String qui seront utilisées pour écrire une ligne dans le contrôle DataGridView : Dim s1, s2, s3, s4 As String

Le fichier de données est ouvert à l’intérieur d’une structure Try End Try : Try FileOpen(1, "data.txt", OpenMode.Input) End Try

Les données sont lues dans le fichier à l’aide d’une boucle Do Loop qui prend fin lorsque la marque de fin de fichier est atteinte : Do s1 = LineInput(1) s2 = LineInput(1) s3 = LineInput(1) s4 = LineInput(1) DataGridView1.Rows.Add(New String() {s1, s2, s3, s4}) Loop Until EOF(1)

Remarquez l’instruction permettant de copier le contenu des quatre variables String dans une ligne du DataGridView : DataGridView1.Rows.Add(New String() {s1, s2, s3, s4})

Une collection de String est créée (New String()), décrite ({s1, s2, s3, s4}) et passée comme argument à la procédure DataGridView1.Rows.Add. Simple et efficace ! La boucle Try se termine par la fermeture du fichier de données : Catch Finally FileClose(1) End Try

Pour modifier ou ajouter des données dans le contrôle DataGridView, l’utilisateur doit cliquer sur une cellule, entrer une valeur dans la zone de texte et appuyer sur la touche Entrée du clavier. Basculez sur la fenêtre de code Form2.vb, sélectionnez DataGridView1 dans la première liste déroulante, CellClick dans la deuxième et complétez la procédure DataGridView1_CellClick() comme suit : Private Sub DataGridView1_CellClick(ByVal sender As System.Object, ByVal e As System.Windows.Forms.DataGridViewCellEventArgs) Handles DataGridView1.CellClick ToolStripTextBox1.Text = DataGridView1.CurrentCell.Value ToolStripTextBox1.Focus() End Sub



Chapitre 24

Favoris web

575

La première instruction affecte le texte contenu dans la cellule cliquée à la zone de texte : ToolStripTextBox1.Text = DataGridView1.CurrentCell.Value

La deuxième instruction donne le focus à la zone de texte afin que l’utilisateur puisse modifier la valeur inscrite : ToolStripTextBox1.Focus()

Pour que la valeur saisie dans la zone de texte s’inscrive dans la cellule précédemment cliquée lorsque l’utilisateur appuie sur la touche Entrée, définissez la procédure ToolStrip TextBox1_KeyPress() suivante : Private Sub ToolStripTextBox1_KeyPress(ByVal sender As System.Object, ByVal e „ As System.Windows.Forms.KeyPressEventArgs) Handles ToolStripTextBox1.KeyPress If Asc(e.KeyChar) = 13 Then DataGridView1.CurrentCell.Value = ToolStripTextBox1.Text End If End Sub

Si la touche sur laquelle on a appuyé est la touche Entrée : If Asc(e.KeyChar) = 13 Then

le contenu de la zone de texte est copié dans la cellule précédemment cliquée : DataGridView1.CurrentCell.Value = ToolStripTextBox1.Text

Pour terminer, vous allez définir le code qui sauvegarde le contenu du contrôle DataGridView1 dans le fichier data.txt lorsque l’utilisateur ferme la deuxième feuille ou clique sur le bouton Quitter. Définissez pour cela les procédures événementielles Form2_FormClosing() et ToolStripButton1_Click() : Private Sub Form2_FormClosing(ByVal sender As Object, ByVal e As System.Windows. Forms.FormClosingEventArgs) Handles Me.FormClosing Sauvegarde() End Sub Private Sub ToolStripButton1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ToolStripButton1.Click Sauvegarde() Me.Close() End Sub

Form2_FormClosing() et Button1_Click() appellent la procédure Sauvegarde() pour mémoriser les informations de la grille dans le fichier data.txt. La procédure Button1_ Click() ferme également la deuxième feuille à l’aide de l’instruction Me.Close. La première



576

Visual Basic 2010

feuille de l’application reprend alors le contrôle et met à jour les listes déroulantes à l’aide de sa procédure Form1_Activated(). Pour terminer, définissez la procédure Sauvegarde() comme suit : Public Sub Sauvegarde() ‘Sauvegarde du DataGridView dans le fichier Data.txt Try FileOpen(1, "data.txt", OpenMode.Output) For i = 0 To DataGridView1.Rows.Count - 1 Dim row As DataGridViewRow = DataGridView1.Rows(i) If row.Cells(0).Value + row.Cells(1).Value + row.Cells(2).Value „ + row.Cells(3).Value <> "" Then PrintLine(1, row.Cells(0).Value) PrintLine(1, row.Cells(1).Value) PrintLine(1, row.Cells(2).Value) PrintLine(1, row.Cells(3).Value) End If Next Catch Finally FileClose(1) End Try End Sub

Après avoir ouvert le fichier data.txt en écriture : FileOpen(1, "data.txt", OpenMode.Output)

une boucle For Next parcourt toutes les cellules du contrôle DataGridView et stocke leur contenu dans le fichier : For i = 0 To DataGridView1.Rows.Count – 1

Pour faciliter l’écriture du code, nous définissons l’objet DataGridViewRow row et nous l’initialisons avec les données de la ligne indexée par i : Dim row As DataGridViewRow = DataGridView1.Rows(i)

Si les cellules de la ligne i contiennent des données : If row.Cells(0).Value + row.Cells(1).Value + row.Cells(2).Value + row.Cells(3). Value <> "" Then

Ces données sont stockées dans le fichier data.txt : PrintLine(1, row.Cells(0).Value) PrintLine(1, row.Cells(1).Value)



Chapitre 24

Favoris web

577

PrintLine(1, row.Cells(2).Value) PrintLine(1, row.Cells(3).Value)

Voici le listing complet de la feuille secondaire de l’application SuperNavigateur. Les fichiers complémentaires se trouvent dans le dossier Projects\SuperNavigateur des sources de l’ouvrage. Public Class Form2 Dim i As Integer Dim data(4, 100) As String ‘Tableau de données Dim NbData As Integer ‘Nombre de références dans les onglets Dim DimCol As Integer Private Sub Form2_FormClosing(ByVal sender As Object, ByVal e As System. „ Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing Sauvegarde() End Sub Private Sub Form2_Load(ByVal sender As System.Object, ByVal e As System. „ EventArgs) Handles MyBase.Load ‘Lecture du fichier de données Dim s1, s2, s3, s4 As String Try FileOpen(1, "data.txt", OpenMode.Input) Do s1 = LineInput(1) s2 = LineInput(1) s3 = LineInput(1) s4 = LineInput(1) DataGridView1.Rows.Add(New String() {s1, s2, s3, s4}) Loop Until EOF(1) Catch Finally FileClose(1) End Try End Sub Private Sub DataGridView1_CellClick(ByVal sender As System.Object, ByVal e As „ System.Windows.Forms.DataGridViewCellEventArgs) Handles DataGridView1.CellClick ToolStripTextBox1.Text = DataGridView1.CurrentCell.Value + Str(DataGridView1.Rows.Count) ToolStripTextBox1.Focus() End Sub



578

Visual Basic 2010

Private Sub ToolStripTextBox1_KeyPress(ByVal sender As System.Object, ByVal e „ As System.Windows.Forms.KeyPressEventArgs) Handles ToolStripTextBox1.KeyPress If Asc(e.KeyChar) = 13 Then DataGridView1.CurrentCell.Value = ToolStripTextBox1.Text End If End Sub Public Sub Sauvegarde() ‘Sauvegarde du DataGridView dans le fichier Data.txt Try FileOpen(1, "data.txt", OpenMode.Output) For i = 0 To DataGridView1.Rows.Count - 1 Dim row As DataGridViewRow = DataGridView1.Rows(i) If row.Cells(0).Value + row.Cells(1).Value + row.Cells(2).Value „ + row.Cells(3).Value <> "" Then PrintLine(1, row.Cells(0).Value) PrintLine(1, row.Cells(1).Value) PrintLine(1, row.Cells(2).Value) PrintLine(1, row.Cells(3).Value) End If Next Catch Finally FileClose(1) End Try End Sub Private Sub ToolStripButton1_Click(ByVal sender As System.Object, ByVal e „ As System.EventArgs) Handles ToolStripButton1.Click Sauvegarde() Me.Close() End Sub End Class

Définition et implémentation du fichier d’aide Nous allons définir puis intégrer un fichier d’aide .CHM dans le projet. Si nécessaire, vous pouvez consulter le Chapitre 16 pour avoir des informations complémentaires sur la création et l’utilisation d’un projet d’aide.



Chapitre 24

Favoris web

579

Première étape : collecte des informations utilisées par le système d’aide Les rubriques d’aide vont être les suivantes :

∑ ∑

Message de bienvenue ;

– Barre d’adresses ;

– Listes déroulantes ;

– Redimensionnement ;

∑

Personnalisation du programme.

Utilisation du produit :

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 (Bloc-notes de Windows, Microsoft FrontPage Express ou Microsoft FrontPage, etc.) pour créer les différentes pages. Voici le code source des cinq fichiers à intégrer dans l’aide. Présentation.htm Présentation L’application "Super Navigateur" est un navigateur Web qui permet de mémoriser vos sites préférés dans une à huit listes déroulantes thématiques. Il contient :

Une barre d’adresses pour afficher les sites de votre choix ;
Un outil de mise à jour des listes déroulantes.
Plusieurs sites types sont proposés par défaut. Quelques secondes suffisent pour les supprimer ou les modifier.



580

Visual Basic 2010

BarreAdresse.htm Etendre l’onglet Astuces La barre d’adresses permet d’entrer une adresse Web quelconque. Lorsque vous appuyez sur la touche Entrée du clavier, la page correspondante apparaît dans la zone d’affichage (partie inférieure de l’application).
Remarque :
Il n’est pas nécessaire d’entrer le préfixe http://. Celui-ci est automatiquement ajouté à l’adresse saisie.

ListesDéroulantes.htm Etendre l’onglet Raccourcis Pour faciliter l’accès à vos pages préférées, une à huit listes déroulantes thématiques peuvent être utilisées.
Ces listes sont automatiquement initialisées dès l’ouverture de l’application.
Pour accéder à une des entrées mémorisées dans les listes déroulantes, il suffit de la sélectionner.
Consultez la rubrique "Personnalisation" pour savoir comment modifier le contenu des listes déroulantes.

Redimensionnement.htm Onglet Astuces



Chapitre 24

Favoris web

581

La fenêtre de l’application peut être redimensionnée en utilisant les moyens conventionnels :

Boutons Agrandir et Restaurer ;
Pointage d’une bordure ou d’un coin de l’application et déplacement de la souris en maintenant le bouton gauche enfoncé.
Vous pouvez également utiliser les commandes "Cacher la barre de navigation" et "Cacher les sites" dans le menu "Outils" pour augmenter la taille de la zone d’affichage.
Ces commandes sont automatiquement remplacées par (respectivement) "Afficher la barre de navigation" et "Montrer les sites".

Personnalisation.htm Etendre l’onglet Astuces Utilisez la commande Personnaliser dans le menu Outils pour accéder à l’outil de personnalisation de l’application.
Les entrées des listes déroulantes sont disposées dans trois colonnes :

Onglet : Nom de la liste déroulante ;
Nom du site : Nom du site en clair ;
URL : Adresse URL complète ;
Commentaire : Texte facultatif qui commente le site.
Pour modifier une cellule, cliquez dessus, utilisez la zone d’édition "Cellule en cours" puis appuyez sur la touche Entrée du clavier.
Si nécessaire, la fenêtre de personnalisation ainsi que les colonnes du tableau peuvent être redimensionnées.
Lorsque le paramétrage est complet, cliquez sur le bouton Quitter ou sur la case de fermeture pour retourner au Super Navigateur.



582

Visual Basic 2010

Troisième étape : utilisation de l’application HTML Help Workshop Lancez l’application HTML Help Workshop avec la commande Tous les programmes/ HTML Help Workshop/HTML Help Workshop dans le menu Démarrer. 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 au format .HLP. 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. 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. Cliquez sur Suivant puis sur Terminer pour générer le projet d’aide. La fenêtre de l’appli cation HTML Help Workshop se présente maintenant comme à la Figure 24.7. Figure 24.7 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. Choisissez l’option Create a new contents file dans la boîte de dialogue Table of Contents Not Specified. Cliquez sur OK. Donnez un nom au fichier sommaire et cliquez sur Enregistrer pour créer le fichier d’extension .HHC.



Chapitre 24

Favoris web

583

Sélectionnez l’onglet Index. Choisissez l’option Create a new index file dans la boîte de dialogue Index Not Specified. 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. Définissez un fichier texte qui référence les différentes pages de l’aide comme à la Figure 24.8. Sauvegardez ce fichier en lui donnant l’extension .H. Figure 24.8 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 apparaît. 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. Validez en cliquant sur le bouton OK. 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 24.9). Figure 24.9 Définition d’un alias.



584

Visual Basic 2010

Lorsque tous les alias ont été définis, vous devez obtenir quelque chose comme à la Figure 24.10. Figure 24.10 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. À titre d’exemple, la Figure 24.11 représente la rubrique Listes déroulantes. 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 24.11 Entrée de sommaire Listes déroulantes.

Lorsque toutes les entrées du sommaire ont été définies, la fenêtre HTML Help Workshop doit ressembler à la Figure 24.12.



Chapitre 24

Favoris web

585

Figure 24.12 Le sommaire est entièrement défini.

Définition de l’index Vous devez tout d’abord basculer sur l’onglet Index. Pour définir une entrée d’index, cliquez sur l’icône Insert a keyword, puis entrez un mot dans la zone de texte Keyword. Cliquez autant de fois que nécessaire sur le bouton Add pour lier le mot-clé aux pages de l’aide. 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 24.13). Figure 24.13 Aucune erreur n’a été détectée dans le projet d’aide.



586

Visual Basic 2010

Quatrième étape : interfaçage du fichier d’aide .CHM avec le projet Pour intégrer le fichier d’aide .CHM au projet, 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. 3. Déroulez le menu Aide de la première feuille de l’application et double-cliquez sur l’entrée Aide SuperNavigateur. Complétez la procédure Menu5Item_Click() comme suit : Private Sub AideSuperNavigateurToolStripMenuItem_Click(ByVal sender As System. Object, ByVal e As System.EventArgs) Handles AideSuperNavigateurToolStripMenu Item.Click Help.ShowHelpIndex(Me, "c`\AideSN.chm") End Sub

La Figure 24.14 donne un exemple d’affichage de l’aide depuis l’application "Super Navigateur". Figure 24.14 La fenêtre d’aide a été affichée avec la touche F1.

Les fichiers relatifs au projet d’aide se trouvent dans le dossier Projects\SuperNavigateur\ SuperNavigateur\Aide, après installation des sources de l’ouvrage.



25 Services web Les nouvelles technologies de l’information (telles qu’Internet et les intranets) ont connu un essor considérable ces dernières années. Aujourd’hui, les développeurs ne peuvent plus ignorer ces médias qui, peu à peu, sont devenus un moyen de communication indispensable pour tout ordinateur qui se respecte. Malheureusement, aucun vrai standard technologique n’occupe les devants de la scène. S’il est vrai que le langage HTML est très répandu, il est également vrai qu’une même page a toutes les chances de s’afficher différemment selon le navigateur ou le système d’exploitation utilisé. Un grand nombre de langages sont venus élargir les possibilités du HTML, mais, là aussi, la barrière du navigateur a été un vrai frein à leur expansion… Avec Visual Studio 2010, Microsoft propose un concept qui a toutes les chances de devenir le standard Internet de demain. Pour mieux comprendre ses immenses possibilités, nous allons raisonner sur un exemple. Supposez qu’un site affiche en continu la valeur du CAC 40 (cours des quarante plus importantes sociétés françaises cotées en Bourse) et mette cette information à la libre disposition des concepteurs de sites. Pour intégrer ce flux de données dans une page, le moyen le plus conventionnel consiste à insérer un script. Malheureusement, le format d’affichage du



588

Visual Basic 2010

CAC 40 imaginé par les concepteurs du script a peu de chances de correspondre à l’aspect général de la page sur laquelle vous comptez l’insérer… Imaginez maintenant qu’il existe un moyen d’exposer l’objet CAC 40 sans aucune interface utilisateur, c’est-à-dire en rendant accessibles les seules méthodes et propriétés de cet objet. Microsoft a imaginé un tel système. À travers son IDE Visual Studio, il est désormais très simple de créer des objets sans interfaces. Appelés "services web", ces objets peuvent être considérés comme des boîtes noires. Ils possèdent des propriétés accessibles en lecture seule, en écriture seule ou en lecture/écriture et des méthodes pour effectuer les actions qui ont motivé leur conception. La mise en place de services web semble essentielle pour une société. Elle permet en effet d’ouvrir les développements internes à d’autres usages, à d’autres besoins et à d’autres clients, extérieurs à l’entreprise. Il est difficile de prévoir à l’avance le comportement de la communauté de programmeurs, mais il semble évident, au vu des possibilités offertes par les services web, que ce type d’objet va devenir courant et même universel dans les années à venir. À travers un exemple simple, cette section va vous montrer comment créer, tester et utiliser un service web élémentaire. Ce service va permettre de connaître le nombre de caractères d’une de ses propriétés chaîne. L’intérêt d’un tel service est des plus limité, puisqu’il suffit d’utiliser la fonction Visual Basic Len() pour obtenir le même résultat. Il a cependant l’avantage de montrer la technique à utiliser pour définir puis utiliser un service web.

Conception du service Lancez la commande Nouveau/Site web dans le menu Fichier. Choisissez .NET Framework 3.5 dans la liste déroulante Framework, puis Services web ASP.NET dans zone de liste centrale. Donnez le nom Service2 au projet et validez. Quelques instants plus tard, le nouveau service web est prêt à être édité dans Visual Studio (voir Figure 25.1). Ce service élémentaire n’utilise aucun composant. Nous allons donc immédiatement intervenir dans le code. En tête du listing, remarquez les trois lignes Imports : Imports System.Web Imports System.Web.Services Imports System.Web.Services.Protocols

Ces lignes donnent accès aux fonctionnalités Microsoft propres aux services web. Remarquez la déclaration de la classe Service2 : Public Class Service Inherits System.Web.Services.WebService



Chapitre 25

Services web

589

Ces deux lignes créent la classe Service. Cette classe hérite des fonctionnalités de la classe WebService de Microsoft. Figure 25.1 Visual Studio est prêt pour la mise en place du nouveau service web.

Supprimez la fonction HelloWorld() : Public Function HelloWorld() As String Return "Hello World" End Function

Et remplacez-la par la fonction Longueur suivante : _ Public Function Longueur(ByVal l As String) As Integer Return Len(l) End Function

La première ligne indique que cette fonction est une WebMethod à laquelle on devra accéder depuis le Net. La variable Description contient une brève description de la fonction. Comme nous le verrons dans les pages suivantes, cette description apparaîtra dans la page ASMX générée par Visual Studio. _

La fonction Longueur() se déclare comme s’il s’agissait d’une fonction Visual Basic classique. Elle admet un argument String et retourne une valeur Integer : Public Function Longueur(ByVal l As String) As Integer



590

Visual Basic 2010

La valeur retournée est calculée à l’aide de la fonction Visual Basic Len() : Return Len(l)

Voici le code complet de la classe Service2. Ce code ainsi que les fichiers qui l’accompagnent sont disponibles dans le dossier Websites\Service2 après installation des sources de l’ouvrage. Imports System.Web Imports System.Web.Services Imports System.Web.Services.Protocols _ _ _ Public Class Service Inherits System.Web.Services.WebService _ Public Function Longueur(ByVal l As String) As Integer Return Len(l) End Function End Class

Le service est prêt à l’emploi. Appuyez sur la touche F5 ou lancez la commande Démarrer le débogage dans le menu Déboguer pour créer les fichiers relatifs au service web. Une boîte de dialogue vous signale que le déboguer n’est pas activé (voir Figure 25.2). Sélectionnez l’option Modifier le fichier Web.config pour activer le débogage et cliquez sur OK. Figure 25.2 Vous devez activer le débogage.

Visual Studio crée une définition XML du service et une page web qui permet d’accéder aux méthodes du service. Au bout de quelques instants, cette page est ouverte dans le navigateur Internet par défaut (voir Figure 25.3).



Chapitre 25

Services web

591

Figure 25.3 Cette page donne accès au service web.

Cliquez sur le lien Longueur pour tester la méthode Longueur(). Le navigateur affiche maintenant des informations concernant la méthode Longueur et permet de saisir une valeur chaîne afin de tester son fonctionnement (voir Figure 25.4). Figure 25.4 Le test de la fonction Longueur().



592

Visual Basic 2010

La partie inférieure de la fenêtre du navigateur indique comment interroger ce service web : POST /Service2/Service.asmx HTTP/1.1 Host: localhost Content-Type: application/soap+xml; charset=utf-8 Content-Length: length string HTTP/1.1 200 OK Content-Type: application/soap+xml; charset=utf-8 Content-Length: length int HTTP POST POST /Service2/Service.asmx/Longueur HTTP/1.1 Host: localhost Content-Type: application/x-www-form-urlencoded Content-Length: length l=string HTTP/1.1 200 OK Content-Type: text/xml; charset=utf-8 Content-Length: length int



Chapitre 25

Services web

593

Entrez un texte dans la zone Valeur du paramètre L et cliquez sur Appeler. À titre d’exemple, nous avons saisi la chaîne "test de la fonction Longueur()" dans la zone Longueur. La Figure 25.5 donne un aperçu des informations renvoyées. Figure 25.5 La longueur de la chaîne apparaît sur la seconde ligne.

Utilisation du service Vous allez maintenant découvrir comment faire appel au service web qui a été défini dans la section précédente. Ouvrez une deuxième instance de Visual Studio et lancez la commande Nouveau/Site web dans le menu Fichier. Sélectionnez .NET Framework 3.5 dans la liste déroulante Framework, Site web ASP.NET dans la zone de liste centrale, donnez le nom TestWSLen au site et validez. Lorsque le squelette de l’application a été généré, cliquez du bouton droit sur l’entrée C:\…\TestWSLen\ dans l’Explorateur de solutions et choisissez Ajouter une référence web dans le menu surgissant. Le service web étant toujours en phase de débogage, une info-bulle signale sa présence dans la barre de notification (voir Figure 25.6). Figure 25.6 L’info-bulle indique le port utilisé par le service web. Ici, il s’agit du port 52306.

Si l’info-bulle ne s’affiche pas dans la barre de notification, repérez l’icône du service web1 dans la barre de notification (ou dans les icônes cachées) et double-cliquez dessus. Une boîte de dialogue analogue à la Figure 25.7 apparaît. 1. Cette icône est facile à repérer : lorsque vous la pointez avec la souris, une info-bulle intitulée «Serveur de développement ASP.NET» apparaît.



594

Visual Basic 2010

Figure 25.7 Le port apparaît clairement dans la zone de texte Port.

Le port utilisé par le service web s’affiche dans cette boîte de dialogue. Dans l’Explorateur de solutions, cliquez du bouton droit sur l’entrée TestWSLen et sélectionnez Ajouter une référence web dans le menu contextuel. Indiquez les références du service que vous voulez utiliser dans la zone de texte URL (voir Figure 25.8). Figure 25.8 L’adresse du service a été entrée dans la zone URL.

Cliquez sur Aller À. La boîte de dialogue Ajouter une référence web doit se présenter comme à la Figure 25.9. Cliquez sur Ajouter une référence. L’Explorateur de solutions contient maintenant la référence au service Service1 (voir Figure 25.10).



Chapitre 25

Services web

595

Figure 25.9 Le service Service2 est sur le point d’être référencé dans le projet.

Figure 25.10 Service2 est référencé dans l’Explorateur de solutions.

Développez l’onglet Standard de la Boîte à outils et ajoutez un Label, un TextBox et un Button à la feuille. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant. Contrôle

Propriété

Valeur

Label1

Text

Entrez du texte dans la zone de texte

TextBox1

Text

Button1

Text

Longueur



596

Visual Basic 2010

Nous allons maintenant relier le bouton de commande à la fonction Longueur() du service web Service2. Double-cliquez sur le bouton 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 Resultat As Integer Dim objLongueur As New localhost.Service Resultat = objLongueur.Longueur(TextBox1.Text) TextBox1.Text = "Le texte entré a une longueur de " + Str(Resultat) + " caractères." End Sub

La première instruction définit la variable entière dans laquelle sera stocké le résultat renvoyé par la fonction Longueur() : Dim Resultat As Integer

La seconde instruction définit l’objet qui servira d’interface pour accéder au service Service2 puis à la fonction Longueur() : Dim objLongueur As New localhost.Service

Pour obtenir la longueur du texte entré dans le TextBox, il suffit de le passer en argument de la fonction Longueur() : Resultat = objLongueur.Longueur(TextBox1.Text)

La valeur retournée s’affiche dans le TextBox : TextBox1.Text = "Le texte entré a une longueur de " + Str(Resultat) + " caractères."

Vous pouvez vérifier que la méthode Longueur() du service web Service2 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 exécuté (voir Figure 25.11). Sélectionnez l’option Modifier le fichier web.config pour activer le débogage et validez en cliquant sur OK. Figure 25.11 Vous devez activer le débogage.



Chapitre 25

Services web

597

Au bout de quelques secondes, l’Explorateur web affiche le contenu de la page web (voir Figure 25.12). Figure 25.12 La page de l’application web.

Entrez un texte dans la zone de texte et cliquez sur Longueur. Après quelques instants, un message du type suivant apparaît dans la zone de texte : Le texte entré a une longueur de 23 caractères

Voici le code complet de l’application. Il est disponible ainsi que les fichiers qui l’accompagnent dans le dossier Websites\WebSite2 après installation des sources de l’ouvrage. 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 Resultat As Integer Dim objLongueur As New localhost.Service Resultat = objLongueur.Longueur(TextBox1.Text) TextBox1.Text = "Le texte entré a une longueur de " + Str(Resultat) „ + " caractères." End Sub End Class

Le service web qui vient d’être développé et utilisé est des plus élémentaire. Il entrouvre cependant une porte vers les immenses possibilités propres aux services web.



598

Visual Basic 2010

Utilisation d’un service web existant À titre d’exemple, nous allons vous montrer comment interfacer un service web permettant de vérifier la validité d’une adresse e-mail. Librement disponible sur le Net, ce service est proposé par la société WebservicesX.NET. Des informations sur les différents services offerts par cette société sont disponibles sur le site http://www.webservicex.net/WCF/ webServices.aspx (voir Figure 25.13). Figure 25.13 Les services web de la société WebserviceX. NET.

Pour accéder au service web de vérification d’e-mails, cliquez sur le lien Communications puis sur le lien Validate Email Address. La page affichée laisse apparaître le code XML correspondant au service, l’adresse URL du service et les deux méthodes accessibles dans le service (voir Figure 25.14). Pour avoir un aperçu du fonctionnement de la méthode IsValidEmail(), cliquez sur le lien correspondant. Entrez l’adresse à tester et cliquez sur Invoke. La valeur renvoyée par la méthode apparaît dans une nouvelle page (voir Figure 25.15). En déroulant la page de test du service web, vous pouvez voir que la méthode IsValid Email() demande une valeur de type String en entrée et renvoie une valeur de type Boolean (voir Figure 25.16) :



Chapitre 25

Services web

599

Figure 25.14 Une méthode est accessible dans le service IsValidEmailEmail.

Figure 25.15 La valeur renvoyée par la méthode IsValidEmail est True : l’adresse e-mail spécifiée existe.

Figure 25.16 La valeur renvoyée par la méthode apparaît dans la réponse SOAP.



600

Visual Basic 2010

Vous avez maintenant tous les éléments en main pour interfacer le service web ValidateEmail :

∑ ∑ ∑

L’adresse du service est http://www.webservicex.net/ValidateEmail.asmx?WSDL. Le paramètre passé en entrée de la méthode IsValidEmail() est de type String. La valeur renvoyée en sortie de la méthode IsValidEmail() est de type Boolean.

Accès traditionnel au service web Lancez la commande Nouveau/Site web dans le menu Fichier. Dans la liste déroulante Framework, choisissez .NET Framework 4. Dans le volet gauche, sous Modèles installés, choisissez Visual Basic. Sélectionnez le modèle Site web ASP.NET, donnez le nom TestWSIsValidEmail au site et validez. Lorsque le squelette du projet a été construit, cliquez du bouton droit sur l’entrée C:\…\TestWSIsValidEmail dans l’Explorateur de solutions et choisissez Ajouter une référence web dans le menu surgissant. Entrez l’adresse du service web dans la zone URL et cliquez sur Aller à. Quelques instants plus tard, le service est prêt à être incorporé au projet (voir Figure 25.17). Figure 25.17 Les méthodes du service ValidateEmail apparaissent dans cette fenêtre.

Cliquez sur Ajouter une référence. Développez l’onglet Standard de la Boîte à outils, puis ajoutez un TextBox, un Button et un Label à la feuille de l’application. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau suivant :



Chapitre 25

Services web

Contrôle

Propriété

Valeur

Button1

Text

Tester e-mail

Label1

Text

601

Double-cliquez sur le bouton Tester e-mail 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 ev As New net.webservicex.www.ValidateEmail Dim result As New Boolean result = ev.IsValidEmail(TextBox1.Text) If result Then Label1.Text = "L’adresse spécifiée est fonctionnelle" Else Label1.Text = "L’adresse spécifiée n’existe pas" End If End Sub

La première instruction définit l’objet interface entre le programme et le service web : Dim ev As New net.webservicex.www.ValidateEmail

La syntaxe utilisée est très simple. Elle reprend l’arborescence indiquée dans l’Explorateur de solutions (voir Figure 25.18), suivie d’un point, suivie du nom du service. Figure 25.18 La référence web est net.webservicex.www.ValidateEmail.



602

Visual Basic 2010

La deuxième instruction définit la variable booléenne Result qui contiendra le résultat renvoyé par la méthode IsValidEmail : Dim result As New Boolean

Cette variable est initialisée avec la valeur renvoyée par IsValidEmail() : result = ev.IsValidEmail(TextBox1.Text)

Une structure If Then Else est alors utilisée pour afficher le résultat dans le Label. Si la valeur renvoyée est True, un message indique que l’adresse e-mail est fonctionnelle : If result Then Label1.Text = "L’adresse spécifiée est fonctionnelle"

Dans le cas contraire, un message indique que l’adresse e-mail n’existe pas : Else Label1.Text = "L’adresse spécifiée n’existe pas"

Pour tester l’application, cliquez sur l’icône Démarrer le débogage de la barre d’outils. Si une boîte de dialogue indiquant que le débogage n’est pas activé (voir Figure 25.19), sélectionnez l’option Modifier le fichier Web.config pour activer le débogage et validez en cliquant sur OK. Figure 25.19 Vous devez activer le débogage.

Au bout de quelques instants, l’application apparaît dans votre navigateur web par défaut. La Figure 25.20 donne un exemple d’exécution de cette application. Voici le code complet de cette application. Ce projet se trouve dans le dossier TestWSIsValidEmail après installation des sources de l’ouvrage. Partial Class _Default Inherits System.Web.UI.Page Protected Sub Button1_Click(ByVal sender As Object, ByVal e As System.



Chapitre 25

Services web

603

„ EventArgs) Handles Button1.Click Dim ev As New net.webservicex.www.ValidateEmail Dim result As New Boolean result = ev.IsValidEmail(TextBox1.Text) If result Then Label1.Text = “L’adresse spécifiée est fonctionnelle” Else Label1.Text = “L’adresse spécifiée n’existe pas” End If End Sub End Class

Figure 25.20 L’adresse e-mail spécifiée n’est pas opérationnelle.

Accès au service web via My.WebServices Le service web peut également être accédé par l’intermédiaire d’un objet My.WebServices. Lancez la commande Nouveau/Projet dans le menu Fichier. Choisissez .NET Framework 4 dans la liste déroulante Framework. Dans le volet gauche, sous Modèles installés, sélectionnez Visual Basic/Windows. Sélectionnez le modèle Application Windows Forms, donnez le nom TestWSIsValidEmail2 au site et validez. Lorsque le squelette du projet a été construit, lancez la commande Ajouter une référence web dans le menu Projet. Entrez la référence du service dans la boîte de dialogue Ajouter une référence web et cliquez sur Aller à. Au bout de quelques instants, les méthodes du service web apparaissent dans la partie centrale de la boîte de dialogue (voir Figure 25.21).



604

Visual Basic 2010

Figure 25.21 Ajout de la référence ValidateEmail.

Nous utiliserons la méthode suivante : IsValidEmail(Email as String) as Boolean

Cliquez sur Ajouter une référence. Au bout de quelques instants, la nouvelle référence apparaît dans l’Explorateur de solutions (voir Figure 25.22). Figure 25.22 La référence au service web a été ajoutée.



Chapitre 25

Services web

605

Sélectionnez l’objet net.webservicex.www dans l’Explorateur de solutions et basculez sur l’onglet Propriétés. Affectez la valeur Static à la propriété Comportement de l’URL (voir Figure 25.23). Figure 25.23 L’adresse du service web est statique.

Pour utiliser la fonction IsValidEmail(), il suffit maintenant de passer par l’objet My.WebServices. Ajoutez un TextBox, un Button et un Label à 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

Form1

Text

Test de validité d’une adresse e-mail

Button1

Text

Tester e-mail

TextBox1

Text

Label1

Text

Label1

Autosize

False

Double-cliquez sur le bouton 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 My.WebServices.ValidateEmail.IsValidEmail(TextBox1.Text) Then Label1.Text = "Cette adresse e-mail existe." Else Label1.Text = "Cette adresse e-mail n’existe pas." End If End Sub

La première instruction envoie le contenu de la zone de texte TextBox1 à la fonction IsValid Email() du service web ValidateEmail et teste le résultat : If My.WebServices.ValidateEmail.IsValidEmail(TextBox1.Text) Then



606

Visual Basic 2010

Si la valeur retournée par la fonction IsValidEmail() est True, cela signifie que l’adresse e-mail existe et est active : Label1.Text = "Cette adresse e-mail existe."

Si la valeur renvoyée est False, l’adresse e-mail n’existe pas ou n’est pas active : Else Label1.Text = "Cette adresse e-mail n’existe pas."

Pour tester l’application, cliquez sur l’icône Démarrer le débogage de la barre d’outils. Il ne vous reste plus qu’à entrer une adresse e-mail dans le zone de texte et à cliquer sur le bouton Tester e-mail pour tester son existence (voir Figure 25.24). Figure 25.24 L’adresse e-mail spécifiée est opérationnelle.

Ce projet se trouve dans le dossier TestWSIsValidEmail2 après installation des sources de l’ouvrage.



26 Silverlight Dans un souci d’amélioration de l’expérience de l’utilisateur sur le Web, plusieurs grandes sociétés telles que Microsoft, Adobe et Mozilla ont conçu des environnements de développement RIA (Rich Internet Application). Ainsi sont nées (respectivement) Silverlight, Flex et XUL. Adobe est particulièrement bien implanté et détient de grandes parts de marché grâce sa technologie Flash et son environnement de développement Flex. Toutefois, Microsoft possède de nombreux atouts et pourrait devenir à l’avenir un sérieux concurrent. Jugez plutôt :

∑

Les développements se font dans une interface éprouvée et bien connue des développeurs : Visual Studio.

∑

Le mode de développement est des plus classiques : définition d’objets et de leurs caractéristiques physiques, placement dans la zone de travail, mise en place des procédures événementielles correspondantes.

∑

Le contenu graphique de l’interface est entièrement dissocié du code. Il est défini à l’aide de balises XAML (eXtensible Application Markup Language) définies à la main ou à l’aide d’un outil dédié : Expression Blend, ou, de façon plus limitée, Visual Studio.



608

Visual Basic 2010

Les deux mondes (celui des codeurs et celui des graphistes) peuvent cohabiter en ignorant tout l’un de l’autre : les modifications de l’un sont automatiquement détectées et prises en charge par l’autre. ∑ Silverlight est un langage multinavigateur multiplateforme. Il peut dont être utilisé sur tous1 les navigateurs et sur tous les systèmes d’exploitation.

Une première application Les applications Silverlight s’exécutent dans une zone graphique rectangulaire chargée dans le navigateur web par le plugin Silverlight. Cette zone peut occuper toute la page (c’est l’option par défaut dans Visual Studio) ou être limitée à un espace plus réduit. Pour créer votre première application Silverlight, lancez la commande Nouveau/Projet dans le menu Fichier. Dans la boîte de dialogue Nouveau Projet, choisissez .NET Framework 4 dans la liste déroulante. Framework. Sous Modèles installés, cliquez sur Silverlight. Dans la zone centrale, cliquez sur Application Silverlight. Choisissez le dossier de sauvegarde et donnez un nom à l’application, puis cliquez sur OK. Si vous n’avez jamais créé une application Silverlight, le runtime Silverlight Developer n’est certainement pas installé sur votre machine. Ouvrez votre navigateur web, tapez l’URL http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=55b 44da3-e5de-4d2a-8eaf-1155ca6b3207 dans sa barre d’adresse et appuyez sur la touche Entrée. Quelques instants plus tard, un avertissement de sécurité vous informe que vous êtes sur le point de télécharger le runtime Silverlight Developer. Cliquez sur Exécuter et patientez jusqu’à la fin de l’installation, en validant les diverses boîtes de dialogue affichées tout au long du processus de téléchargement et d’installation. Vous serez également amené à installer une mise à jour de Visual Studio pour utiliser Silverlight 4 (voir Figure 26.1). Figure 26.1 Une mise à jour de Visual Studio doit être installée avant de pouvoir créer des applications Silverlight 4.

Cliquez sur le lien contenu dans cette boîte de dialogue, téléchargez puis installez la mise à jour. Une fois ces deux éléments logiciels installés, définissez un nouveau projet de type Application Silverlight. Une boîte de dialogue vous demande si l’application Silverlight doit être 1. Silverlight peut s’exécuter sur tous les systèmes pour lesquels un plugin a été développé. Actuellement, Windows, Mac OS X et Linux.



Chapitre 26

Silverlight

609

hébergée sur un site web. Cochez la case Héberger l’application Silverlight sur un nouveau site web pour que Visual Studio crée les fichiers d’extension ASPX et HTML. Choisissez Projet d’application web ASP.NET dans la liste déroulante puis cliquez sur OK. Figure 26.2 Paramétrage de l’application Silverlight.

Un nouveau projet Silverlight est créé dans Visual Studio. Maintenant, il ne vous reste plus qu’à définir son interface et son comportement, tout comme vous le feriez dans un projet desktop ou ASP.Net. Pour commencer en douceur, vous allez créer une première application qui contiendra un bouton de commande et un label. Un message s’affichera dans le label lorsque l’utilisateur cliquera sur le bouton de commande. Faites glisser un contrôle Button et un contrôle Label de la Boîte à outils sur la zone graphique de l’application MailPage.xaml. Modifiez les propriétés de ces contrôles comme indiqué dans le tableau ci-après. Objet

Propriété

Valeur

Button

Button

Bouton

Button

Content

Cliquez ici

Label

Label

Texte

Label

Content

Double-cliquez sur le bouton et complétez la procédure Bouton_Click() comme suit : Private Sub Bouton_Click(ByVal sender As System.Object, ByVal e As System. „ Windows.RoutedEventArgs) Handles Bouton.Click Texte.Content = "Ce texte est affiché par Silverlight" End Sub



610

Visual Basic 2010

Appuyez sur la touche de fonction F5 pour exécuter l’application. Le navigateur web par défaut s’ouvre et affiche l’application en mode plein écran. La Figure 26.3 représente l’application exécutée dans Internet Explorer 8, après un clic sur le bouton de commande. Figure 26.3 L’application Silverlight, exécutée localement.

Les fichiers générés par Visual Studio Jetons un œil à l’Explorateur de solutions pour découvrir les fichiers générés par Visual Studio (voir Figure 26.4). Figure 26.4 L’Explorateur de solutions, juste après la génération de l’application.

Sous l’entrée SilverlightApplication1.Web, les fichiers SilverlightApplication1TestPage. aspx et SilverlightApplication1TestPage.html correspondent à deux déploiements différents : le premier sur un serveur ASP.NET, fonctionnant sous le contrôle d’IIS (Internet



Chapitre 26

Silverlight

611

Information Server) ; le deuxième sur un serveur quelconque, fonctionnant sous Windows ou sous Linux. Sous l’entrée SilverlightApplication1, le fichier MainPage.xaml contient la description du contenu de la zone d’affichage Silverlight. Ce fichier utilise le langage de description de page XAML (eXtensible Application Markup Language), propre à Silverlight pour décrire les caractéristiques des objets déposés dans la zone d’affichage. Enfin, le fichier MainPage.xaml.vb contient le "code behind", c’est-à-dire le code événementiel Visual Basic appliqué aux objets Silverlight. Examinons le code XAML :

Visual Basic 2010

Recommend Documents

Média, info / Agences de presse

et

Vie pratique / Petites annonces