Autoformation Windev Express 19

WinDev 19 Express
Documentation version 19 (1) - 0614
Version d’évaluation
Diffusion interdite sans l’accord écrit de PC SOFT
Visitez régulièrement le site www.pcsoft.fr, espace téléchargement, pour vérifier si des mises
à jour sont proposées.
Adresse e-mail Support Technique Gratuit : [email protected]
Conseil : Pour recevoir directement des mises à jour intermédiaires et des conseils d’utilisa-
tion, abonnez-vous à la LST (revue trimestrielle + DVD), en français.
Cette documentation n’est pas contractuelle. PC SOFT se réserve le droit de modifier ou de

supprimer tout sujet traité dans ce document.
Tous les noms de produits ou autres marques cités dans cet ouvrage sont des marques déposées par leurs propriétaires respectifs.
© PC SOFT 2014 : Aucune reproduction intégrale ou partielle du présent ouvrage sur quelque support que ce soit ne peut être
effectuée sans l’autorisation expresse de PC SOFT.
Sommaire
Licence
Introduction
Préliminaires.......................................................................................................................................................... 19
Présentation du cours d’auto-formation.............................................................................................................. 19
Comment accéder à l’aide en ligne ?................................................................................................................... 20
Légende des symboles........................................................................................................................................... 22
Si vous connaissez WinDev 18.............................................................................................................................. 23
Que fait-on avec WinDev ?..................................................................................................................................... 23
PARTIE 1 - A la découverte de WinDev
Leçon 1.1. Découvrez WinDev

Présentation........................................................................................................................................................... 28
Lancement de WinDev........................................................................................................................................... 28
Environnement de développement....................................................................................................................... 29
L’éditeur.................................................................................................................................................... 29
La barre de menu (ruban) en détail......................................................................................................... 30
Leçon 1.2. Ma première fenêtre

Présentation........................................................................................................................................................... 33
Ouverture du projet.................................................................................................................................. 33
Ma première fenêtre : saisir et afficher des données.......................................................................................... 34
Présentation............................................................................................................................................. 34
Création de la fenêtre.............................................................................................................................. 34
Saisie et affichage de la valeur saisie..................................................................................................... 36
Améliorations de la fenêtre..................................................................................................................... 39
Leçon 1.3. Des fenêtres plus évoluées

Présentation........................................................................................................................................................... 43
Gérer la saisie d’un numérique pour faire un calcul............................................................................................ 43
Mise en place........................................................................................................................................... 44
Test de la fenêtre...................................................................................................................................... 45
Utilisation d’un champ Combo pour proposer plusieurs possibilités.................................................... 45
Création et utilisation d’une procédure.................................................................................................. 48
Afficher la date et l’heure en temps réel.............................................................................................................. 49
Présentation............................................................................................................................................. 49
Création de la fenêtre.............................................................................................................................. 49
Mise en place du timer............................................................................................................................. 53
Création d’un bouton pour quitter la fenêtre.......................................................................................... 54
Création d’une fenêtre avec un menu................................................................................................................... 56
Décrire le menu........................................................................................................................................ 56
Associer un code aux options de menu.................................................................................................. 59
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Sommaire 3

WinDev : Concepts de base et terminologie........................................................................................................ 61
Concepts de base..................................................................................................................................... 61
Terminologie............................................................................................................................................. 62
Leçon 1.4. Bases de programmation

Introduction.............................................................................................................................................................64
Déclaration des différents types de variables......................................................................................................64
Les différents types de variables............................................................................................................. 64
La déclaration des variables et leur portée............................................................................................ 64
Instructions de base du WLangage....................................................................................................................... 65
Instructions conditionnelles.................................................................................................................... 65
Instructions de boucle............................................................................................................................. 67
Commentaires.......................................................................................................................................... 68
Opérateurs de base du WLangage........................................................................................................................ 69
Les opérateurs logiques.......................................................................................................................... 69
Les opérateurs de comparaison............................................................................................................. 70
Les opérateurs d’indirection.................................................................................................................... 70
Procédures et fonctions......................................................................................................................................... 71
Définition.................................................................................................................................................. 71
Procédure locale...................................................................................................................................... 71
Procédure globale et collection de procédures...................................................................................... 71
Comment choisir si une procédure est globale ou locale ?.................................................................... 72
A propos du passage des paramètres..................................................................................................... 72
Appel d’une procédure............................................................................................................................. 73
Création d’une procédure........................................................................................................................ 73
Exemple pratique......................................................................................................................................74
Un exercice d’application ? A vous de jouer !...........................................................................................74
Traitements des chaînes........................................................................................................................................ 74
Exemple pratique......................................................................................................................................74
Principales manipulations sur une chaîne de caractères...................................................................... 75
Un exercice d’application ? A vous de jouer !.......................................................................................... 77
Traitements des numériques................................................................................................................................ 78
Exemple pratique..................................................................................................................................... 78
Principales manipulations sur les numériques...................................................................................... 78
Traitement des monétaires................................................................................................................................... 80
Détails....................................................................................................................................................... 80
Traitements des dates et des heures.................................................................................................................... 82
Les dates................................................................................................................................................................. 82
Masque de saisie et valeur retournée..................................................................................................... 83
Quel jour sommes-nous ?........................................................................................................................ 85
Quel jour sommes-nous, mais avec le jour et le mois en lettres ?......................................................... 85
Quel est le nombre de jours entre 2 dates ?........................................................................................... 85
Quel est le jour de la semaine d’une date donnée ?............................................................................... 86
Petit exercice pratique............................................................................................................................. 86
Manipulation des variables de type Date............................................................................................... 86
4 Sommaire (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite

Les heures............................................................................................................................................................... 88
Quelle heure est-il ?.................................................................................................................................. 88
Combien de temps s’est-il écoulé entre deux heures ?.......................................................................... 89
Calculs avec des dates et des heures................................................................................................................... 90
Leçon 1.5. Questions / Réponses

Questions / Réponses............................................................................................................................................ 92
Comment visualiser l’élément auquel appartient le traitement en cours ?.......................................... 92
Comment imprimer le code source ?...................................................................................................... 92
Comment faire un "rechercher et/ou remplacer" ?................................................................................ 92
Que signifient les signes "+" ou "-" dans l’éditeur de code ?................................................................... 93
Est-il possible d’identifier la personne qui a écrit une ligne de code ?.................................................. 93
Est-il possible de connaître le numéro d’une ligne de code ?................................................................ 93
Existe-t-il un moyen d’obtenir facilement la syntaxe ou de l’aide sur une fonction ? ........................... 94
Quels sont les raccourcis clavier à connaître sous l’éditeur de code ? ................................................. 94
Comment dialoguer avec l’utilisateur ?................................................................................................... 95
PARTIE 2 - Ma première base de données
Leçon 2.1. Présentation

Présentation du projet réalisé dans cette partie.............................................................................................. 100
Leçon 2.2. WinDev et les bases de données

Présentation........................................................................................................................................................ 102
Les différents modes d’accès aux bases de données...................................................................................... 103
Accès Natif..............................................................................................................................................103
Accès ODBC direct..................................................................................................................................103
Accès OLE DB.........................................................................................................................................104
Accès ODBC via OLE DB.........................................................................................................................104
HFSQL................................................................................................................................................................... 104
Leçon 2.3. Projet et analyse

Présentation........................................................................................................................................................ 106
Création du projet................................................................................................................................................ 106
Création de l’analyse........................................................................................................................................... 108
Création de la description des fichiers de données.......................................................................................... 109
Création d’un fichier de données : utilisation d’un fichier pré-défini...................................................110
Création d’un fichier de données : création du fichier et des rubriques..............................................111
Importation d’un fichier CSV..................................................................................................................115
Importation directe de fichiers de données existants..........................................................................118
Création des liaisons........................................................................................................................................... 119
Génération de l’analyse...................................................................................................................................... 125

Leçon 2.4. Le RAD complet
Qu’est-ce que le RAD ? ....................................................................................................................................... 128
Génération du RAD.............................................................................................................................................. 129
Test de l’application............................................................................................................................................ 133
Modification rapide : Verrouillage de l’application........................................................................................... 134
PARTIE 3 - Application complète avec données

Présentation de l’application réalisée dans cette partie................................................................................. 138
Projets fournis...................................................................................................................................................... 138
Projet exemple........................................................................................................................................138
Projets corrigés.......................................................................................................................................139
Leçon 3.2. Fenêtres d’ajout et de modification

Présentation........................................................................................................................................................ 142
Création d’une fenêtre listant les produits........................................................................................................ 142
Création de la fenêtre............................................................................................................................142
Création des champs.............................................................................................................................144
Test de la fenêtre.................................................................................................................................... 147
Création d’une fenêtre "Fiche produit".............................................................................................................. 149
Création des champs de saisie.............................................................................................................149
Création des boutons.............................................................................................................................152
Améliorations de l’interface de la fenêtre.............................................................................................152
Affichage de la fiche depuis la liste des produits..................................................................................156
Gestion de la modification d’un produit............................................................................................................ 157
Modification de l’image du produit........................................................................................................157
Validation des modifications du produit...............................................................................................159
Test de la modification d’un produit......................................................................................................160
Création d’un nouveau produit............................................................................................................................161
Ajout d’un bouton................................................................................................................................... 161
Ajout dans le fichier de données...........................................................................................................162
Test de l’ajout d’un produit....................................................................................................................162
Visualiser les enregistrements saisis....................................................................................................164
Leçon 3.3. Recherche simple et parcours des enregistrements

Présentation.........................................................................................................................................................167
Modification de la fenêtre : utilisation d’un champ Onglet.............................................................................. 168
Création du champ Onglet.....................................................................................................................168
Modifications du champ Onglet.............................................................................................................169
Mise en place de la recherche.............................................................................................................................172
Zone d’affichage des informations trouvées........................................................................................ 172
Recherche à l’identique......................................................................................................................... 174
Recherche générique............................................................................................................................. 178
Parcours des fiches................................................................................................................................180
Test de la fenêtre....................................................................................................................................183

Leçon 3.4. Recherche multicritère
Présentation........................................................................................................................................................ 185
Création de la requête pour rechercher les commandes................................................................................ 186
Création de la requête............................................................................................................................186
Test de la requête...................................................................................................................................188
Utilisation de paramètres dans la requête...........................................................................................189
Test de la requête paramétrée..............................................................................................................192
Création de l’interface pour réaliser une recherche multicritère.................................................................... 192
Modifications du champ Onglet.............................................................................................................192
Création des champs de paramétrage des critères et affichage du résultat......................................194
Leçon 3.5. Imprimer le contenu d’un champ Table

Présentation........................................................................................................................................................ 206
Impression du contenu d’un champ Table.........................................................................................................207
Impression directe via la FAA (Fonctionnalité automatique de l’application).....................................207
Création d’un état automatique sur un champ Table...........................................................................209
Leçon 3.6. Imprimer une commande

Présentation........................................................................................................................................................ 212
Création de l’état "Bon de commande"............................................................................................................. 212
Création de la requête............................................................................................................................213
Création de l’état basé sur une requête................................................................................................ 216
Modifications de l’état "Bon de commande"........................................................................................222
Affichage de l’état imprimé depuis une option de menu................................................................................. 224
Création du menu contextuel................................................................................................................224
Association du menu contextuel au champ Table................................................................................225
Test de l’impression...............................................................................................................................226
Leçon 3.7. Imprimer une liste de clients

Présentation........................................................................................................................................................ 228
Création de l’état................................................................................................................................................. 228
Lancement de l’impression d’un état par programmation............................................................................. 235
Leçon 3.8. Statistiques : champs Graphe et Tableau Croisé Dynamique

Présentation........................................................................................................................................................ 239
Affichage de données dans un champ Graphe................................................................................................. 239
Sélection des données à afficher dans le champ Graphe...................................................................239
Création du champ Graphe....................................................................................................................242
Création de tableaux de synthèse grâce au champ Tableau Croisé Dynamique........................................... 246
Création du champ Tableau Croisé Dynamique................................................................................... 247
Test du Tableau Croisé dynamique........................................................................................................250
Leçon 3.9. Envoyer un email

Présentation........................................................................................................................................................ 253
Une fenêtre pour envoyer des emails................................................................................................................ 254
Création des champs de paramétrage de l’envoi.................................................................................254
Création des champs permettant de saisir les caractéristiques de l’email........................................256
Envoi de l’email......................................................................................................................................259
Améliorations de la fenêtre.................................................................................................................................261
Fermeture de la fenêtre.........................................................................................................................261
Mise en forme.........................................................................................................................................261
Ouverture non modale de la fenêtre.....................................................................................................262
Leçon 3.10. Identifier l’utilisateur : le groupware utilisateur

Présentation........................................................................................................................................................ 265
Intégrer le groupware utilisateur........................................................................................................................ 265
Configurer le groupware utilisateur................................................................................................................... 269
Création des utilisateurs et des groupes..............................................................................................269
Définition des droits............................................................................................................................... 271
Test de l’application...............................................................................................................................273
Débrancher la gestion du groupware utilisateur...............................................................................................274
Leçon 3.11. Réutilisez du code grâce aux composants externes

Présentation.........................................................................................................................................................276
Travail en équipe.................................................................................................................................... 276
Les projets volumineux.......................................................................................................................... 276
Les bases de données accédées par plusieurs projets....................................................................... 277
Les traitements utilisés dans plusieurs projets.................................................................................... 277
La possibilité de diffuser une fonctionnalité ou un ensemble de fonctionnalités.............................. 277
Composant externe multiproduits......................................................................................................... 277
Etape par étape................................................................................................................................................... 278
Etape 1 : Création d’un composant externe.........................................................................................278
Etape 2 : Utilisation du composant externe..........................................................................................283
Distribution d’un composant externe................................................................................................................ 286
Distribution simple.................................................................................................................................286
Distribution professionnelle..................................................................................................................287
Leçon 3.12. Consommer un Webservice

Présentation........................................................................................................................................................ 289
Exemple pratique...................................................................................................................................289
Importation d’un Webservice............................................................................................................................. 289
Consommation d’un Webservice....................................................................................................................... 292
Leçon 3.13. Surveillez l’évolution de vos applications

Présentation........................................................................................................................................................ 295
Le tableau de bord............................................................................................................................................... 295
Widget "Projet"........................................................................................................................................296
Widget "GDS"..........................................................................................................................................296
Widget "Audit statique et Compilation".................................................................................................296
Widget "Audit dynamique".....................................................................................................................296
Widget "Performances"..........................................................................................................................296
Widget "Sélection rapide"......................................................................................................................297
Les Widgets en relation avec les Centres de Contrôle..........................................................................297
Tests automatiques............................................................................................................................................. 298

Leçon 3.14. Déployer l’application
Présentation........................................................................................................................................................ 303
Création de l’exécutable..................................................................................................................................... 303
Création de l’installation......................................................................................................................................307
Installation d’une application..............................................................................................................................310
Les différents types de déploiement..................................................................................................................311
Présentation........................................................................................................................................... 311
Installation avec mise à jour réseau...................................................................................................... 311
Installation avec mise à jour Internet.................................................................................................... 313
Leçon 3.15. Diffusez "Etats & Requêtes" avec vos applications

Lancement du logiciel "Etats & Requêtes"........................................................................................................316
Paramétrage du projet........................................................................................................................... 317
Paramétrage de l’analyse...................................................................................................................... 317
Paramétrage des états.......................................................................................................................... 318
Paramétrage des requêtes.................................................................................................................... 319
Création de l’exécutable et diffusion de l’application.......................................................................... 319
Installation de l’application...................................................................................................................321
Test de l’application...............................................................................................................................322
Conclusion............................................................................................................................................................ 324
Leçon 3.16. Gérer le multilingue

Qu’est-ce qu’une application multilingue ?....................................................................................................... 326
Choix des langues du projet................................................................................................................................ 326
Internationalisation de l’analyse........................................................................................................................ 328
Internationalisation des éléments du projet......................................................................................................331
Internationalisation d’une image..........................................................................................................332
Internationalisation des champs...........................................................................................................333
Internationalisation d’un message de programmation.......................................................................333
Internationalisation des menus............................................................................................................334
Les outils de traduction....................................................................................................................................... 335
Saisie directe des traductions...............................................................................................................335
Traduction avec WDMSG et WDTRAD...................................................................................................336
Autres éléments à traduire : les messages du framework...................................................................336
Programmation du changement de langue...................................................................................................... 337
Ajout d’une option de menu..................................................................................................................337
Programmation......................................................................................................................................337
Test du projet..........................................................................................................................................338

Leçon 3.17. GDS
Introduction.......................................................................................................................................................... 340
GDS (Gestionnaire de Sources).......................................................................................................................... 340
Principe du GDS.....................................................................................................................................340
Création de la base de sources............................................................................................................. 341
Intégration d’un projet dans le GDS................................................................................................................... 342
Ajouter le projet dans le GDS.................................................................................................................342
Ouverture du projet depuis le GDS........................................................................................................345
Configuration du GDS............................................................................................................................346
Manipulation du projet via le GDS...................................................................................................................... 348
Modification d’un paramètre du projet.................................................................................................348
Modification d’une fenêtre du projet.....................................................................................................350
Modification de l’élément extrait...........................................................................................................351
Réintégration de l’élément extrait.........................................................................................................352
Synchronisation du projet......................................................................................................................353
Mode déconnecté (ou nomade)............................................................................................................354
Administrateur du GDS..........................................................................................................................355
Déconnexion du GDS.............................................................................................................................356
Conclusion............................................................................................................................................................ 356
PARTIE 4 - Administrer une base HFSQL Client/Serveur
Leçon 4.1. Introduction

Présentation........................................................................................................................................................ 360
Pourquoi passer une application en mode HFSQL Client/Serveur ?................................................................361
Leçon 4.2. Mise en place d’une application Client/Serveur

Présentation........................................................................................................................................................ 363
Installation d’un serveur HFSQL local................................................................................................................ 363
Création d’une application en mode HFSQL Client/Serveur........................................................................... 363
Adaptation d’une application HFSQL Classic pour gérer le mode Client/Serveur......................................... 364
Présentation...........................................................................................................................................364
Migration de l’exemple...........................................................................................................................364
Fonctionnalités disponibles en mode HFSQL Client/Serveur......................................................................... 368
Leçon 4.3. Administrer une base de données Client/Serveur

Présentation........................................................................................................................................................ 370
Configuration des postes.................................................................................................................................... 370
Le Centre de Contrôle HFSQL............................................................................................................................. 370
Créer un compte utilisateur dans le Centre de Contrôle HFSQL...................................................................... 372
Sauvegarder la base de données........................................................................................................................376
Conclusion.............................................................................................................................................................377
Leçon 4.4. Installation en clientèle

Présentation........................................................................................................................................................ 379
Lancement de l’assistant de création d’installation........................................................................................ 379

PARTIE 5 - Optimiser et déboguer un projet

Présentation........................................................................................................................................................ 384
Ouverture du projet................................................................................................................................384
Leçon 5.2. Audits du projet

Qu’est-ce qu’un audit ? ....................................................................................................................................... 386
Audit statique....................................................................................................................................................... 386
Procédure non exécutée........................................................................................................................388
Elément orphelin....................................................................................................................................389
Requête à optimiser...............................................................................................................................390
Nettoyage du projet................................................................................................................................391
Audit dynamique................................................................................................................................................. 391
Leçon 5.3. Analyseur de performances

Présentation........................................................................................................................................................ 396
Lancer l’analyseur de performances................................................................................................................. 396
Analyse du résultat...............................................................................................................................................397
Leçon 5.4. Débogage d’un projet

Présentation....................................................................................................................................................... 403
Utiliser le débogueur........................................................................................................................................... 403
PARTIE 6 - Programmation avancée

Présentation........................................................................................................................................................ 412
Exemple pratique................................................................................................................................... 412
Leçon 6.2. Gestion automatique des erreurs

Présentation.........................................................................................................................................................415
Fonctionnement..................................................................................................................................... 415
Mise en place......................................................................................................................................... 415
Types d’erreurs concernées................................................................................................................... 416
Gestion automatique des erreurs : un exemple didactique..............................................................................416
Leçon 6.3. Manipuler des fichiers externes

Présentation........................................................................................................................................................ 421
Manipulation des fichiers texte ou CSV............................................................................................................. 421
Présentation...........................................................................................................................................421
Manipulation des répertoires............................................................................................................................. 422

Manipulation des fichiers XML........................................................................................................................... 423
Présentation...........................................................................................................................................423
Manipulation des fichiers XLS............................................................................................................................ 424
Exemples pratiques...............................................................................................................................424
Leçon 6.4. Compilation dynamique

Présentation........................................................................................................................................................ 427
Exemple................................................................................................................................................................ 427
Leçon 6.5. Evénement Windows

Introduction.......................................................................................................................................................... 430
Traitements optionnels proposés par WinDev.................................................................................................. 430
Evénements de Windows.....................................................................................................................................431
Exemple : Détecter le clic sur une liste..................................................................................................432
Leçon 6.6. Les threads

Définition.............................................................................................................................................................. 435
Exemple................................................................................................................................................................ 435
Leçon 6.7. Les sockets

Présentation........................................................................................................................................................ 437
Application Serveur : cas d’un serveur simplifié............................................................................................... 437
Création de la socket..............................................................................................................................437
Echange de données.............................................................................................................................437
Fermeture de la socket..........................................................................................................................438
Application Cliente.............................................................................................................................................. 438
Connexion au serveur............................................................................................................................438
Echange de données.............................................................................................................................438
Fin de communication...........................................................................................................................438
Exemple pratique................................................................................................................................................ 439
Test de l’exemple....................................................................................................................................439
Analyse du code utilisé..........................................................................................................................439
Leçon 6.8. Le FTP

Présentation........................................................................................................................................................ 442
Se connecter à un serveur FTP........................................................................................................................... 442
Envoyer un fichier................................................................................................................................................ 443
Lister les fichiers présents sur un serveur FTP.................................................................................................. 444
Récupérer un fichier............................................................................................................................................ 445
Se déconnecter d’un serveur FTP....................................................................................................................... 445

Leçon 6.9. La POO
Concepts................................................................................................................................................................447
Les classes.............................................................................................................................................447
Les objets...............................................................................................................................................447
Les membres..........................................................................................................................................447
Les méthodes.........................................................................................................................................447
Notion d’héritage....................................................................................................................................447
Constructeur et Destructeur..................................................................................................................448
Encapsulation de données....................................................................................................................448
Exemple..................................................................................................................................................448
Créer un programme orienté objet........................................................................................................448
Exemple simple................................................................................................................................................... 449
Déclarer une classe...............................................................................................................................449
Décrire les méthodes.............................................................................................................................450
Déclarer et manipuler les objets...........................................................................................................451
Diagramme UML................................................................................................................................................. 452
Conclusion

Licence
Attention: En installant et en utilisant un logiciel WINDEV version Express vous avez accepté les
termes de la licence suivante :
Le LOGICIEL désigne le droit d’utilisation du logiciel WinDev, dans cette version de démonstration
(appelée également Version Express, Version d’évaluation ou Version limitée).
L’EVALUATEUR représente la personne (physique ou morale) installant et / ou utilisant le logiciel.
Une APPLICATION désigne un programme ou un ensemble de programmes réalisé avec le LOGI-
CIEL.
1. Version Express
Ce LOGICIEL est proposé ici dans une version de "démonstration".
Cette version de démonstration est exclusivement destinée au test de ses fonctionnalités, et/ou à
une utilisation par des étudiants d’un établissement reconnu par l’état pendant la durée de leurs
études, en dehors de toute utilisation commerciale, partielle ou totale.
De nombreuses fonctionnalités sont bridées, limitées ou différentes de la version "commerciale".
Pour créer des applications destinées à être utilisées, il est nécessaire d’acquérir et d’utiliser une
version "commerciale" et non cette version de démonstration et de test.
Il est strictement interdit de créer en totalité ou en partie une ou des applications dans un autre
but que le TEST du LOGICIEL, ou la réalisation de Travaux Pratiques dans le cadre d’études.
L’utilisation des applications créées dans un but autre que le test de courte durée est interdite.
Toute utilisation autre que l’essai du logiciel, et/ou une utilisation pour une durée supérieure à
celle autorisée, constitue une utilisation illégale qui donnera lieu à des poursuites.
Il est interdit de dupliquer et diffuser ce logiciel, même dans cette version de démonstration, sans
l’accord écrit de PC SOFT.
2. Licence
Ce LOGICIEL doit être utilisé sur une et une seule machine par une et une seule personne à un
instant donné. Le LOGICIEL est déclaré utilisé dès qu’il se trouve en "mémoire centrale" (égale-
ment appelée RAM) d’un ordinateur.
Ce logiciel ne peut être utilisé que pour la durée autorisée.
3. Propriété du LOGICIEL
Ce logiciel est la propriété de PC SOFT. L’EVALUATEUR a simplement le droit d’utiliser ce LOGICIEL
selon les conditions définies.
4. Documentation
La duplication de la documentation, en totalité ou en partie, est strictement interdite.
5. Utilisation
L’EVALUATEUR doit utiliser le LOGICIEL pour l’usage pour lequel il est diffusé. Il est interdit de
modifier ou tenter de modifier ce LOGICIEL, de désassembler ou tenter de désassembler ce LOGI-
CIEL. Il est interdit d’enlever ou de tenter d’enlever les mentions de copyright pouvant apparaître
et/ou étant contenues dans le LOGICIEL.
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Licence 15

La location ou le prêt de ce LOGICIEL est interdit.
Il est interdit d’utiliser WinDev "Express" pour créer et diffuser tout ou partie d’outil de développe-
ment, de LOGICIEL de création d’applications, de générateur de programmes, ou de tout LOGICIEL
de même nature que WinDev lui-même. Interrogez-nous en cas de doute.
Les fonctions de génération de code JAVA ne peuvent être utilisées que dans le cadre de la mani-
pulation habituelle du LOGICIEL, dans le but de créer une APPLICATION autonome.
Le code généré par WinDev "Express" ne doit pas être réutilisé dans d’autres logiciels ou disposi-
tifs de création de logiciel. Le code généré avec cette fonctionnalité ne peut pas être inclus dans
un logiciel, payant ou gratuit, qui ferait concurrence à WINDEV, WINDEV MOBILE ou WEBDEV, en
totalité ou en partie.
Les photographies, illustrations et images contenues dans les exemples, modèles, ambiances et
gabarits ne peuvent être utilisées que dans leur implantation originelle. Toute utilisation, repro-
duction, représentation, adaptation ou copie, en totalité ou en partie, sous quelque forme que ce
soit, par tout procédé existant ou à venir et en quelque lieu que ce soit est interdite.
Les images et les animations disponibles à partir du catalogue d’images doivent être utilisées ex-
clusivement dans des APPLICATIONS réalisées avec le LOGICIEL. La vente ou la distribution de ces
images est interdite. L’utilisation dans d’autres logiciels ou sites que l’APPLICATION est interdite.
Les images ne peuvent être séparées de l’APPLICATION qui les utilise.
6. Absence de responsabilité
Le LOGICIEL et la documentation qui l’accompagne sont fournis en l’état, SANS AUCUNE GARAN-
TIE D’AUCUNE SORTE. PC SOFT ne saurait être tenu pour responsable pour tout dommage de
quelque nature que ce soit, et en particulier en cas de perte ou détérioration des données, en
cas de perte financière, en cas de perte d’exploitation, en cas de divergence des informations
contenues dans la documentation avec le comportement du LOGICIEL, en cas de comportement
du LOGICIEL différent de celui attendu. L’EVALUATEUR est seul et unique responsable du fonction-
nement et du support des programmes qu’il aura réalisé avec le LOGICIEL.
7. Cas particuliers
Fonctionnalités liées à des services
Avertissement : avant d’utiliser une fonctionnalité reliée à des services ou des applications, et
en particulier à Google, nous vous conseillons vivement de vous reporter à la licence d’utilisation
de ce service ou de cette application. Certaines restrictions peuvent s’appliquer. Le contenu des
licences peut varier avec le temps.
PC SOFT dégage toute responsabilité de l’usage qui peut être fait des fonctions d’accès natif. Il
vous appartient de vérifier que l’usage que vous faites respecte la licence du fournisseur de ser-
vice.
8. Logiciels tiers
Polices installées
La police "Open Sans" installée et utilisée par le LOGICIEL est soumise à la licence "Apache Li-
cense". Le texte de cette licence est présent dans le sous-répertoire "Aide" du LOGICIEL.
16 Licence (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite

Acceptation de la licence :
Le fait de conserver et d’utiliser ce logiciel indique la compréhension et l’acceptation des termes
de cette licence.
Ce contrat ne peut pas être modifié, sauf par un courrier original paraphé de la direction générale
de PC SOFT.
Ce contrat de licence est régi par le droit français; tout litige qui pourrait en résulter sera de la
compétence exclusive des tribunaux du siège social de PC SOFT.
PC SOFT,
3, rue de Puech Villa
BP 44 408
34197 Montpellier Cedex 5
France
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Licence 17

18 Licence (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite
Introduction
Préliminaires
Attention : Ce manuel est un cours d’auto-formation. Il est conseillé de consulter l’aide en ligne
lorsque vous utilisez WinDev.
Le manuel du cours d’auto-formation a pour objectif de vous faire découvrir WinDev, de vous fami-
liariser avec les éditeurs et de vous apprendre les concepts de WinDev.
Ce manuel n’est PAS exhaustif des possibilités de WinDev.
Consacrez au moins quelques heures pour suivre ce cours et pour apprendre WinDev : vous les
rentabiliserez vite !
Si vous essayez de démarrer le développement d’une application sans avoir suivi ce cours, vous
perdrez du temps, beaucoup plus que deux jours.
Le cours a été conçu pour être suivi de deux façons :
• soit vous suivez tous les exercices détaillés dans les leçons du cours (méthode conseillée).
• soit, si vous êtes pressé et disposez d’une expérience significative, vous pouvez uniquement
le lire sans exécuter les exercices, tous les exercices sont illustrés. Toutefois, pour que les
concepts soient plus rapidement assimilés, il est préférable de suivre les manipulations.
WinDev évoluant en permanence, les copies des fenêtres illustrant le cours peuvent être diffé-
rentes de celles du produit que vous possédez.
Présentation du cours d’auto-formation

Le cours d’auto-formation a été conçu pour vous permettre d’apprendre progressivement à utiliser
WinDev. En suivant ce cours :
• d’une part, vous découvrirez les concepts importants expliqués d’une façon informelle ; en
effet dans ce cas, il s’agit de concepts à acquérir et à comprendre.
• d’autre part, vous serez amené à effectuer des manipulations pour illustrer les concepts qui
viennent d’être expliqués.
Au fil de la lecture du cours, si vous voulez approfondir un concept ou si vous voulez avoir plus
de détails sur une fonction de programmation, consultez l’aide en ligne (accessible directement
depuis les éditeurs ou dans le guide).
La taille d’une leçon n’est pas obligatoirement proportionnelle à son intérêt ...
N’oubliez pas d’étudier ensuite les exemples livrés avec WinDev : ils sont très didactiques !
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Introduction 19

Depuis l’impression de ce document, le cours d’auto-formation a peut-être évo-
lué. N’hésitez pas à consulter la version électronique du cours d’auto-formation
Notes
(fichier PDF accessible directement dans le menu de WinDev : sous le volet "Ac-
cueil", dans le groupe "Aide en ligne", déroulez "Guide d’Auto-formation" et sélec-
tionnez l’option "Guide d’Auto-formation (PDF)".
Comment accéder à l’aide en ligne ?

L’aide en ligne de WinDev permet de consulter les informations détaillées concernant les 2500
fonctions du WLangage. Elle contient également l’aide des éditeurs, des champs, des astuces, ...
L’aide en ligne est disponible à tout moment dans WinDev :
• Sous l’éditeur de code, une aide spécifique est directement accessible pour chaque nom de
fonction sélectionné, grâce à la touche [F1].
• Chaque fenêtre de dialogue affichée par WinDev propose un bouton permettant d’accéder à
la page d’aide correspondante.
• Le menu d’aide des éditeurs (option "Aide" disponible sous le volet "Accueil", dans le groupe
"Aide en ligne" du menu de WinDev) vous permet de lancer l’aide en ligne.
L’aide peut être affichée :

• dans un "browser d’aide" spécifique :
20 Introduction (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite

• dans un navigateur Internet, si vous avez accès à Internet :
L’aide en ligne de WinDev, WebDev et WinDev Mobile sur Internet est accessible
depuis n’importe quel poste disposant d’un accès Internet, sans que le produit
Notes
soit forcément installé. Cette aide est mise à jour régulièrement.

Chaque internaute peut ajouter des commentaires sur les pages de documenta-
tion : explications personnelles, exemples, liens, ...

Pour lancer directement l’aide en ligne Internet depuis le produit :
1. Sous le volet "Accueil", dans le groupe "Environnement", déroulez "Options" et sélectionnez
l’option "Options générales de WinDev".
2. Dans l’onglet "Aide", sélectionnez :
• le mode d’accès à la base d’aide.
• le contenu de l’aide : aide commune à WinDev, WebDev et WinDev Mobile ou aide du pro-
duit en cours d’utilisation.
Légende des symboles
Ce symbole indique la durée de la leçon et de ses manipulations. Attention, le temps

réel peut varier selon votre expérience.
Un exemple est disponible pour compléter le cours. Les exemples sont disponibles
dans le volet "Assistants, Exemples et Composants" de WinDev.
Ce symbole présente une "Astuce" : la lecture du texte associé est vivement conseil-
lée.
Ce symbole présente un "Avertissement" : la lecture du texte associé est primordiale.
Ce symbole présente une "Note" : la lecture du texte associé est conseillée.
Ce symbole présente le résultat d’un "Test" : la lecture du texte associé est conseillée.

Si vous connaissez WinDev 18...
Si vous connaissez déjà WinDev 18, le suivi de ce nouveau cours ne pourra être que bénéfique :
ce sera une bonne occasion de "réviser" les possibilités de WinDev !
Que fait-on avec WinDev ?

WinDev est un AGL (Atelier de Génie Logiciel). Il vous permet de développer des applications dans
tous les domaines :
• Gestion des stocks, inventaire, traçabilité des marchandises
• Réglage et suivi de machines sur chaîne de production
• Prise de commandes pour traitement rapide sur un lieu de vente de passage (foire, école,
stand, ...)
• Fiches clients
• Outil d’aide à la prise de décision d’urgence sur téléphone portable
• Vérification d’identité des visiteurs d’une manifestation : salon, présentation de produits, ...
• Médecin ou vétérinaire en déplacement
• Prises d’informations sur un lieu de passage : salon professionnel, rue pour un sondage,
stade, ...
WinDev est un outil de développement complet qui intègre tous les outils nécessaires au cycle de
réalisation d’une application.
Contrairement à d’autres langages de développement traditionnels, il n’est pas nécessaire de
chercher et de rajouter des modules pour pouvoir concevoir, tester et installer une application.
Le L5G (Langage de 5ème Génération) de WinDev, le WLangage, vous étonnera par sa simplicité :
quelques heures suffisent pour appréhender le langage, une semaine suffit en général pour maî-
triser toute sa puissance !
Comme il est en français, le WLangage (disponible également en anglais) vous fera gagner du
temps !


PARTIE 1
A la découverte
de WinDev
Leçon 1.1. Découvrez WinDev
Ce que vous allez apprendre dans cette leçon ...
• Lancement de WinDev
Durée estimée : 5 mn
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Partie 1 : A la découverte de WinDev 27
Présentation
WinDev est un AGL (Atelier de Génie Logiciel) complet permettant de développer des applications
Windows dans de nombreux domaines : gestion, industrie, médical, ... Les applications dévelop-
pées peuvent inclure l’accès à des informations stockées dans des bases de données.
Tout au long de ce cours d’auto-formation, vous allez apprendre à créer vos applications (avec ou
sans base de données) et à les enrichir en utilisant les nombreuses fonctionnalités proposées par
WinDev.
Lancement de WinDev
Lancez WinDev 19 (si ce n’est déjà fait).

Si vous n’avez jamais lancé WinDev 19, un assistant de bienvenue se lance :
• Si vous possédiez une ancienne version de WinDev, cet assistant permet de récupérer les
configurations existantes.
• Si vous êtes nouvel utilisateur, cet assistant permet de paramétrer votre environnement.
Vous pouvez ainsi choisir la configuration écran utilisée et paramétrer les Centres de
Contrôle. Pour plus de détails, consultez l’aide en ligne.
Si vous avez déjà lancé WinDev 19, identifiez-vous si nécessaire. L’environnement de
développement se lance. La fenêtre de bienvenue apparaît.
Arrêtons-nous un instant sur l’environnement de développement de WinDev.
28 Partie 1 : A la découverte de WinDev (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite
Environnement de développement
L’éditeur
L’environnement de développement de WinDev est constitué d’une interface spécifique et de plu-
sieurs éditeurs permettant de créer les différents éléments de vos applications.
Ainsi, l’éditeur de fenêtres permet de créer des fenêtres, l’éditeur d’états permet de créer des
états, ...
Tous les éditeurs utilisent le même environnement :
1. Menu des éditeurs, affiché sous forme de ruban (nous allons voir sa manipulation dans le para-
graphe suivant).
2. Editeur en cours (ici, éditeur de fenêtres). Cet espace permet de visualiser de manière WY-
SIWYG (What You See Is What You Get) l’élément en cours de création ou de modification.
3. Volets. L’interface de WinDev dispose de plusieurs volets (horizontaux et verticaux) permettant

d’accéder rapidement à différents types d’informations.
Quelques exemples :
• Le volet "Explorateur de projet" (ici, affiché à droite) permet de lister tous les éléments du projet
par catégorie.
• Le volet "Assistant, Exemples et Composant" (ici, affiché en bas) permet d’accéder rapidement à
des exemples complets, des fenêtres d’exemples, des champs facilement intégrables dans vos
applications.
Si nécessaire, ces volets peuvent être cachés rapidement en utilisant la combinaison de touches
[CTRL] + [W].
4. Barre des documents ouverts. Cette barre permet de visualiser rapidement tous les éléments
ouverts. Un simple clic sur le bouton correspondant à l’élément l’affiche dans son propre éditeur.
La barre de menu (ruban) en détail

La barre de menu de WinDev est présentée sous forme d’un ruban. Ce ruban est composé de
volets dans lesquels sont regroupées les différentes options des éditeurs.
Nous allons détailler ici, les différents éléments importants du ruban, ainsi que la manière dont
nous le manipulerons dans ce cours.
Les différents éléments du ruban

Le ruban est constitué de 3 zones :
• la zone des boutons, à gauche.
• la zone des volets en haut.
• la zone des options.
Voyons ces différentes zones en détail.
La zone des boutons

La zone des boutons regroupe principalement les boutons d’accès rapide.
Ces boutons permettent d’effectuer les opérations les plus courantes, bien
souvent communes à tous les éditeurs : enregistrer, ouvrir, créer, ...
Les 3 boutons en haut de cette zone sont également spécifiques :
• Le logo du produit permet d’afficher la fenêtre "A propos", les perso-menus
(menus personnalisés) et les menus déroulants de l’ancienne interface des
éditeurs (version 17 et antérieure).
• Les 2 logos suivants permettent de retrouver les barres d’outils et les me-
nus déroulants de l’ancienne interface des éditeurs (version 17 et antérieure).
La zone des volets
Les différents volets du ruban permettent d’accéder aux options des différents éditeurs. Plusieurs
types de volets sont disponibles :
• le volet en cours : L’onglet du volet apparaît en gris clair et un trait orange est affiché en haut
de l’onglet.
• les volets contextuels, spécifiques à l’élément en cours : Le nom du volet est affiché en orange.
• les volets disponibles : Le nom du volet apparaît en blanc.
La zone des options
En fonction du volet sélectionné, les options affichées dans le ruban diffèrent. Plusieurs types
d’options sont disponibles :
• Options à cocher
• Boutons à cliquer
• Boutons à flèche permettant de dérouler des options. Deux types de boutons à flèche sont dis-
ponibles :
• les boutons à flèche permettant uniquement de dérouler un menu
• les boutons à flèche permettant soit de dérouler un menu (clic sur la flèche), soit d’effectuer
une action par défaut (clic sur l’icône du bouton).
Les options sont rassemblées par groupe. Chaque groupe d’options a un nom et peut avoir un
bouton de regroupement . Ce bouton permet d’effectuer une action spécifique selon le groupe
en cours : affichage de la description de l’élément en cours, affichage de l’aide, ...
Dans ce cours, pour désigner une option de menu, nous parlerons donc de volets et de groupes.
Par exemple :
Pour afficher l’aide, sous le volet "Accueil", dans le groupe "Aide en ligne", cliquez sur "Aide".
Leçon 1.2. Ma première fenêtre
• Comment créer une fenêtre

• Comment saisir un texte et l’afficher
Présentation
Pour commencer à utiliser WinDev, nous allons simplement créer quelques fenêtres.
Les fenêtres permettent d’afficher ou de saisir à l’écran des informations. L’uti-

Note
lisateur peut agir directement sur les fenêtres par l’intermédiaire de champs, de
boutons, ...
Ces quelques exemples vous permettront de connaître les bases de la programmation en WinDev
et vous permettront ensuite d’aborder des sujets plus complets.
Les leçons de cette première partie vont vous permettre de :
• créer des fenêtres simples,
• manipuler des chaînes, des numériques, des monétaires,
• manipuler des dates et des heures.
Ouverture du projet
Lancez WinDev 19 (si ce n’est déjà fait). Si nécessaire, fermez le projet en cours pour faire
apparaître la fenêtre de bienvenue.
Ouvrez le projet "WD Mes Premières Fenêtres".
Pour cela, dans la fenêtre de bienvenue, cliquez sur "Cours d’auto-formation" et sélectionnez
le premier projet "Mes premières fenêtres (Exercice)".
Astuce : si la fenêtre de bienvenue n’est pas affichée, sous le volet "Accueil", dans le groupe
"Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez l’option "Mes premières
fenêtres (Exercice)".
Important
Dans cette partie, nous nous concentrons sur la création de fenêtres simples. Le
projet "WD Mes Premières Fenêtres" est un projet vide, déjà créé. La création de
projet sera abordée dans une prochaine leçon.
Un projet corrigé est disponible. Ce projet contient les différentes fenêtres créées
dans cette leçon. Pour ouvrir le projet corrigé :
Corrigé
• dans la fenêtre de bienvenue, cliquez sur "Cours d’auto-formation" et sélection-

nez le projet "Mes premières fenêtres (Corrigé)".
• sous le volet "Accueil", dans le groupe "Aide en ligne", déroulez "Guide d’Auto-
formation" puis sélectionnez "Mes premières fenêtres (Corrigé)".
Ma première fenêtre : saisir et afficher des données
Présentation
Voici la fenêtre que vous allez créer :
Cette fenêtre permet à l’utilisateur de saisir son prénom et d’afficher un message de bienvenue
grâce au bouton "Afficher".
Vous pouvez être tenté de dire que c’est trop simple, trop basique, mais nous vous conseillons
de réaliser cette fenêtre. Vous risquez d’être surpris par la facilité et l’intuitivité de l’éditeur de
WinDev. De plus, cette fenêtre vous permettra de découvrir des concepts fondamentaux pour la
suite de ce cours.
Création de la fenêtre
Pour créer la fenêtre :

1. Cliquez sur parmi les boutons d’accès rapide du menu de WinDev :
2. Une fenêtre en forme de roue s’affiche. Cette fenêtre permet de créer tous les éléments
pouvant être associés à un projet.
3. Cliquez sur "Fenêtre". L’assistant de création de fenêtres s’affiche.
4. Sélectionnez "Vierge" dans la liste des fenêtres "standard" affichée sur la gauche. Dans la
liste des gabarits présente sur la droite, le gabarit "Elegant" est sélectionné par défaut. Vous
pouvez choisir un autre gabarit proposé dans la liste.
Les gabarits permettent de créer rapidement des interfaces professionnelles. Un

Note
gabarit définit le look de la fenêtre mais également le look de tous les champs
qui seront utilisés dans cette fenêtre. Ainsi, aucune faute de goût n’est possible.
5. Validez. La fenêtre est automatiquement créée sous l’éditeur.
Nous allons définir les caractéristiques de base de la fenêtre : son nom et le titre qui sera
affiché dans la barre de titre.
Double-cliquez sur la fenêtre qui vient d’être créée. La fenêtre de description s’affiche sur
l’onglet "Général". Le nom de la fenêtre proposé par défaut est "FEN_SansNom1".
Observez bien le nom de la fenêtre que WinDev propose par défaut : ce nom
commence par les lettres "FEN_". Ce préfixe est automatiquement ajouté car le
projet utilise une charte de programmation.
La charte de programmation permet de définir un préfixe pour chaque type d’ob-
jet et ainsi d’identifier rapidement l’élément manipulé :
Note
• une fenêtre commence par FEN,

• un bouton commence par BTN,
• etc.
Si vous ne voulez pas utiliser cette charte, il suffit de la débrancher : sous le volet
"Projet", dans le groupe "Autres actions", déroulez "Charte" et décochez l’option
"Utiliser la charte".
Saisissez les informations suivantes :
1. Le nom "logique" de la fenêtre : remplacez "FEN_SansNom1" par "FEN_Saisie".

Ce nom sera le nom sous lequel sera enregistrée la fenêtre sur le disque (avec l’extension
"WDW") dans le répertoire des sources du projet. Ce nom sera également utilisé en program-
mation pour manipuler la fenêtre, nous y reviendrons.
2. Le titre de la fenêtre : saisissez "Ma première fenêtre". Ce titre est affiché dans la barre de
titre de la fenêtre.
Validez (bouton vert). Le titre apparaît dans la barre de titre de la fenêtre.
Enregistrez la fenêtre en cliquant sur parmi les boutons d’accès rapide. Par défaut :
• le titre de l’élément correspond au titre que nous avons saisi.
• le nom de l’élément correspond au nom logique de la fenêtre.
• l’emplacement proposé correspond au répertoire du projet, dans lequel tous les éléments
du projet sont regroupés.
Validez en cliquant sur le bouton vert.

Saisie et affichage de la valeur saisie
Pour gérer la saisie et l’affichage de la valeur saisie, vous allez créer :
• un champ dans lequel l’utilisateur va saisir son prénom. Ce type de champ est donc un "champ
de saisie".
• un bouton permettant d’afficher le prénom saisi.
Pour créer le champ de saisie :

1. Sous le volet "Création", dans le groupe "Champs usuels", déroulez "Saisie" (cliquez sur la
flèche) :
La liste des champs de saisie proposés par défaut s’affiche.

2. Cliquez sur "Texte simple" dans la liste des champs. Le champ en création suit alors le mou-
vement de la souris.
3. Déplacez la souris dans la fenêtre vers la position où le champ doit être créé (par exemple
en haut de la fenêtre). Pour poser le champ dans la fenêtre, il suffit de faire un nouveau clic
gauche de souris.
4. Faites un clic droit de la souris sur le champ que vous venez de créer. Le menu contextuel
du champ s’affiche. Dans le menu contextuel affiché, sélectionnez l’option "Description". La
fenêtre de description du champ de saisie s’affiche.
5. Modifiez les caractéristiques du champ en saisissant les informations suivantes :
• Ce champ a pour nom : "SAI_Prénom" (1).

• Ce champ a pour libellé : "Prénom" (2).
• Ce champ est de type texte (3).
6. Validez la fenêtre de description du champ (bouton vert). Le champ apparaît sous l’éditeur
de fenêtres.
Le libellé du champ apparaît tronqué sous l’éditeur. Pour afficher correctement le champ :
1. Sélectionnez le champ (il suffit de cliquer dessus avec la souris).
2. Dans le menu contextuel (clic droit), sélectionnez l’option "Adapter la taille".
3. Le champ est immédiatement agrandi et le libellé apparaît en entier.
Remarque : Il est également possible d’agrandir la zone de saisie du champ :
1. Sélectionnez le champ.
2. Positionnez le curseur de la souris au-dessus d’une des poignées situées à droite du champ
(petit carré). Le curseur de la souris se transforme en flèche.
3. Cliquez avec le bouton gauche de la souris et maintenez le bouton enfoncé pendant le
déplacement permettant d’agrandir le champ.
4. Lorsque le champ a atteint la taille voulue, relâchez le bouton de la souris.
Pour créer le bouton "Afficher" :
1. Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur .
2. Positionnez le champ dans la fenêtre. Cliquez à l’emplacement de création du bouton (par
exemple à droite du champ de saisie).
3. Cliquez sur le bouton que vous venez de créer. Le texte affiché dans le bouton passe en édi-
tion. Saisissez le libellé "Afficher". Le nom du bouton devient automatiquement "BTN_Afficher".
4. Vous pouvez voir le nom du bouton :
• soit dans la bulle d’aide affichée lors du survol du champ :
• soit dans la barre de message de l’éditeur :
Nous allons afficher le texte saisi dans une boîte de dialogue (une mini-fenêtre proposée par
le système). Pour cela, nous allons utiliser notre première fonction WLangage : la fonction
Info.
Notes
Le WLangage est le langage de programmation fourni avec WinDev. C’est un lan-

gage de 5ème génération (L5G), possédant des ordres évolués.
1. Sélectionnez à l’aide de la souris le bouton "Afficher".

2. Affichez le menu contextuel du champ (clic droit de la souris).
3. Sélectionnez l’option "Code". Cette option ouvre l’éditeur de code de WinDev. Cet éditeur
permet de saisir toutes les instructions WLangage.
4. Dans le traitement "Clic sur BTN_Afficher", saisissez le code suivant :
Info("Bonjour " + SAI_Prénom)
Remarque sur l’aide à la saisie : Dès la saisie des trois premiers caractères, WinDev propose tous
les mots du vocabulaire WLangage contenant ces caractères. L’assistance au développement est
poussée très loin. Vous ne pouvez plus vous tromper en saisissant le nom d’un élément : les er-
reurs de syntaxe sont minimisées. Il suffit de sélectionner le mot désiré et de valider par la touche
[Entrée]. Vous pourrez ainsi vous concentrer sur l’algorithme.
C’est pour cela que la charte de programmation est très importante. Tous les
Notes
éléments manipulés dans le code de l’application utilisent la même norme et

peuvent ainsi être facilement retrouvés lors de la saisie du code.
En saisissant ce code sous l’éditeur de code, vous constatez que les différents
éléments saisis utilisent des couleurs différentes. C’est la coloration syntaxique.
Notes L’éditeur de code permet ainsi d’identifier rapidement les différents éléments
manipulés par le code :
• les fonctions du WLangage apparaissent en bleu,
• les chaînes de caractères (entre guillemets) apparaissent en violet,
• les noms de champs apparaissent en cyan.
La fonction Info affiche le message passé en paramètre. Notre message est construit à partir du
texte "Bonjour " et de la valeur du champ "SAI_Prénom". Le signe "+" indique une opération dite de
"concaténation" entre deux chaînes.
Notes
Dans cet exemple, le texte saisi est affiché dans une fenêtre système, mais il est
également possible de l’afficher dans une fenêtre créée avec WinDev.
Nous allons enregistrer la fenêtre et la tester :

1. Enregistrez les modifications en cliquant sur parmi les boutons d’accès rapide (à gauche
du ruban) ou par la combinaison de touches [Ctrl]+[S].
2. Cliquez sur parmi les boutons d’accès rapide (ou utilisez la touche [F9]).
3. La fenêtre que vous avez créée se lance en exécution. Saisissez votre prénom.
4. Cliquez sur le bouton "Afficher".
5. Validez la fenêtre système qui s’affiche (cliquez sur le bouton "OK").
Tout développeur sait que tester un programme est souvent long, voire fastidieux. Avec WinDev,
en UN CLIC, vous testez la fenêtre, l’état ou la procédure que vous êtes en train de réaliser. C’est
à la fois simple et rapide !
Fermez la fenêtre de test : cliquez sur le bouton de fermeture système de la fenêtre (bouton
"x" situé dans la barre de titre).
L’éditeur de WinDev réapparaît. Fermez l’éditeur de code : sous le volet "Accueil", dans le
groupe "Général", cliquez sur "Fermer".
Améliorations de la fenêtre
Lors de ce premier test, vous avez remarqué que :
• votre fenêtre est trop grande,
• votre fenêtre peut être redimensionnée alors qu’elle ne contient que deux champs,
• le prénom saisi est affiché avec la casse utilisée dans le champ de saisie. Nous allons forcer
l’utilisation d’une majuscule en début de mot.
Nous allons revoir rapidement l’interface de cette fenêtre.
Pour réduire la taille de la fenêtre sous l’éditeur :
1. Cliquez sur la fenêtre : des poignées apparaissent autour de la fenêtre (selon le gabarit uti-
lisé, la couleur de ces poignées peut être différente).
2. Cliquez sur la poignée située en bas à droite et réduisez la taille de la fenêtre en mainte-
nant le bouton gauche de la souris enfoncé.
Pour que la fenêtre ne soit pas redimensionnable pendant l’exécution :
1. Double-cliquez sur la fenêtre. La fenêtre de description s’affiche.
2. Dans l’onglet "IHM", décochez l’option "Redimensionnable" (il suffit de cliquer sur l’option).
3. Validez.
Notes
Nous approfondirons les conseils d’interface et d’ergonomie dans un prochain

chapitre de ce cours.
Pour visualiser le résultat en exécution, relancez le test de cette fenêtre.

Revenez sous l’éditeur en fermant la fenêtre de test.
Nous allons maintenant forcer l’utilisation d’une majuscule lors de la saisie et de l’affichage
du prénom.
Par défaut, les caractères seront saisis en majuscules ou en minuscules selon

la position de la touche [CAPSLOCK] du clavier. Ce genre de saisie peut être très
gênant lors d’une recherche par exemple.
Notes
WinDev propose la gestion d’un masque de saisie pour un champ. Le masque

de saisie permet de mettre en forme la valeur saisie, automatiquement et sans
aucune ligne de code.
Pour modifier le masque de saisie :

1. Double-cliquez sur le champ "Prénom". La fenêtre de description du champ s’affiche.
2. Dans l’onglet "Général", déroulez la liste "Masque de saisie" et choisissez "1ère lettre maj.".
3. Validez la fenêtre de description du champ.

4. Sous l’éditeur, le nom du masque apparaît automatiquement dans le champ.
Relancez le test de cette fenêtre pour visualiser le résultat en exécution.
Vous venez de créer rapidement et avec succès votre première fenêtre. Nous allons dans la suite
de ce cours découvrir de nouveaux concepts de WinDev.
Validez le message et fermez la fenêtre de test (cliquez sur la croix en haut, à droite de la
fenêtre). L’éditeur de WinDev réapparaît.
Fermez la fenêtre "FEN_Saisie" affichée sous l’éditeur : sous le volet "Accueil", dans le groupe
"Général", cliquez sur "Fermer".
Fermez le projet : sous le volet "Accueil", dans le groupe "Général", déroulez "Fermer" et
sélectionnez "Fermer le projet".
Un exemple pour chaque type de champs

Dans cette leçon, nous avons utilisé deux types de champs : un champ de saisie
et un bouton.
WinDev propose plus d’une quarantaine de champs. Pour découvrir l’utilisation
de chaque type de champ, des exemples unitaires sont à votre disposition.
Pour ouvrir un exemple unitaire :
1. Affichez le volet "Assistants, Exemples et composants" : sous le volet "Ac-
Notes
cueil", dans le groupe "Environnement", déroulez "Volets" et sélectionnez "As-

sistants, Exemples et composants".
2. Dans le volet, cliquez sur "Exemples". La liste des exemples apparaît. Les
exemples sont affichés par catégorie.
3. Dans la catégorie "Exemples unitaires", sélectionnez l’exemple voulu (par
exemple "Le champ Arbre") et double-cliquez sur son nom : la fenêtre corres-
pondante s’ouvre automatiquement sous l’éditeur.
Remarque : Pour simplifier la recherche, tous les noms des exemples unitaires
correspondant aux champs commencent par "Le champ ".
Leçon 1.3. Des fenêtres plus évoluées
• Comment faire un calcul

• Comment créer une fenêtre affichant la date et l’heure en temps réel
• Créer une fenêtre avec menu
Présentation
Dans la leçon précédente, nous avons déjà vu comment saisir et afficher un texte.
Dans cette leçon, nous allons créer les fenêtres suivantes :
• Une fenêtre de calcul,
• Une fenêtre affichant la date et l’heure en temps réel,
• Un menu pour rassembler les fenêtres créées précédemment.
Ces fenêtres vont être créées dans le projet "WD Mes Premières Fenêtres" que nous avons déjà
manipulé dans la leçon précédente.
Ouvrez à nouveau le projet "WD Mes Premières Fenêtres".
le premier projet "Mes premières fenêtres (Exercice)".
"Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez l’option "Mes premières
fenêtres (Exercice)".
Un projet corrigé est disponible. Ce projet contient les différentes fenêtres créées
dans cette leçon. Pour ouvrir le projet corrigé :
Corrigé
• dans la fenêtre de bienvenue, cliquez sur "Cours d’auto-formation" et sélection-

nez le projet "Mes premières fenêtres (Corrigé)".
• sous le volet "Accueil", dans le groupe "Aide en ligne", déroulez "Guide d’Auto-
formation" puis sélectionnez "Mes premières fenêtres (Corrigé)".
Gérer la saisie d’un numérique pour faire un calcul

Dans une nouvelle fenêtre, nous allons maintenant :
• Créer deux champs de saisie numériques.
• Calculer et afficher la valeur TTC du montant HT saisi.
Le résultat du calcul sera affiché dans le champ "Prix TTC".
Cette fenêtre est la suivante :
Mise en place
Créez une nouvelle fenêtre vierge :

1. Cliquez sur parmi les boutons d’accès rapide. Dans la roue qui s’affiche, cliquez sur
"Fenêtre". L’assistant de création de fenêtres s’affiche.
2. Sélectionnez "Vierge" et le gabarit "Elegant".
4. Faites un clic droit sur la fenêtre et sélectionnez l’option "Description".
5. Donnez à la fenêtre le nom "FEN_Calcul" et le titre "Exemple de calcul". Validez la fenêtre
de description.
6. Enregistrez la fenêtre : cliquez sur parmi les boutons d’accès rapide.
7. Validez les informations affichées dans la fenêtre de sauvegarde en cliquant sur le bouton
vert.
Il est très important de sauvegarder la fenêtre dès sa création.

L’enregistrement de la fenêtre permet par la suite à WinDev :
Notes
• de proposer le nom des champs automatiquement dans le code.

• de proposer le renommage automatique des champs dans le code.
Pour créer le champ de saisie correspondant au prix HT :

flèche). La liste des différents champs de saisie disponibles s’affiche. Sélectionnez le champ
"Monétaire" et positionnez le champ dans la fenêtre.
2. Faites un clic droit sur le champ et sélectionnez l’option "Description".
3. Dans la fenêtre de description :
• Saisissez le nom du champ "SAI_PrixHT".
• Saisissez le libellé "Prix HT".
4. Validez.
Pour créer le champ dans lequel sera affiché le résultat :
flèche). La liste des différents champs de saisie disponibles s’affiche. Sélectionnez le champ
"Monétaire" et positionnez le champ dans la fenêtre (par exemple sous le champ de saisie affi-
chant le prix HT).
2. Saisissez les informations du champ : faites un clic droit sur le champ et sélectionnez l’op-
tion "Description".
• Indiquez le nom du champ "SAI_PrixTTC".
• Modifiez le libellé par "Prix TTC".
3. Le résultat affiché dans ce champ ne doit pas être modifiable. Cliquez sur l’onglet "IHM" et
choisissez l’état initial "Affichage seul".
4. Validez.
5. Sauvez la fenêtre.
Le calcul du montant TTC va être effectué à chaque modification du champ contenant le montant
hors taxe.
Pour réaliser le calcul du montant TTC :
1. Affichez le code du champ "SAI_PrixHT" (option "Code" du menu contextuel du champ).
2. Dans le code "A chaque modification", saisissez le code suivant :
// TVA figée à 19.6% pour l’exemple
// Cela aurait pu être une variable quelconque
// provenant d’une base de données
SAI_PrixTTC = SAI_PrixHT * 1.196
3. Fermez la fenêtre de code (icône "x" de la fenêtre de code).
4. Enregistrez la fenêtre.
Test de la fenêtre
Testez la fenêtre :
1. Cliquez sur parmi les boutons d’accès rapide.
2. Saisissez une valeur dans le champ "Prix HT". Le résultat apparaît immédiatement dans le
champ "Prix TTC".
3. Fermez la fenêtre de test.
Utilisation d’un champ Combo pour proposer plusieurs possibilités

Dans la fenêtre que nous venons de créer et de tester, le calcul prend en compte un taux fixe de
TVA.
Pour compliquer un peu notre exemple, nous allons donner la possibilité de sélectionner le taux
de TVA dans une liste déroulante (appelée "combo").
Pour créer le champ Combo de sélection de la TVA :
1. Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur "Combo" puis cliquez
dans la fenêtre à la position où le champ doit être créé (à côté du champ "Prix HT").
2. L’assistant de création d’un champ Combo s’affiche. Cet assistant permet de définir sim-
plement les principales caractéristiques du champ.
3. Sélectionnez l’option "Remplir la combo par programmation ou saisir directement une liste
de valeurs".
4. Affichez l’écran suivant.

5. Conservez les options proposées par défaut. Affichez l’écran suivant.
6. Dans l’écran intitulé "Contenu initial", saisissez la liste des valeurs de TVA possibles :
• 5.5
• Appuyez sur la touche ENTREE
• 19.6
• Appuyez sur la touche ENTREE
• 25.
7. Affichez l’écran suivant et donnez un nom au champ (COMBO_TVA) et un libellé (TVA).
8. Validez.
9. Modifiez si nécessaire la taille de la fenêtre pour que le champ Combo soit affiché à côté du
champ de saisie affichant le prix HT.
Nous allons maintenant modifier le code du champ "Prix HT" pour prendre en compte le montant
de la TVA sélectionné dans le champ Combo.
Pour prendre en compte le montant de la TVA sélectionné :
1. Sélectionnez le champ "Prix HT".
2. Affichez le code du champ "Prix HT" (option "Code" du menu contextuel).
3. Modifiez le code de la façon suivante :
SAI_PrixTTC = ...
SAI_PrixHT*(1+Val(COMBO_TVA..ValeurAffichée)/100)
Ce code calcule le montant TTC en utilisant la valeur sélectionnée dans le champ Combo
(donnée obtenue avec la propriété ..ValeurAffichée). Le contenu du champ Combo étant une
chaîne de caractères, la fonction Val permet d’obtenir une valeur numérique afin de calculer
le montant TTC.
Le WLangage est composé de fonctions et de propriétés. Les fonctions peuvent

attendre des paramètres et renvoient des résultats. Les propriétés sont directe-
ment appliquées aux champs grâce à la syntaxe :
<Nom du champ>..<Nom de la propriété>.
Notes
Dans notre exemple, la propriété ValeurAffichée est utilisée sur le champ

COMBO_TVA.
A tout moment, il est possible de consulter l’aide en ligne d’une fonction grâce à
la touche F1. Pour plus de détails sur l’aide en ligne, consultez "Comment accé-
der à l’aide en ligne ?", page 20.
4. Testez votre fenêtre ( parmi les boutons d’accès rapide) :
• Saisissez une valeur dans le champ "Prix HT".
• Le résultat apparaît immédiatement dans le champ "Prix TTC" en fonction de la TVA sélec-
tionnée.
• Cependant si vous changez le taux de TVA, la valeur du champ "Prix TTC" n’est pas modifiée.
Nous allons maintenant corriger ce problème.
5. Fermez la fenêtre de test. L’éditeur de code est de nouveau affiché.
Pour prendre en compte le montant de la TVA, à chaque modification de la valeur de la TVA

dans la combo, il suffit de recopier le code du traitement "A chaque modification" de "Prix HT"
dans le traitement "Sélection d’une ligne" de la combo "COMBO_TVA" :
1. Affichez le code du champ "Prix HT" (option "Code" du menu contextuel par exemple).
2. Sélectionnez le code présent dans le traitement "A chaque modification de SAI_PrixHT".
3. Utilisez les touches "CTRL" + "C".
4. Affichez le code du champ Combo "TVA".
5. Placez-vous dans le traitement "Sélection d’une ligne" et utilisez les touches "CTRL" + "V".
6. Testez votre fenêtre ( parmi les boutons d’accès rapide) et sélectionnez les différentes
valeurs dans le champ Combo.
Maintenant, notre fenêtre fonctionne correctement. Mais le même code est utilisé à 2 endroits
différents ! Comment gérer les modifications et leur report ? Le plus simple est d’utiliser une
procédure. C’est ce que nous allons faire maintenant.
Fermez la fenêtre de test pour revenir sous l’éditeur de code.
Création et utilisation d’une procédure
La création d’une procédure à partir d’un code existant est très simple avec WinDev : une option
de menu se charge de tout.
Pour créer la procédure de calcul de la TVA :
1. Sélectionnez le code présent dans le traitement "Sélection d’une ligne" de la combo "TVA".
2. Affichez le menu contextuel du code sélectionné (clic droit de la souris).
3. Sélectionnez l’option "Nouveau .. Créer une procédure locale contenant le code sélec-
tionné".
4. Donnez le nom de la procédure à créer : CalculTVA. Validez.
5. La procédure locale "CalculTVA" est automatiquement créée avec le code sélectionné. Votre
code a été remplacé par l’appel à la procédure "CalculTVA()".
6. Pour terminer, il suffit de remplacer le second code de calcul de la TVA (présent dans le trai-
tement "A chaque modification" du champ "Prix HT") par l’appel à la procédure "CalculTVA()".
7. Voilà, c’est terminé. Vous pouvez enregistrer et tester votre fenêtre pour vérifier si tout fonc-
tionne correctement.
Afficher la date et l’heure en temps réel
Présentation
Nous allons réaliser la fenêtre suivante :
Cette fenêtre affiche la date et l’heure. Simple ! Cependant, l’heure est mise à jour en temps réel.
Pour cela, WinDev met à votre disposition les "Timers".
Un timer permet d’exécuter en parallèle une tâche qui doit être lancée périodiquement (acquisi-
tion de données en tâche de fond, rafraîchissement automatique de données, déclenchement
d’un programme à une heure donnée, ...).
Mais commençons par créer notre fenêtre !
Créez une nouvelle fenêtre vierge :

"Fenêtre". L’assistant de création de fenêtres s’affiche.
2. Sélectionnez "Vierge" dans la liste des fenêtres "standard" affichée sur la gauche. Dans la
liste des gabarits présente sur la droite, le gabarit "Elegant" est proposé automatiquement.
Enregistrez la fenêtre en cliquant sur parmi les boutons d’accès rapide. Dans la fenêtre
qui s’affiche, saisissez :
• le titre de l’élément : "Mise à jour de l’heure par timer".
• le nom de l’élément : FEN_Timer.
Validez (bouton vert). La fenêtre est enregistrée. Le titre apparaît dans la barre de titre.
Nous allons maintenant ajouter un champ de type Date dans notre fenêtre pour afficher la date
du jour.
Pour créer le champ de saisie de type Date :
flèche). La liste des différents champs de saisie disponibles s’affiche.
2. Sélectionnez le champ "Date" (sans le petit calendrier) et positionnez le champ dans la
fenêtre.
3. Faites un clic droit sur le champ et sélectionnez l’option "Description" dans le menu contex-
tuel.
4. Dans l’onglet "Général" de la fenêtre de description :
• Saisissez le nom du champ "SAI_Jour" (1).

• Saisissez le libellé "Nous sommes le : " (2).
• Ce champ est de type "Date" : ce champ permet d’afficher et de saisir une date (3).
Nous allons définir les différents masques associés à ce champ (4).
Deux types de masques sont disponibles :
• Le masque d’affichage : il correspond au format utilisé lorsque la valeur est
Notes
affichée dans le champ.

• Le masque de saisie : il correspond au format utilisé lorsque l’utilisateur va
saisir la valeur dans le champ.
1. Conservez le masque de saisie sélectionné ("Date définie dans le projet").
Par défaut, le masque de saisie du champ correspond au masque numérique

défini pour le projet. Cette information est sélectionnée dans l’onglet "Langues"
de la description du projet. Pour afficher la description du projet, sous le volet
Notes
"Projet", dans le groupe "Projet", cliquez sur "Description".

Ainsi, le même masque est utilisé automatiquement dans tous les champs
numériques de l’application. Cette fonctionnalité est très utile dans les
applications multilingues.
2. Sélectionnez le masque d’affichage " JJJJ JJ MMMM AAAA". Ce masque d’affichage permet
d’afficher la date sous une forme littéraire par exemple "Mardi 16 juillet 2013".
3. Ce champ permet uniquement d’afficher la date. Aucune saisie ne doit être effectuée. Pour
cela, il suffit d’indiquer que ce champ est en mode "Affichage seul" dans l’onglet "IHM" de la
fenêtre de description du champ.
4. Validez.
Le masque que nous avons choisi permet d’afficher la date en toutes lettres. Pour éviter
d’afficher une date tronquée, nous allons agrandir la largeur du champ :
1. Sélectionnez le champ de saisie.
2. Agrandissez le champ en largeur à l’aide des poignées de redimensionnement.
Pour afficher la date du jour dans le champ de type Date, il suffit de l’initialiser avec cette date.
Cette opération est réalisée par programmation.
Affichez le code associé au champ que vous venez de créer :
1. Sélectionnez le champ de saisie : il suffit de cliquer dessus avec la souris.
2. Affichez le menu contextuel (clic droit de la souris) et sélectionnez l’option "Code". L’éditeur
de code apparaît.
3. Dans le traitement "Initialisation de SAI_Jour", saisissez le code suivant :
MoiMême = DateDuJour()
Examinons ce code d’initialisation :

• MoiMême est un mot-clé qui représente le nom du champ en cours. MoiMême permet de
rendre un code local (traitement d’un champ, ...) ou global (procédure globale, classe, ...) in-
dépendant du champ en cours.
• DateDuJour est une fonction WLangage permettant (comme son nom l’indique) d’obtenir la
date du jour.
• Le signe "=" permet d’affecter le champ en cours avec le résultat de la fonction WLangage
DateDuJour.
Enregistrez la fenêtre et testez-la (en cliquant sur puis sur parmi les boutons
d’accès rapide).
Le champ de saisie est bien initialisé avec la date du jour.

Nous allons maintenant ajouter un nouveau champ de saisie permettant d’afficher l’heure en
temps réel.
Pour créer le champ de saisie de type heure :
flèche). La liste des différents champs de saisie disponibles s’affiche.
Sélectionnez le champ "Heure" et positionnez le champ dans la fenêtre.
2. Faites un clic droit sur le champ et sélectionnez l’option "Description".
3. Dans l’onglet "Général" de la fenêtre de description :
• Saisissez le nom du champ "SAI_Heure".
• Saisissez le libellé "Il est : ".
• Le masque d’affichage sélectionné par défaut affiche les heures, les minutes et les se-
condes. Nous n’y touchons pas.
4. Comme pour le champ Date, ce champ permet uniquement d’afficher l’heure. Sélectionnez
l’option "Affichage seul" dans l’onglet "IHM" de la fenêtre de description du champ.
5. Validez.
De la même manière que pour le champ Date, nous allons initialiser le champ Heure avec
l’heure actuelle.
1. Affichez le code associé au champ que vous venez de créer :
• Affichez le menu contextuel du champ (clic droit).
• Sélectionnez l’option "Code".
Pour afficher les traitements associés à un champ, il est également possible

de :
Notes
1. Sélectionner le champ.
2. Utiliser la touche F2.
3. Dans le traitement "Initialisation de SAI_Heure", saisissez le code suivant :

MoiMême = Maintenant()
La fonction Maintenant est une fonction WLangage permettant (comme son nom l’indique) d’ob-
tenir l’heure actuelle.
Enregistrez la fenêtre et testez-la (en cliquant sur puis sur ). La date et l’heure
s’affichent. Nous allons maintenant actualiser l’heure au fil du temps.
Mise en place du timer
Pour mettre à jour le champ Heure, nous allons appeler toutes les secondes une procédure qui
va modifier le champ Heure avec l’heure actuelle. Cette procédure va être locale à la fenêtre : en
effet, cette procédure ne sera appelée que dans cette fenêtre.
Dans la fenêtre de calcul, nous avons déjà créé une procédure à partir d’un code existant. Mainte-
nant, nous allons détailler les différentes étapes de création d’une procédure.
Remarque : Dans la suite de ce cours, nous reviendrons en détail sur les différents types de pro-
cédures.
Pour créer une procédure locale :
1. Sélectionnez dans le volet "Explorateur de projet" le nom de la fenêtre "FEN_Timer".
2. Cliquez sur la flèche à gauche pour afficher les différents éléments.
3. Cliquez sur "Procédures locales". Le dossier est sélectionné.
4. Dans le menu contextuel de "Procédures locales" (clic droit), sélectionnez l’option "Nouvelle
procédure locale".
5. Dans la fenêtre qui apparaît, indiquez le nom de la procédure "MiseAheure" et cliquez sur le
bouton "Ajouter".
6. La procédure apparaît sous l’éditeur de code. Saisissez le code suivant :
SAI_Heure = Maintenant()
7. Ce code permet de mettre à jour le champ affichant l’heure. Nous allons maintenant l’appe-
ler toutes les secondes grâce au timer.
Pour mettre en place le timer :
1. Revenez sur la fenêtre "FEN_Timer". Vous pouvez par exemple cliquer sur le bouton "FEN_
Timer" en bas.
2. Cliquez dans la fenêtre d’accueil de la fenêtre (fond gris). Affichez le menu contextuel (clic
droit) et sélectionnez l’option "Code".
3. Les différents traitements associés à la fenêtre s’affichent.
4. Dans le traitement "Fin d’initialisation de FEN_Timer", saisissez le code suivant :
TimerSys(MiseAheure, 100,1)
5. Ce code permet d’indiquer que la procédure "MiseAheure" va être appelée toutes les se-
condes (100 représente les centièmes de seconde).
Enregistrez la fenêtre et testez-la (en cliquant sur puis sur parmi les boutons
d’accès rapide).
Nous avons vu ici la création d’un timer par programmation. Il est également
Notes
possible de créer un timer automatiquement depuis l’éditeur de code. Pour plus

de détails, consultez l’aide en ligne (mot-clé : Procédures automatiques).
Fermez la fenêtre de test pour revenir sous l’éditeur.

Création d’un bouton pour quitter la fenêtre
Dans une fenêtre, il y a toujours un bouton ou une option pour quitter la fenêtre. Bien entendu,
si vous n’ajoutez pas de bouton ou d’option, il reste toujours la possibilité de fermer la fenêtre en
cliquant sur l’icône "X" de la barre de titre, mais ce n’est pas très convivial.
Pour créer le bouton de fermeture :
1. Sous le volet "Création", dans le groupe "Champs usuels", déroulez "Bouton" (cliquez sur la
flèche). La liste des boutons prédéfinis s’affiche.
2. Cliquez sur le bouton de type "Fermer".
3. Cliquez dans la fenêtre à la position où le bouton doit être créé (par exemple en bas à
droite).
Vérifions la description du bouton créé :
1. Affichez la description du champ (option "Description" du menu contextuel ou double-clic sur
le bouton).
2. Dans l’onglet "Général" :
• Le nom du bouton respecte la charte de programmation.
• Une action est associée au bouton : cette action permet de fermer la fenêtre.
• Les images correspondant au gabarit utilisé sont automatiquement associées au bouton.
3. Dans l’onglet "IHM", le bouton est de type "Abandon". Le code du bouton sera ainsi exécuté
lorsque la touche ESC sera utilisée.
WinDev propose plusieurs types pour les boutons : Aide, Normal, Validation,
Interruptionet Abandon.
Les règles d’utilisation des boutons sont les suivantes :
Si votre fenêtre ne comporte pas de champs de saisie
Type de bouton à utiliser Tous les boutons peuvent être de type

NORMAL
Si votre fenêtre a au moins un champ de saisie
Type de bouton à utiliser Un bouton de type VALIDATION

Notes
Un bouton de type ABANDON
Un bouton de type AIDE (si les champs

ont des fenêtres d’aide associées)
Tous les autres boutons de type INTER-

RUPTION
Pour plus de détails sur les différents types de boutons :

• consultez l’aide en ligne (mot-clé : Champ Bouton, Type de bouton).
• consultez l’exemple unitaire : Le champ Bouton.
4. Fermez la fenêtre de description du bouton.

Vous pouvez facilement déplacer le bouton de fermeture :
1. Cliquez sur le bouton de fermeture avec le bouton gauche de la souris.
2. Tout en maintenant le bouton de la souris enfoncé, faites glisser la souris (et le champ) à
l’emplacement voulu.
Notre fenêtre est terminée.
Relancez le test de cette fenêtre pour visualiser le résultat en exécution.
Création d’une fenêtre avec un menu
Voilà, nous venons de réaliser quelques fenêtres. Nous allons maintenant créer la fenêtre princi-
pale de cet exemple. Cette fenêtre contiendra le menu organisant l’accès aux différentes fenêtres
de l’application.
WinDev permet de créer des menus déroulants.

Un menu est toujours associé à une fenêtre. Ainsi, pour créer un menu, il faut en premier créer la
fenêtre affichant ce menu.
Décrire le menu
Pour créer une fenêtre comportant un menu :

1. Cliquez sur parmi les boutons d’accès rapide pour créer une nouvelle fenêtre.
2. Dans la roue qui s’affiche, cliquez sur "Fenêtre".
3. Dans l’assistant qui s’affiche, sélectionnez "Vierge" et validez.
4. Donnez un nom et un titre à cette fenêtre. Cette fenêtre a pour nom "FEN_Menu" et pour
titre "Menu principal".
6. Sous le volet "Fenêtre", dans le groupe "Barres et menus", déroulez "Menu principal" et
sélectionnez l’option "Ajouter le menu principal".
7. Un menu s’insère dans la fenêtre sous la barre de titre. Ce menu contient par défaut une
option qui se nomme "Menu".
Remarque : Chaque option de menu est saisie directement dans le menu.

Chaque option comporte une lettre d’appel. Cette lettre d’appel permet d’accéder directe-
ment à l’option avec la combinaison de touches [Alt]+Lettre. Le caractère ’&’ doit alors
précéder la lettre d’appel (par exemple "&Fenêtres").
Pour créer une option de menu et pour la modifier, il suffit d’utiliser le menu contextuel du
menu ou de l’option de menu. Pour afficher le menu contextuel d’une option de menu :
1. Sélectionnez le menu.
2. Cliquez avec le bouton droit de la souris.
3. Le menu contextuel suivant s’affiche :
Plusieurs choix sont possibles. Les principales options de gestion de menu sont :
• "Description de l’option" pour modifier le libellé de l’option et la lettre d’appel.
• "Code" pour saisir le code source correspondant au traitement à exécuter lors du clic sur
cette option.
• "Ajouter après" pour ajouter une option de menu après l’option en cours.
• "Ajouter avant" pour ajouter une option de menu avant l’option en cours.
• "Transformer pour dérouler un sous-menu" pour ajouter dans l’option en cours un sous-
menu (arborescence).
Nous allons réaliser le menu suivant :
Pour le menu "Fichier .. Quitter" :
1. Affichez la description de l’option "Menu" insérée par défaut et changez le libellé en
"Fichie&r". Validez la fenêtre de description.
Notes
Rappel : Le "&" permet de définir la lettre d’appel de l’option de menu.
2. Dans le menu contextuel de l’option "Fichier", sélectionnez l’option "Transformer pour dé-
rouler un sous-menu" et saisissez "Quitter".
Pour le menu "Fenêtres" :

1. Sélectionnez l’option "Fichier".
2. Dans le menu contextuel de l’option "Fichier", sélectionnez l’option "Ajouter après" et saisis-
sez "&Fenêtres".
3. Dans le menu contextuel de l’option "Fenêtres", sélectionnez "Transformer pour dérouler un
sous-menu" et saisissez "&Saisie d’un texte".
4. Dans le menu contextuel de l’option "Saisie d’un texte", sélectionnez "Ajouter après" et sai-
sissez "&Heure en temps réel".
5. Dans le menu contextuel de l’option "Heure en temps Réel", sélectionnez "Ajouter après" et
saisissez "Calcul de &TVA".
Nous allons maintenant ajouter le raccourci [ALT + F4] pour l’option "Quitter".
1. Sélectionnez l’option "Quitter".
2. Affichez la description de l’option (option "Description de l’option" du menu contextuel).
3. Dans la zone "Raccourci clavier", déroulez la combo, parcourez les éléments et sélectionnez
"F4". Puis cochez la case "Alt".
4. Validez.
Lorsque toutes les options de menu sont saisies, visualisez la fenêtre : cliquez sur "Aperçu" dans
le volet "Modification" ou utilisez la combinaison de touches [SHIFT]+[F9].
Ce mode de visualisation permet de visualiser l’aspect final du menu. Pour fermer cette fenêtre,
utilisez le bouton "Fermer" de la télécommande de l’aperçu.
Dans vos applications, nous vous conseillons de suivre le standard des menus
Windows. Veillez en particulier aux points suivants :
• Chaque option du menu principal doit proposer au moins une sous-option.
• La première lettre de chaque option doit être en majuscule, même si ce
n’est pas la lettre d’appel. La lettre d’appel est soulignée (utilisez le carac-
Astuce
tère "&").
• Si un choix de menu appelle une fenêtre de paramétrage avant d’exécuter
l’option choisie, terminez le libellé par trois points (…).
• L’option "Quitter" doit être la dernière sous-option de la première option de
la barre de menu (exemple : "Fichier .. Quitter").
• Si une option d’aide est présente, elle doit se trouver à la fin de la première
ligne de menu (l’option la plus à droite).
Associer un code aux options de menu
Chaque option terminale de menu doit comporter un traitement associé. Classiquement, ce traite-
ment ouvre une fenêtre, mais n’importe quel type de traitement peut être exécuté.
Nous allons saisir le code des différentes options :
1. Sélectionnez l’option "Quitter". Cette option va permettre de quitter l’application. Dans le
menu contextuel, sélectionnez l’option "Code". Dans la fenêtre de code qui s’ouvre, saisissez le
code suivant :
2. Fermez ensuite la fenêtre de code. La fenêtre en cours d’édition apparaît.

3. Dans la fenêtre, sélectionnez l’option de menu "Saisie d’un texte". Cette option va per-
mettre d’ouvrir la fenêtre "FEN_Saisie". Dans le menu contextuel, sélectionnez l’option
"Code". Dans la fenêtre de code qui s’ouvre, saisissez le code suivant :
4. Fermez la fenêtre de code.

5. Répétez cette opération pour l’option "Heure en temps réel" et saisissez le code suivant :
6. Répétez cette opération pour l’option "Calcul de TVA" et saisissez le code suivant :
Vous l’aurez deviné : la fonction Ouvre permet d’afficher une fenêtre pour effectuer une saisie. La
fonction Ferme quant à elle, ferme la fenêtre en cours.
Si la fenêtre contenant le menu est la première fenêtre affichée par l’application, la fermeture
de la fenêtre contenant le menu (par l’option "Fichier .. Quitter" dans notre exemple) équivaut à
quitter l’application.
Dans ce code, les fonctions WLangage utilisées sont en français. Si vous êtes
plus familiarisé avec la langue de Shakespeare, il est possible de visualiser
et de saisir le code en version anglaise : sous le volet "Code", dans le groupe
Notes
"Langues", déroulez "Convertir le code" et sélectionnez "Convertir en anglais".

Dans cette documentation, seuls les termes français seront utilisés. L’aide en
ligne indique pour chaque terme sa traduction en anglais.
Enregistrez et testez la fenêtre. Lors du test :

• Sélectionnez une des options de menu. Fermez la fenêtre qui s’ouvre.
• Cliquez sur l’option "Fichier .. Quitter" pour quitter le programme.
Manipuler les options de menu par programmation

Le WLangage offre diverses fonctions et propriétés permettant de manipuler les
options de menu.
Notes
Il est ainsi possible d’ajouter par programmation des menus, options de menu,
séparateurs, ou encore de cloner une option de menu.
Les propriétés permettent de savoir si une option est visible ou non, marquée ou
non, ...
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Menu").
WinDev : Concepts de base et terminologie
Après la pratique, revenons à un peu de théorie pour aborder les concepts de base de WinDev et
la terminologie spécifique à WinDev.
Concepts de base
WinDev permet de créer simplement une application. Mais que recouvre exactement ce terme
Application ?
Une application est un outil qui permet de réaliser des tâches, des actions automatiquement. Une
application est constituée d’un programme exécutable (ou d’un ensemble de programmes exécu-
tables), de librairies, de fichiers de données, ...
Un programme exécutable est un fichier composé d’éléments directement manipulables par l’uti-
lisateur (fenêtres, états imprimés, ...). C’est ce que lance l’utilisateur final d’une application.
Pour créer un exécutable, WinDev propose de créer un projet. Un projet relie entre eux les dif-
férents éléments du programme et les organise. C’est à partir du projet que pourra être créé le
programme exécutable.
Si votre application manipule des données, WinDev permet de définir la structure de la base de
données grâce à l’analyse. L’analyse WinDev contient la description des fichiers (appelés sou-
vent "Tables" dans de nombreuses bases de données). Ces fichiers contiendront les données de
l’application.
La description des fichiers de données dans l’analyse n’entraîne pas leur créa-
Notes
tion. Les fichiers de données sont créés physiquement uniquement à l’exécution

de l’application.
Un ou plusieurs projets WinDev peuvent être liés à la même analyse. Dans ce cas, on parle d’ana-
lyse partagée. Par exemple, une application de gestion commerciale peut être séparée en plu-
sieurs modules exécutables. Chaque module utilise la même analyse (et en exécution, chaque
exécutable peut également utiliser les mêmes fichiers de données).
Terminologie
Comme nous venons de le voir, un projet WinDev (lié si nécessaire à une analyse) permet de créer
une application. Avant de commencer réellement à travailler avec WinDev, revenons sur les termes
utilisés dans WinDev. En effet, si vous avez travaillé avec d’autres outils, de nombreux termes sont
spécifiques à WinDev et ne recouvrent pas toujours la même réalité que dans d’autres logiciels.
Dans l’analyse, les termes utilisés sont les suivants :
• Fichier : L’analyse permet de décrire la structure des fichiers de la base de données. Le terme
"Fichier" correspond dans certaines bases de données à "une table".
Dans WinDev, le terme "Table" est réservé pour désigner un objet graphique permettant de
visualiser le contenu d’un fichier de données sous forme de tableau, et/ou de saisir des lignes.
Par exemple, une table peut permettre de saisir le détail d’une commande.
• Enregistrement : Un enregistrement est quelquefois également appelé ligne. L’enregistrement
d’un fichier de données correspond à l’ensemble des rubriques définies pour le fichier.
• Rubrique : Dans l’analyse, le terme rubrique désigne une zone d’un fichier de données. L’en-
semble des rubriques d’un fichier de données permet de définir la structure d’un enregistre-
ment.
• Clé/Index : Avec WinDev et sa base de données HFSQL, la notion d’index est liée à la notion de
clé. La notion de clé fait partie des caractéristiques d’une rubrique. Les clés permettent d’accé-
lérer les accès aux données ou de faciliter les parcours des fichiers de données. En WinDev, si
un fichier de données HFSQL a plusieurs rubriques clés, en exécution, un seul fichier d’index
sera créé.
Dans les fenêtres et les états, les termes utilisés sont les suivants :
• Fenêtre : Les fenêtres permettent d’afficher ou de saisir à l’écran des informations. Les fenêtres
sont également appelées "Écrans" ou "Boites de dialogue". L’utilisateur peut agir directement
sur les fenêtres par l’intermédiaire de champs, de boutons, ...
• Etat : Les états permettent d’obtenir une vue personnalisée d’informations. Ces informations
peuvent provenir de la base de données, de fichiers texte, de champs présents dans les fe-
nêtres, ... Les états peuvent être visualisés à l’écran, imprimés sur papier, générés en PDF ou
en HTML, ...
• Champ : Le mot "champ" est le terme utilisé pour désigner les différents objets graphiques affi-
chés dans une fenêtre ou dans un état.
• Gabarit : Le gabarit permet de définir le "look" de l’application : apparence visuelle des fenêtres,
des boutons, des champs, ...
• Style : Le style regroupe les caractéristiques graphiques d’un élément : image de fond, bordure,
police, ... Les styles des différents éléments constituant l’interface d’une application WinDev
sont regroupés dans une feuille de styles.
Dans une application, l’entité "NomClient" peut correspondre :

Important
• au nom d’un champ d’une fenêtre

• au nom d’un champ d’un état
• à la rubrique d’un fichier de données
• à une variable définie par le programmeur
Leçon 1.4. Bases de programmation
• Les différents types de variables

• Instructions de base du WLangage
• Les opérateurs de base du WLangage
• Procédures et fonctions
• Traitement des chaînes, des numériques et des monétaires
• Traitement des dates et des heures
Durée estimée : 1 heure
Introduction
Dans la leçon précédente, nous avons un peu manipulé l’éditeur de code de WinDev et son lan-
gage, le WLangage. Cette leçon va vous permettre de revenir sur les bases de la programmation
en WLangage, en présentant les sujets suivants :
• Déclaration des différents types de variables,
• Instructions de base du WLangage,
• Procédures et fonctions,
• Traitements des chaînes,
• Traitements des numériques,
• Traitements des dates et des heures.
Déclaration des différents types de variables
Les différents types de variables

WinDev propose une grande variété de types de variables (booléen, entier, réel, monétaire, chaîne,
date, heure, durée, dateheure, variant, tableau, structure, ...).
La syntaxe à utiliser pour déclarer une variable est très simple : il suffit d’indiquer le nom de la
variable et son type :
NomVariable EST UN(e) TypeVariable
Quelques exemples :
Indice est un entier
NomFournisseur est une chaîne
TablePrix est un tableau de 10 monétaires
I, J, K sont des entiers
Compteur est un entier = 120
B1 est un booléen = Faux
Pour plus d’informations tous les types de variables disponibles (types simples, types avancés, ...),
consultez l’aide en ligne (mot-clé : "Types de données").
La déclaration des variables et leur portée

Le WLangage permet de manipuler deux types de variables :
• Les variables globales
• Les variables locales
Les variables globales peuvent être globales au projet ou à une fenêtre. Il suffit de déclarer ces
variables :
• dans le code d’initialisation du projet, pour déclarer les variables globales au projet. Ces va-
riables pourront être utilisées dans tous les traitements du projet et des éléments du projet
(fenêtres, états, ...)
• dans le code de déclarations des globales de la fenêtre, pour déclarer les variables globales de
la fenêtre. Ces variables pourront être utilisées dans tous les traitements de la fenêtre et des
éléments de la fenêtre.
Toutes les variables déclarées ailleurs sont des variables locales.
La plupart des développeurs est tentée de déclarer toutes ses variables en "glo-
bal" dans un projet. Ce type de programmation est en effet "facile". Les variables
étant toutes globales, elles sont alors manipulables depuis n’importe quel trai-
tement.
Attention !
Mais ce type de programmation est souvent la cause d’écrasement de variables

et d’effets de bord indésirables.
Il est donc préférable de déclarer un nombre limité de variables globales et en-
suite de déclarer des variables locales.
Si vous souhaitez partager des valeurs entre 2 fenêtres, il est vivement conseillé
d’utiliser la méthode du "passage de paramètres", méthode que nous verrons un
peu plus tard.
Instructions de base du WLangage

Le WLangage est un L5G riche, composé de :
• Fonctions WLangage.
• Propriétés WLangage.
• Mots-clés WLangage.
• Instructions WLangage.
Au fur et à mesure de votre formation, vous découvrirez les instructions nécessaires.
Dans cette leçon, nous allons simplement vous présenter les instructions de base, permettant de
réaliser des conditions et des boucles ou simplement de saisir des commentaires.
Exemple pratique
Pour comprendre un concept, rien ne vaut une manipulation. Le projet "WD Bases Program-
mation" contient des exemples pour chaque concept présenté.
1. Lancez WinDev 19 si ce n’est déjà fait.
2. Fermez si nécessaire le projet en cours : sous le volet "Accueil", dans le groupe "Général",
déroulez "Fermer" et sélectionnez l’option "Fermer le projet".
3. Dans la fenêtre de bienvenue, cliquez sur l’option "Cours d’auto-formation" et sélectionnez
le projet "Bases de la programmation".
Astuce : il est également possible sous le volet "Accueil", dans le groupe "Aide en ligne", de
dérouler "Guide d’Auto-formation" puis de sélectionner l’option "Bases de la programmation".
Instructions conditionnelles
Le WLangage permet de gérer des instructions conditionnelles du type :
• SI, SINON, FIN pour effectuer un test sur une condition.
• SELON, CAS, FIN pour exécuter une ou plusieurs actions selon les différents résultats d’un
test sur une condition.
Quelques exemples
SI Maximum > Hasard(1, 999) ALORS
Info("Bravo, vous avez gagné !")
SINON
Info("Dommage, vous avez perdu !")
FIN
SELON Jour
CAS "Lundi"
// Premier jour de la semaine
CAS "Mercredi"
// Troisième jour de la semaine
CAS "Vendredi"
// Cinquième jour de la semaine
CAS "Samedi", "Dimanche"
// C’est le week-end
AUTRES CAS
// C’est un autre jour
FIN
Exemple pratique
Après avoir présenté les principales instructions conditionnelles, rien ne vaut un petit test réel !
Ouvrez la fenêtre "FEN_Code.wdw" : dans le volet "Explorateur de projet", dans le dossier
"Fenêtres", double-cliquez sur le nom de la fenêtre. Cette fenêtre présente différents
exemples.
Pour rechercher rapidement une fenêtre dans le projet en cours, utilisez la com-
binaison de touches [CTRL] + [E]. Une fenêtre s’affiche permettant de réaliser
Astuce
une recherche sur toutes les fenêtres contenant la suite de lettres saisies dans
la zone de recherche. Il suffit de sélectionner la fenêtre voulue et de valider pour
que cette fenêtre s’ouvre sous l’éditeur.
Lancez le test de cette fenêtre ( parmi les boutons d’accès rapide).

1. Cliquez sur l’onglet "SI / SELON".
2. Testez les différents exemples. Le code exécuté est affiché dans la fenêtre.
3. Fermez la fenêtre et revenez sous l’éditeur.
Instructions de boucle
Le WLangage propose plusieurs possibilités pour gérer des boucles :
• POUR, FIN pour un nombre d’itérations déterminé.
• TANTQUE, FIN pour un nombre d’itérations indéterminé et dont la condition de sortie de la
boucle est testée au début de la boucle.
• BOUCLE, FIN pour un nombre d’itérations indéterminé et dont la condition de sortie de la
boucle est testée dans la boucle. L’instruction SORTIR permet de sortir de cette boucle.
Le WLangage propose également des boucles de type POUR TOUT, FIN permet-
Notes
tant de parcourir les éléments d’un champ, les chaînes de caractères, les enre-
gistrements d’un fichier de données, ... Ces boucles avancées seront étudiées
dans la suite de ce cours d’auto-formation.
Quelques exemples
i est un entier = 0
TANTQUE i < Maximum
i ++ // Equivalent à i=i+1
FIN
i est un entier = 0
BOUCLE
i ++ // Equivalent à i=i+1
SI i > Maximum ALORS SORTIR
FIN
POUR i = 1 A 100 // Il n’est pas nécessaire de déclarer i

Cpt ++ // Equivalent à Cpt=Cpt+1
FIN
Exemple pratique
Après avoir présenté les principales instructions de boucle, vérifions le fonctionnement en exécu-
tion.
Ouvrez la fenêtre "FEN_Code.wdw" : dans le volet "Explorateur de projet", dans le dossier
"Fenêtres", double-cliquez sur le nom de la fenêtre. Cette fenêtre présente différents
exemples.
1. Cliquez sur l’onglet "Boucle".
2. Testez les différents exemples. Le code exécuté est affiché dans la fenêtre.
3. Fermez la fenêtre et revenez sous l’éditeur.
Commentaires
Pour saisir des commentaires dans le code, il suffit de commencer le code par // (deux carac-
tères "/").
Exemple :
// Ceci est une ligne de commentaire
Vous pouvez mettre en commentaires plusieurs lignes de code en sélectionnant

au clavier (ou à la souris) les lignes à mettre en commentaires puis en appuyant
Astuce
sur les touches [Ctrl] / (du pavé numérique).

Vous réalisez l’opération inverse (enlever les commentaires) en sélectionnant au
clavier (ou à la souris) les lignes à enlever des commentaires puis en appuyant
sur les touches [Ctrl] [Shift] / (du pavé numérique).
Opérateurs de base du WLangage
Le WLangage dispose de plusieurs types d’opérateurs :
• les opérateurs logiques (ET, OU, PAS, ...),
• les opérateurs arithmétiques qui permettent d’additionner, de soustraire, ...
• les opérateurs de comparaison qui permettent de comparer des valeurs. Nous en avons vu
quelques-uns dans le paragraphe précédent (>, <, =, ...),
• les opérateurs binaires qui permettent d’effectuer des opérations sur des valeurs binaires,
• les opérateurs d’affectation et d’échange (=, <=>),
• les opérateurs d’indirections qui permettent de construire le nom d’un champ à partir d’une
expression.
• les opérateurs sur les chaînes de caractères (que nous verrons dans le paragraphe "Traitements
des chaînes", page 74).
• ...
Nous allons ici détailler l’utilisation des opérateurs logiques, des opérateurs de comparaison et
des opérateurs d’indirection. Nous verrons les autres types d’opérateurs au fil de nos besoins
dans ce cours. Pour plus de détails sur un type d’opérateur, consultez l’aide en ligne (mot-clé :
"Opérateurs").
Les opérateurs logiques

Le WLangage dispose de 5 opérateurs logiques qui permettent d’effectuer des opérations lo-
giques et de construire des conditions :
• ET et _ET_ qui correspondent à la multiplication logique.
• OU et _OU_ qui correspondent à l’addition logique.
• PAS qui correspond à la négation logique.
Exemple pratique
Rien ne vaut un bon exemple pour comprendre les subtilités de ces opérateurs.
Dans le projet "WD Bases Programmation", ouvrez la fenêtre "FEN_Opérateur".
Lancez le test de cette fenêtre ( parmi les boutons d’accès rapide) et testez les opéra-
teurs logiques.
Les opérateurs de comparaison
Le WLangage possède de nombreux opérateurs de comparaison qui permettent de réaliser de
nombreux traitements :
• opérateurs d’égalité : égalité (=), égalité souple (~=) ou égalité très souple (~~).
• opérateurs de comparaison : différent (<>), inférieur et supérieur (<, <=, >, >=), ou commence
par ([=, [=~, [=~~).
Exemple pratique
Une page d’exemple est disponible pour tester quelques cas d’utilisation des différents opéra-
teurs de comparaison.
Dans le projet "WD Bases Programmation", ouvrez la fenêtre "FEN_Opérateur".
Lancez le test de cette fenêtre ( parmi les boutons d’accès rapide) et testez les opéra-
teurs de comparaison.
Les opérateurs d’indirection

Le mécanisme "d’indirection" permet de construire le nom d’un champ, d’une rubrique de fichier
ou le nom d’une variable à partir d’une expression de type chaîne.
Ceci permet par exemple de créer des traitements génériques indépendants des noms des
champs, des variables, des rubriques de fichier ...
L’indirection est réalisée à l’aide des opérateurs { }.
Pour optimiser la vitesse de vos applications, il est conseillé de préciser lors de l’utilisation de la
syntaxe d’indirection le type de l’élément manipulé.
Ainsi, si vous manipulez un champ, le type correspondant sera IndChamp (voir exemple ci-des-
sous).
Voici quelques exemples d’indirection :
• Exemple d’indirections simples :
{"NOM",indChamp} = NomCli
// est équivalent à NOM=NomCli
{"NOM",indChamp} = {"CL.NOMCLI"}
// est équivalent à NOM=CL.NOMCLI
{"FENCLI.NOM",indChamp} = NomCli
// est équivalent à FENCLI.NOM=NomCli
{"FENCLI"+".NOM",indChamp} = NomCli
// est équivalent à FENCLI.NOM=NomCli
• Exemple d’indirection avec une procédure :

NomChamp est une chaîne
NomChamp = "SAISIE1" //SAISIE1 est le nom du champ
// Appel d’une procédure rendant un champ invisible
INVISIBLE(NomChamp)
PROCEDURE INVISIBLE(NChamp)
{NChamp,indChamp}..Visible = Faux
Pour plus de détails sur l’utilisation des indirections, consultez l’exemple
Exemple
"Manipulationdes indirections" (exemple unitaire), livré en standard avec
WinDev. Cet exemple est accessible depuis le volet "Assistants, Exemples et
Composants".
Procédures et fonctions
Définition
Comme nous l’avons vu dans la leçon précédente, lorsqu’un traitement est appelé plusieurs fois
dans un projet ou dans une fenêtre, il est souvent intéressant de créer une procédure contenant
ce traitement. Il suffit alors d‘appeler la procédure à chaque fois que cela est nécessaire.
Côté programmation, il existe les procédures et les fonctions :
• Les fonctions renvoient un résultat.
• Les procédures servent à exécuter un traitement spécifique.
WinDev permet de gérer simplement les deux types de traitements, de manière identique : sous
WinDev, il n’y a pas de différence entre une procédure et une fonction. C’est pourquoi dans la
suite de ce cours, nous utiliserons uniquement le terme "procédure".
Vous avez la possibilité de créer des procédures "locales" et des procédures "globales".
Procédure locale
Une procédure "locale" est liée à une fenêtre et uniquement à cette fenêtre.
Une procédure, lorsqu’elle est locale, peut être utilisée uniquement dans les traitements de la
fenêtre et des champs de la fenêtre dans laquelle elle a été déclarée. Elle fait partie de la fenêtre.
Procédure globale et collection de procédures

Les procédures "globales" sont contenues dans des "collections de procédures". Chaque "collec-
tion de procédures" est un fichier qui contient toutes les procédures globales qui lui sont asso-
ciées. Ce fichier possède l’extension ".WDG". Par exemple, une collection permet de regrouper les
procédures selon un thème : CalculsTVA, CalculsFraisDePorts, ...
Vous pouvez créer autant de collections de procédures que vous le désirez dans un projet.
Une collection de procédures permet de :
• partager des procédures globales entre plusieurs développeurs, pour un même projet.
• partager des procédures globales entre plusieurs projets. En effet, une même collection de
procédures peut être utilisée dans plusieurs projets.
Pour créer une collection de procédures :
1. Sélectionnez le volet "Explorateur de projet".
2. Sélectionnez "Procédures".
3. Dans le menu contextuel (clic droit), sélectionnez l’option "Nouvelle collection de procé-
dures".
4. Dans la fenêtre qui apparaît, indiquez le nom de la collection de procédures et validez.

5. Les traitements associés à la collection de procédures apparaissent sous l’éditeur de code.
Il est ensuite possible de créer des procédures globales (cette création est détaillée dans la suite
de cette leçon).
Comment choisir si une procédure est globale ou locale ?

Pour choisir si une procédure doit être globale ou locale, posez-vous la question suivante : "La
procédure va-t-elle être utilisée uniquement dans cette fenêtre, ou peut-elle être appelée depuis
une autre fenêtre ?"
• Si la procédure est appelée "uniquement depuis cette fenêtre", la procédure peut être "lo-
cale".
• Si la procédure peut être appelée "depuis plusieurs fenêtres", la procédure doit être "glo-
bale".
A propos du passage des paramètres

Dans le projet "WD Mes Premières fenêtres", vous avez pu voir qu’une procédure pouvait gérer
des paramètres. Les paramètres peuvent être obligatoires ou optionnels.
Les paramètres "obligatoires" sont toujours définis avant les paramètres "optionnels". La déclara-
tion d’un paramètre "optionnel" est effectuée en affectant une valeur par défaut lors de la décla-
ration du paramètre. Par exemple :
PROCEDURE MaProcédure (Param1, ParamOption = "Valeur par défaut")
Une fenêtre peut également renvoyer une valeur au traitement qui l’a appelée. Pour plus de dé-
tails, consultez l’aide en ligne sur la propriété ..ValeurRenvoyée.
Appel d’une procédure
Pour appeler une procédure dans un traitement, il suffit d’écrire son nom dans l’éditeur de code
et si nécessaire d’indiquer des paramètres.
WinDev sait bien évidemment gérer les appels de procédures imbriquées.
Dans l’éditeur de code, lorsque vous êtes positionné sur un nom de procédure,
Astuce
l’appui sur la touche de fonction [F2] permet de visualiser le code de cette pro-
cédure. L’appui simultané sur les touches [CTRL]+[F2] permet de revenir dans le
code précédent sur le nom de la procédure.
Création d’une procédure

Une procédure peut être créée directement depuis l’éditeur principal de WinDev. Il suffit d’utiliser
le volet "Explorateur de projet".
Pour créer une procédure locale :
1. Dans le volet "Explorateur de projet", sélectionnez le nom de la fenêtre associée à la procé-
dure locale.
2. Cliquez sur la flèche à gauche pour afficher les différents éléments.
3. Sélectionnez "Procédures locales".
4. Dans le menu contextuel de "Procédures locales", sélectionnez l’option "Nouvelle procédure
locale".
5. Dans la fenêtre qui apparaît, indiquez le nom de la procédure et validez.
6. La procédure apparaît sous l’éditeur de code. Saisissez le code de la procédure.
Pour créer une procédure globale :

1. Sélectionnez le volet "Explorateur de projet".
2. Sélectionnez "Procédures".
3. Créez si nécessaire la collection de procédures dans laquelle la procédure globale doit être
créée. Si cette collection existe, sélectionnez-la.
4. Dans le menu contextuel, sélectionnez l’option "Nouvelle procédure globale".
5. Dans la fenêtre qui apparaît, indiquez le nom de la procédure et validez.
6. La procédure apparaît sous l’éditeur de code. Saisissez le code de la procédure.
Rappel : Il est également possible de créer directement une procédure à partir du code sélec-
tionné dans l’éditeur de code (option "Nouveau .. Créer une procédure contenant le code sélec-
tionné" du menu contextuel). C’est ce que nous avons fait dans la leçon précédente.
Quand utiliser les procédures ?

• Lorsqu’un traitement est utilisé plusieurs fois dans une même fenêtre, il est
conseillé d’utiliser une procédure locale à la fenêtre qui contiendra ce traite-
Astuce
ment.
• Lorsqu’un traitement est utilisé plusieurs fois dans un ensemble de fenêtres,
il est conseillé d’utiliser une procédure globale au projet qui contiendra ce trai-
tement.
Exemple pratique
Après avoir vu la théorie, un peu de pratique !
Dans le projet "WD Bases Programmation", ouvrez la fenêtre "FEN_Code" (double-cliquez sur
son nom dans l’explorateur de projet). Cette fenêtre présente différents exemples.
1. Cliquez sur l’onglet "Fonction" pour tester le fonctionnement d’une fonction.
2. Cliquez sur l’onglet "Procédure" pour tester le fonctionnement d’une procédure.
3. Fermez la fenêtre.
Consultez la liste des différentes procédures locales (accessible depuis le volet "Explorateur
de projet"). En double-cliquant sur le nom de la procédure, le code de cette procédure est affi-
ché dans l’éditeur de code.
Un exercice d’application ? A vous de jouer !

Pour mettre en application les différentes fonctionnalités de cette partie, nous vous proposons un
petit exercice :
Dans le projet "WD Bases Programmation", ouvrez la fenêtre "FEN_Code" : double-cliquez sur
son nom dans l’explorateur de projet.
Afficher l’onglet "A vous de jouer".
• Dans le bouton "Votre code", écrivez une procédure qui permet d’afficher tous les chiffres
pairs de 10 à 1 (compte à rebours) dans le champ de saisie SAI_VotreRésultat.
• Testez la fenêtre pour tester votre code.
Correction : Le bouton "Code corrigé" contient la solution.
Traitements des chaînes

Parmi les fonctionnalités de base d’un langage de programmation, la manipulation des chaînes
de caractères est une des fonctionnalités les plus importantes.
Le WLangage offre une palette impressionnante de possibilités pour manipuler les chaînes de
caractères : fonctions WLangage, opérateurs d’extraction, de concaténation, ...
Nous présentons ici les fonctions les plus courantes pour manipuler les chaînes de caractères.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Chaîne de caractères").
Exemple pratique
Ouvrez si nécessaire le projet "WD Bases Programmation.WDP" :

1. Fermez si nécessaire le projet en cours.
Ouvrez la fenêtre "FEN_Chaîne.WDW" : double-cliquez sur son nom dans l’explorateur de
projet. Cette fenêtre illustre les différentes manipulations que nous expliquerons dans cette
leçon.
Testez la fenêtre ( parmi les boutons d’accès rapide).
Principales manipulations sur une chaîne de caractères
Initialisation
Un champ de type texte (par exemple un champ Libellé ou un champ de saisie) peut être initialisé
grâce à une des méthodes suivantes :
• dans l’onglet "Contenu" de la fenêtre de description du champ :
• par programmation en affectant directement la chaîne au nom du champ :

SAI_Texte = "WinDev est un outil formidable"
• par programmation en utilisant une variable de type chaîne :
ch est une chaîne
ch = "WinDev est un outil formidable"
SAI_Texte = ch
Concaténation
Une chaîne peut être construite à partir de plusieurs autres chaînes. On parle alors de concaténa-
tion de chaînes. Pour concaténer deux chaînes, il suffit d’utiliser l’opérateur "+".
// La fonction Info permet d’afficher le résultat à l’écran
Info(SAI_TEXT2 + SAI_TEXT1)
Extraction de parties d’une chaîne

L’extraction d’une partie d’une chaîne peut être réalisée avec :
• les opérateurs [[ et ]] (attention il ne faut pas d’espace entre les crochets [[ et ]]).
Info(SAI_Texte[[1 à 6]]) // Affiche "WinDev"
• la fonction ExtraitChaîne, qui extrait une sous-chaîne depuis une chaîne :

Info(ExtraitChaîne(SAI_Texte,1," ")) // Affiche "WinDev"
• la fonction Milieu, qui extrait un morceau de chaîne depuis une chaîne :

Info(Milieu(SAI_Texte,4,2)) // Affiche "De"
• la fonction Gauche, qui retourne la partie gauche d’une chaîne :
Info(Gauche(SAI_Texte,6)) // Affiche "WinDev"
• la fonction Droite, qui retourne la partie droite d’une chaîne :

Info(Droite(SAI_Texte,3)) // Affiche "ble"
Manipulations diverses
La taille d’une chaîne peut être connue avec la fonction Taille :
Info(Taille(SAI_TEXT2)) // Affiche 35
Une chaîne peut être transformée en majuscules avec la fonction Majuscule ou en minuscules
avec la fonction Minuscule :
Info(Majuscule(SAI_TEXT2))
Info(Minuscule(SAI_TEXT2))
Une chaîne peut être recherchée dans une autre avec la fonction Position :
ChaîneARechercher est une chaîne = "WinDev"
Pos est un entier
Pos = Position(SAI_Texte, ChaîneARechercher)
SI Pos = 0 ALORS
InfoConstruit ("%1 non trouvé dans le texte", ChaîneARechercher)
SINON
InfoConstruit("%1 trouvé dans le texte", ChaîneARechercher)
FIN
Vous pouvez également effectuer une recherche de position d’une chaîne de caractères dans
une autre sans tenir compte de la casse. Il suffit d’indiquer à la fonction Position la constante
SansCasse :
Pos = Position(SAI_TEXT2, ChaîneARechercher, 1, SansCasse)
Pour connaître le nombre d’occurrences d’une chaîne de caractères donnée dans une autre
chaîne de caractères, utilisez la fonction ChaîneOccurrence :
NbOccurrences est un entier
NbOccurrences = ChaîneOccurrence("anastasia", "a") // Renvoie 4
Il est également possible de rechercher une chaîne et de la remplacer en une seule opération
grâce à la fonction Remplace :
Remplace(SAI_Texte, "WinDev", "WinDev Mobile")
76 Partie 1 : A la découverte de WinDev

Pour construire une chaîne à partir d’une chaîne et du résultat d’une fonction,
il est conseillé d’utiliser la fonction InfoConstruit. Cette fonction permet de
construire le texte affiché en fonction de paramètres (%1, %2, ...) :
InfoConstruit("%1 non trouvé dans le texte", ...
ChaineARechercher)
Bien entendu, il est possible d’utiliser la concaténation simple :
Astuce
Info(ChaineARechercher + " non trouvé dans le texte")

L’utilisation de la fonction InfoConstruit présente plusieurs avantages :
• la lisibilité du code : une chaîne plus simple à lire
• la traduction : une chaîne peut être traduite dans son intégralité. Il est possible
d’inverser les mots et les paramètres. Le traducteur n’a qu’une obligation :
remettre les %1, %2, %3.
Selon le même principe, le WLangage propose les fonctions ChaîneConstruit,
ErreurConstruit, ...

petit exercice :
Dans le projet "WD Bases Programmation", ouvrez la fenêtre "FEN_Chaîne" si nécessaire :
double-cliquez sur son nom dans l’explorateur de projet.
Dans la zone "A vous de jouer", un exercice vous est proposé :
• Dans le bouton "Votre code", écrivez le code permettant d’afficher le 5ème mot du texte
manipulé en majuscules ainsi que la taille de ce mot.
Traitements des numériques
Les calculs sur les numériques peuvent être effectués à partir des champs de saisie de type
numérique ou directement en manipulant les variables typées (entier, réel, numérique, moné-
taire, ...).
Exemple pratique

Ouvrez la fenêtre "FEN_Numérique.WDW" : double-cliquez sur le nom de la fenêtre dans le
volet "Explorateur de projet".
Testez la fenêtre. Cette fenêtre présente un aperçu des manipulations sur les "numériques".
Principales manipulations sur les numériques
Initialisation
Un champ de saisie de type numérique peut être initialisé grâce à une des méthodes suivantes :
• l’onglet "Contenu" de la fenêtre de description du champ.
• par programmation en affectant directement la valeur numérique au nom du champ :
SAI_ValeurInitiale = 3.14
• par programmation en utilisant une variable de type numérique :
ent1 est un entier
ent1 = 1234
SAI_ValeurInitiale = ent1
Il est possible de concaténer une chaîne et un numérique avec l’opérateur "+" :

Info("Le champ SAI_ValeurInitiale contient la valeur : " + ...
SAI_ValeurInitiale)
Si vous exécutez le code suivant :

Info("Un calcul : " + 1 + 2)
Astuce
La boîte de dialogue affichera "Un calcul : 12".

Si vous souhaitez afficher le résultat du calcul, il faut utiliser le code suivant :
Info("Un calcul : " + (1 + 2))
La boîte de dialogue affichera "Un calcul : 3".
Manipulations diverses
Quelques exemples de manipulations de numériques réalisés en WLangage :
• La partie entière d’un nombre est connue par la fonction PartieEntière, la partie décimale
par la fonction PartieDécimale :
InfoConstruit("Partie entière de %1 : %2" + RC + ...
"Partie décimale de %1 : %3", SAI_RéelSigné, ...
PartieEntière(SAI_RéelSigné), ...
PartieDécimale(SAI_RéelSigné))
• La valeur absolue d’un nombre est retournée par la fonction Abs :

InfoConstruit("Valeur absolue de %1 : %2", ...
SAI_RéelSigné, Abs(SAI_RéelSigné))
• La valeur arrondie d’un nombre est retournée par la fonction Arrondi :

InfoConstruit("Arrondi de %1 : %2", ...
SAI_RéelSigné, Arrondi(SAI_RéelSigné, 1))
• La fonction Racine permet de calculer la racine Nième d’un nombre :

InfoConstruit("Racine carrée de %1 : %2", ...
SAI_Reference_Racine, Racine(SAI_Reference_Racine, 2))
• La fonction Puissance permet d’élever un nombre à la puissance N :

InfoConstruit("Puissance 2 de %1 : %2", ...
SAI_Reference_Puissance, Puissance(SAI_Reference_Puissance, 2))
Remarque : le type des champs de saisie numériques

Lorsqu’un champ est défini comme numérique, on ne connaît pas a priori son type (entier, réel,
réel double, ...). Son type est défini automatiquement en fonction du masque sélectionné pour le
champ.
Pour forcer le type d’un champ, il suffit d’utiliser une variable typée. Par exemple :
Val1 est un entier
Val1 = 123456789
SAI_NUM1 = Val1 // Affectation du champ
Val1 = SAI_NUM1 // Récupération du champ

petit exercice :
Dans le projet "WD Bases Programmation", ouvrez la fenêtre "FEN_Numérique" si nécessaire :
double-cliquez sur son nom dans l’explorateur de projet.
• Dans le bouton "Votre code", écrivez le code qui permet d’afficher le résultat de la soustrac-
tion des champs "Montant 1" et "Montant 2" arrondi à 1 décimale.
Traitement des monétaires
Exemple pratique

Ouvrez la fenêtre "FEN_RéelMonétaire.wdw" (double-cliquez sur son nom dans le volet
"Explorateur de projet").
Testez la fenêtre. Cette fenêtre permet de tester les différents codes présentés dans ce
paragraphe.
Détails
Le type "Monétaire" est un réel codé sur 10 octets. Il permet de donner la solution à deux pro-
blèmes non résolus par les réels :
• avoir plus de 15 chiffres significatifs (les réels doubles gèrent 15 chiffres significatifs maximum),
le type "Monétaire" gère 23 chiffres significatifs.
• éviter une erreur induite par le codage binaire des réels :
• Un réel gère jusqu’à 15 chiffres significatifs. Or, en réalité, le codage binaire des réels ne
permet pas de coder tous les réels de 15 chiffres significatifs.
• Le type "Monétaire" a un codage différent des réels qui n’induit pas d’erreur d’arrondi.
En effet, le code suivant donne un résultat faux :
// Avec une variable de type Réel, le calcul est faux
Reel est un Réel
Reel = 18.6 - 8.6 - 10
Erreur("18.6-8.6-10=" + Reel)
Pour tester ce code, cliquez sur le bouton "Soustraction de réels" dans la fenêtre de test.
Par contre avec le code suivant, le calcul est correct :
Monetaire est un Monétaire
Monetaire = 18.6 - 8.6 - 10
Info("18.6-8.6-10=" + monetaire)
Pour tester ce code, cliquez sur le bouton "Soustraction de monétaires" dans la fenêtre de
test.
Pour effectuer des divisions sur des monétaires, il est conseillé de passer par des variables inter-
médiaires de type "Monétaire".
Monetaire1, Monetaire2 sont des monétaires

// Attribue un nombre aux deux variables monétaires
Monetaire1 = "12 345 678 901 234 567,123456"
Monetaire2 = "12 345 678 901 234 567,123456"
// Division de Monétaire1 par Monétaire2
Monetaire1 = Monetaire1/Monetaire2
// Affiche le résultat de la division
Info("12 345 678 901 234 567,123456"," divisé par ",...
"12 345 678 901 234 567,123456 "," = "+Monetaire1)
Pour tester ce code, cliquez sur le bouton "Division d’un monétaire" dans la fenêtre de test.
Pour faire des calculs avancés, le WLangage met également à votre disposition
le type Numérique. Par défaut, le type Numérique correspond à 32 chiffres pour
Remarque
la partie entière et 6 chiffres pour la partie décimale (comme le type monétaire).

Mais l’avantage du type numérique est de pouvoir configurer le nombre de
chiffres à utiliser pour la partie entière et le nombre de chiffres à utiliser pour la
partie décimale.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Numérique").
Mélange de chaînes et de numériques
Les numériques et les chaînes font bon ménage. WinDev est très souple dans les affectations de
variables. Ainsi il est possible d’affecter une chaîne de chiffres dans une variable numérique et
inversement. Par exemple :
i est un entier
c est une chaîne
i = 123
c = i // la variable c contient la chaîne "123"
c = "456"
i = c // la variable i contient la valeur 456
Si vous voulez transformer un nombre en une chaîne de caractères en respectant un format bien
précis, il suffit d’utiliser la fonction NumériqueVersChaîne. Par exemple :
NumériqueVersChaîne(1234.567,"012,3f") // renvoie "00001234,567"
A chaque fois que vous devez utiliser la fonction NumériqueVersChaîne et que vous ne savez pas
exactement quels paramètres utiliser, utilisez l’assistant de code proposé par WinDev : cet assis-
tant vous donnera la syntaxe à utiliser en fonction du résultat souhaité.
Sous l’éditeur de code, lors de la saisie du nom d’une fonction suivi de la paren-
thèse ouvrante, plusieurs informations peuvent être affichées dans une liste :
Notes
• le nom de l’assistant correspondant à la fonction. Si vous sélectionnez

cette option, un assistant se lance. Grâce à des questions simples, cet as-
sistant écrit automatiquement la syntaxe voulue.
• le nom d’un exemple utilisant cette fonction. Si vous sélectionnez cette op-
tion, l’exemple est automatiquement ouvert sous l’éditeur.
La fonction "inverse" de NumériqueVersChaîne est la fonction Val. Cette fonction permet de

convertir une chaîne en un numérique.
Traitements des dates et des heures

Pour gérer simplement les dates et les heures dans vos applications, WinDev met à votre dispo-
sition :
• un champ de saisie de type Date, Heure ou Durée. Avec ce champ, plus aucun problème pour
saisir une date ou une heure valide.
• un champ libellé de type Date, Heure ou Durée. Avec ce champ, plus aucun problème pour affi-
cher une date ou une heure au bon format.
• des variables de type Date, Heure, DateHeure et Durée. Ces variables simplifient la manipula-
tion des dates et des heures par programmation et permettent de multiples calculs.
Les dates
Exemple pratique

Ouvrez la fenêtre "FEN_Date.WDW". Cette fenêtre illustre les explications données dans la
suite de cette leçon.
Masque de saisie et valeur retournée
Les dates (comme les heures) sont des chaînes qui ont un format prédéfini.
Dans un champ de saisie de type "Date" (ou de type "Heure"), il faut distinguer :
• Le masque de saisie : c’est le format avec lequel la date et l’heure seront saisies.
• Le masque d’affichage : c’est le format avec lequel la date et l’heure seront affichées.
• La valeur retournée (ou mémorisée) : c’est la valeur retournée par le champ vers le programme.
Ces informations sont saisies dans la fenêtre de description du champ de saisie.
Dans la fenêtre "FEN_Date", affichez la fenêtre de description du champ "Saisissez une date"
(option "Description" du menu contextuel du champ). Affichez l’onglet "Général" de cette
fenêtre. Les informations affichées sont les suivantes :
Par exemple, pour un champ de type "Date" :

• le masque de saisie sera "JJ/MM/AAAA". La date saisie par l’utilisateur sera de la forme
"01/11/2013".
• le masque d’affichage sera "JJJJ JJ MMMM AAAA". La date affichée dans le champ sera de la
forme "Jeudi 18 Juillet 2013".
• la valeur retournée sera par défaut "AAAAMMJJ" (Exemple : la valeur saisie sous la forme
"23/04/2013" retournera au programme "20130423").
Remarque
Il existe la possibilité de choisir un masque de saisie de type "Date système".

Dans ce cas, le format affiché sera celui défini dans les "Paramètres régionaux
du panneau de configuration de Windows" de la machine en cours d’exécution.
Pour comprendre l’importance et les relations entre le masque de saisie et la valeur retournée,
regardons les exemples suivants :
• Si le masque de saisie et d’affichage d’un champ date est "JJ/MM/AA" et la valeur
retournée est "AAAAMMJJ" :
DATEJ = "20131225" // Affiche la date sous la forme "25/12/13"
DATEJ = "131225" // Affiche la date sous une forme incorrecte
La date affichée sera incorrecte.
• Si le masque de saisie et d’affichage d’un champ date est "MM/JJ/AAAA" et la valeur
retournée est "AAMMJJ" :
DATEJ = "131225" // Affiche la date sous la forme "12/25/2013"
DATEJ = "20131225"// Affiche la date sous une forme incorrecte
La date affichée est incorrecte.
Il faut donc faire attention au format de la valeur retournée dans un champ de type date ou
heure.
Les fonctions du WLangage qui manipulent :
• des dates utilisent le format "AAAAMMJJ".
• des heures utilisent le format "HHMMSSCC" (certaines utilisent le format "HHMMSSCCMMM",
pour la gestion des millisecondes).
Rappel : Par défaut, le format (masque de saisie) du champ correspond au

masque date défini dans l’onglet "Langues" de la fenêtre de description du projet
(sous le volet "Projet", dans le groupe "Projet", cliquez sur "Description"). Ainsi, le
Notes
même masque est utilisé automatiquement dans tous les champs de type date
de l’application.
Cette fonctionnalité est également très utile dans les applications multilingues.
Nous allons maintenant voir comment gérer les dates par programmation.
1. Fermez si nécessaire la fenêtre de description du champ.
2. Testez la fenêtre "FEN_Date" ( parmi les boutons d’accès rapide).
Quel jour sommes-nous ?
Pour connaître la date du jour, il suffit d’utiliser la fonction DateDuJour (ou DateSys). La fonction
DateDuJour retourne la date système de votre ordinateur sous la forme d’une chaîne de carac-
tères au format "AAAAMMJJ". Exemple :
Info("Nous sommes le " + DateDuJour())
Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton "DateDuJour".
Comme vous pouvez le constater, la date affichée est au format "AAAAMMJJ".
Pour afficher la date sous un format plus explicite, il suffit d’utiliser la fonction DateVersChaîne :
Info("Nous sommes le " + DateVersChaîne(DateDuJour(),...
MaskDateSystème))
La fonction DateVersChaîne transforme une chaîne au format "AAAAMMJJ" en chaîne au format

choisi. La constante MaskDateSystème permet d’utiliser le format de date défini dans l’onglet
"Langues" des caractéristiques du projet.
Rappel : Pour afficher les caractéristiques du projet, sous le volet "Projet", dans le groupe "Projet",
cliquez sur "Description".
Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton "DateVersChaîne".
Quel jour sommes-nous, mais avec le jour et le mois en lettres ?
Pour afficher la date en toutes lettres, il faut utiliser la fonction DateVersChaîne en utilisant un
format de date spécifique :
Info("Nous sommes le " + DateVersChaîne(DateDuJour(),...
"JJJJ JJ MMMM AAAA")
Dans ce code :
• la chaîne "JJJJ JJ" permet d’obtenir le jour en toutes lettres. Par exemple : Mardi 17.
• la chaîne "MMMM" permet d’obtenir le mois en toutes lettres. Par exemple : Septembre.
• la chaîne "AAAA" permet d’obtenir l’année. Par exemple : 2013.
Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton "En lettres".
Quel est le nombre de jours entre 2 dates ?
Vous voulez savoir combien de jours se sont écoulés entre deux dates ? C’est très simple : il suffit
d’utiliser la fonction DateDifférence :
NombreJour est un entier
NombreJour = DateDifférence("20100101", DateDuJour())
InfoConstruit(...
"Le nombre de jours entre le %1 et le %2 est : %3", ...
DateVersChaîne("20100101", maskDateSystème),...
DateVersChaîne(DateDuJour(), maskDateSystème), NombreJour)
Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton "DateDifférence".
Il est également possible d’obtenir la durée entre la date du jour et une date
spécifique sous forme d’un texte clair (il y a deux jours, dans 3 semaines, ...). Il
suffit d’utiliser :
Remarque
• soit le masque d’affichage de type "Durée relative",

• soit la fonction DateVersChaîne avec la constante maskDateDuréeRelative.
Par exemple :
// A la date du 22/01/2013
Res = DateVersChaîne("20130101", maskDateDuréeRelative)
// Renvoie : il y a 3 semaines
Quel est le jour de la semaine d’une date donnée ?

Toujours aussi simplement, vous pouvez connaître le jour de n’importe quelle date avec la fonc-
tion DateVersJourEnLettre :
J est une chaîne
J = DateVersJourEnLettre("17890714")
Info("Le 14 juillet 1789 était un " + J)
Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton
"DateVersJourEnLettre".
Petit exercice pratique

Maintenant que vous maîtrisez les dates, une colle : que fait le code suivant ?
DateVersChaîne(DateDuJour(),"JJJJ JJ MMM AAAA")
Réponse : Affiche la date littérale (le jour et la date en clair).
Manipulation des variables de type Date

Le WLangage propose des types de variables spécifiques pour les valeurs de type Date, DateHeure
ou de Durée.
Ces variables sont assimilables à des "chaînes". Chacune contient une valeur selon le tableau
suivant :
Type Format par défaut
Date AAAAMMJJ
DateHeure AAAAMMJJHHMMSSCC
Durée AAAAMMJJHHMMSSCC
Le type "Date" permet de gérer des dates comprises entre le 01/01/0001 et le 31/12/9999 (de
quoi être tranquille pour un bon moment !).
Plus sérieusement, pour manipuler la valeur de ces variables, vous pouvez utiliser les syntaxes
suivantes :
MaDate est une Date = "20121021"
Info(DateVersChaîne(MaDate)) //Affiche "21/10/2012"
MaDate..Année = MaDate..Année + 1
MaDate..Mois = MaDate..Mois + 1
MaDate..Jour = MaDate..Jour + 1
Info(DateVersChaîne(MaDate)) //Affiche "22/11/2013"
Dans ce code, Année, Mois et Jour sont des propriétés WLangage.

Dans la fenêtre "FEN_Date", le bouton "Exemple de code" permet de calculer la date du
prochain 1er Janvier en utilisant une variable de type Date.
Le code utilisé est le suivant :
MaDate est une Date
// MaDate est automatiquement initialisée à la date du jour
// Calcul de la date du prochain 1er Janvier

NouvelleAnnée est une Date
NouvelleAnnée..Année++
NouvelleAnnée..Jour = 1
NouvelleAnnée..Mois = 1
MaDurée est une Durée = NouvelleAnnée - MaDate
Info(ChaîneConstruit(...
"Il reste %1 jours avant le prochain réveillon du jour de l’an",...
" le %2.", MaDurée..EnJours, DateVersChaîne(NouvelleAnnée))

Pour mettre en application les différentes manipulations sur les dates, nous vous proposons un
petit exercice :
Dans le projet "WD Bases Programmation", ouvrez la fenêtre "FEN_Date" si nécessaire
(double-cliquez sur son nom dans l’explorateur de projet).
• Dans le bouton "Votre code", écrivez le code qui permet de calculer la date qu’il sera dans
180 jours et affichez cette date en lettres.
Les heures
Exemple pratique
Ouvrez si nécessaire le projet "WD Bases Programmation.WDP".

Ouvrez la fenêtre "FEN_Heure.WDW". Cette fenêtre illustre les explications données dans la
suite de cette leçon.
Testez cette fenêtre.
Quelle heure est-il ?

Pour connaître l’heure, il suffit d’utiliser la fonction Maintenant (ou HeureSys). La fonction
Maintenantretourne l’heure actuelle de votre système sous la forme d’une chaîne de caractères
au format "HHMMSSCC" :
Info("Il est " + Maintenant())
Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton "Maintenant".
Vous souhaitez afficher l’heure au format standard "HH:MM:SS:CC" ? Le code devient alors :
Info("Il est " + HeureVersChaîne(Maintenant()))
La fonction HeureVersChaîne transforme une heure au format "HHMMSSCC" en une chaîne au

format "HH:MM:SS:CC".
Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton "HeureVersChaîne".
Pour ne pas afficher les centièmes de seconde, le code est :
Info("Il est " + HeureVersChaîne(Maintenant(), "HH:MM:SS"))
Il suffit de préciser le format d’affichage de l’heure avec la fonction HeureVersChaîne.

Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton "Sans les cen-
tièmes".
Combien de temps s’est-il écoulé entre deux heures ?

Il est 17h25. Combien de temps s’est écoulé depuis 12h15 ? Le code est le suivant :
// Affiche le temps écoulé depuis 12h15

Diff est un entier = HeureDifférence("1215", Maintenant())
Résultat_Temps est une chaîne = EntierVersHeure(Abs(Diff))
SI Diff < 0 ALORS

InfoConstruit(...
"Temps écoulé avant 12:15 -> %1 h %2 min %3 s ", ...
Résultat_Temps..Heure, Résultat_Temps..Minute, ...
Résultat_Temps..Seconde)
SINON
"Temps écoulé depuis 12:15 -> %1 h %2 min %3 s ", ...
Résultat_Temps..Heure, Résultat_Temps..Minute, ...
Résultat_Temps..Seconde)
FIN
La fonction EntierVersHeure transforme un entier (qui correspond au nombre de centièmes de

secondes écoulées depuis minuit (ou 00h00)) vers une heure sous la forme "HHMMSSCC".
La fonction HeureVersEntier effectue l’opération inverse.
Attention !
• Ne mettez pas de ":" dans l’heure passée en paramètre à la fonction

HeureVersEntier, cela fausserait le résultat.
• Pour calculer des durées de plus de 24 heures, utilisez les types Date, Heure, ...
Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton "1er exemple".
Le même calcul peut être effectué en utilisant les variables de type Heure et Durée.
Le WLangage propose des types de variables spécifiques pour les valeurs de type Date, Heure,
DateHeure ou de Durée. Ces variables sont assimilables à des "chaînes". Chacune contient une
valeur selon le tableau suivant :
Type Format par défaut
Heure HHMMSSCC
Durée AAAAMMJJHHMMSSCC
Le code peut devenir :
Dans12H est une Heure
Dans12H..Heure+= 12
Dans12H..Minute+= 30
InfoConstruit("Dans 12 heures et 30 minutes, il sera %1", ...
HeureVersChaîne(Dans12H, "HH:MM"))
Pour tester cette fonctionnalité dans notre exemple, cliquez sur le bouton "2 ème
exemple".

Pour mettre en application les différentes manipulations sur les dates, nous vous proposons un
petit exercice :
Dans le projet "WD Bases Programmation", ouvrez la fenêtre "FEN_Heure" si nécessaire
• Dans le bouton "Votre code", écrivez le code qui permet d’afficher le temps restant avant
23h59 au format HH:MM.
Calculs avec des dates et des heures

Le WLangage possède de très nombreuses fonctions pour gérer les dates et les heures et effec-
tuer différents calculs.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Date, Fonctions WLangage").
Leçon 1.5. Questions / Réponses
• Questions / Réponses
Questions / Réponses
Question Comment visualiser l’élément auquel appartient le traitement en cours ?
Pour visualiser l’élément correspondant au traitement en cours, sous le volet "Code", dans le
groupe "Navigation", cliquez sur "Aller à l’objet" (CTRL + ALT + F2). La fenêtre contenant l’élément
voulu s’affiche.
Question Comment imprimer le code source ?
Le code source en cours peut être imprimé directement en cliquant sur l’icône dans le volet
"Accueil" ou grâce à la combinaison de touches [CTRL] + [P].
Question Comment faire un "rechercher et/ou remplacer" ?
Les fonctions de recherche ou de remplacement (dans le code, l’interface, ...) sont accessibles
depuis le volet "Accueil", dans le groupe "Rechercher" ou dans le volet "Rechercher - Remplacer"
(CTRL + F) :
Vous pouvez ensuite définir les différentes caractéristiques de la recherche à effectuer.
Question Que signifient les signes "+" ou "-" dans l’éditeur de code ?
L’éditeur de code permet d’enrouler ou de dérouler le code WLangage. Cette fonctionnalité est
très utile si vos traitements utilisent de nombreuses instructions structurées (boucles, condition,
parcours, ...).
Pour replier un code, sous le volet "Affichage", déroulez "Replier" et sélectionnez l’option de menu
"Replier tout" (ou le raccourci [CTRL] + [SHIFT] + * (du clavier numérique)).
Seuls les commentaires restent visibles. Le survol de chaque ligne de commentaire permet de
visualiser le code associé dans une bulle :
La combinaison de touches [CTRL] + * (du clavier numérique) permet de déplier tout le code. Le
clic sur les symboles "-" ou "+" permet d’enrouler ou de dérouler uniquement la partie de code
correspondante.
Question Est-il possible d’identifier la personne qui a écrit une ligne de code ?
L’appui de la touche [F6] permet d’afficher les informations (nom et date de la création/modifica-
tion) de chaque ligne de code.
Question Est-il possible de connaître le numéro d’une ligne de code ?
Dans l’éditeur de code, pour activer (ou non) la numérotation des lignes de code, sous le volet
"Affichage", dans le groupe "Aide à l’édition", cliquez sur "Afficher les numéros de ligne".
Question Existe-t-il un moyen d’obtenir facilement la syntaxe ou de l’aide sur une
fonction ?
Lors de la frappe d’une fonction, la syntaxe de la fonction s’affiche :

• dans une bulle d’aide au-dessous de la ligne en cours de saisie. Pour chaque paramètre (y
compris le résultat de la fonction), une bulle explicative est affichée.
Si plusieurs syntaxes sont disponibles, il est possible de passer d’une syntaxe à l’autre
grâce aux touches [ALT] + flèche droite ou flèche gauche.
• dans la barre de message de l’éditeur.
Dans l’aide affichée, les paramètres entourés par [ et ] sont optionnels.
Pour les fonctions utilisant des noms de fichiers de données, de champs, de fenêtres, ou d’états,
la saisie assistée permet d’afficher la liste des éléments du projet correspondant au paramètre
de la fonction en cours de saisie.
Exemple de saisie assistée pour la fonction HLitPremier : l’option <Assistant> permet de lancer
un assistant de code. Cet assistant vous pose différentes questions sur l’utilisation de la fonction
et génère automatiquement le code correspondant.
Toutes les fonctions et les propriétés du WLangage ont une aide associée. Cette aide est directe-
ment accessible depuis l’éditeur en appuyant sur la touche [F1] sur le nom de la fonction ou de la
propriété voulue.
Question Quels sont les raccourcis clavier à connaître sous l’éditeur de code ?
• [CTRL]+[L] supprime la ligne en cours.

• [CTRL]+[D] duplique la ligne en cours (ou les lignes sélectionnées) sur la ligne du dessous.
• [TAB] et [SHIFT]+[TAB] permettent de gérer l’indentation de l’ensemble des lignes sélectionnées.
• [CTRL]+[/] met en commentaires les lignes sélectionnées, [CTRL]+[SHIFT]+[/] enlève les com-
mentaires (Attention touche [/] du pavé numérique).
• [F2] sur le nom d’un champ, d’une méthode, d’une classe, d’une procédure ou d’un bloc d’état
affiche le traitement de cet objet.
• [CTRL]+[F2] permet de revenir au traitement initial.
Il est possible par l’appui répété sur la touche [F2] de se déplacer d’un traitement à un
autre. Pour revenir sur le traitement initial, il suffit d’appuyer autant de fois sur les touches
[CTRL]+[F2].
• [CTRL]+[R] permet de réindenter automatiquement le code affiché.
Question Comment dialoguer avec l’utilisateur ?
Il suffit d’utiliser une boîte de dialogue avancée. Ces boîtes de dialogue permettent de gérer :
• l’interrogation directive (fonction Dialogue) : l’utilisateur répond à une question grâce à des
boutons contenant le texte de l’action à effectuer.
• la saisie immédiate (fonction Saisie), en proposant à l’utilisateur de saisir directement dans
la boîte de dialogue la valeur voulue.
Pour plus de détails sur ces fonctions, consultez l’aide en ligne (mot-clé : "Dialogue" et "Saisie").
Pour tester les différents modes de dialogue avec l’utilisateur :
1. Ouvrez si nécessaire le projet "WD Bases Programmation.WDP" : sous le volet "Accueil", dans
le groupe "Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez "Bases de la pro-
grammation".
2. Ouvrez la fenêtre "FEN_Dialogue.WDW". Cette fenêtre illustre les différents modes de dia-
logue possibles.
3. Testez cette fenêtre (bouton "GO").
4. Cliquez sur les différents boutons pour tester les différents modes de dialogue.
5. Arrêtez le test de cette fenêtre et revenez sous l’éditeur de code pour étudier le code de
chaque bouton.
Pour mettre en application les différentes manipulations sur les boîtes de dialogues, nous
vous proposons un petit exercice :
1. Dans le projet "WD Bases Programmation", ouvrez la fenêtre "FEN_Dialogue" si nécessaire
2. Dans la zone "A vous de jouer", un exercice vous est proposé :
• Dans le bouton "Votre code", écrivez le code qui permet de demander à l’utilisateur son pré-
nom. Affichez ce prénom dans la barre de message et dans une boîte d’information. Si l’uti-
lisateur annule la saisie du prénom, affichez un toast pour indiquer cette annulation.
PARTIE 2
Ma première
base de données
98 Partie 2 : Ma première base de données (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite
• Présentation du projet réalisé dans cette partie
Durée estimée : 5mn
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Partie 2 : Ma première base de données 99
Présentation du projet réalisé dans cette partie
Dans cette partie, nous allons créer un projet associé à une base de données HFSQL.
Vous allez ainsi découvrir des éléments clés de la conception d’une application :
• Création d’un projet WinDev.
• Description des fichiers de données manipulés par l’application.
Dans une prochaine partie, nous nous concentrerons sur le développement des éléments (fe-
nêtres, états, ...) d’une application avec données, que nous développerons de A à Z, de la création
de l’interface à la distribution finale. Vous verrez ainsi tous les points importants du développe-
ment d’une application.
Dans cette partie, la base de données que nous allons créer ensemble est une gestion de com-
mandes.
Le même type de base de données sera ensuite utilisé dans la partie 3 de ce cours pour dévelop-
per une application complète. La base de données utilisée est HFSQL Classic, la base de données
gratuite fournie avec WinDev. Plus loin dans ce cours, nous étudierons la base de données HFSQL
Client/Serveur.
Leçon 2.2. WinDev et les bases de
données

• Vocabulaire utilisé.
• Les différents modes d’accès aux bases de données.
Présentation
Lors de la conception d’une application, vous pouvez être amené à manipuler des données. Pour
les stocker, vous devez constituer ce que l’on nomme "une base de données".
Dans WinDev, lors de la création d’un projet manipulant des données, vous devez tout d’abord
créer une "analyse".
Une "analyse" contient la description des fichiers de données (ou tables) contenant les données
de l’application.
C’est seulement lors de l’exécution de l’application, que ces descriptions sont utilisées pour créer
la base de données et/ou les fichiers de données. C’est dans cette base ou dans ces fichiers de
données que seront stockées les informations.
Notes
Plusieurs outils de maintenance des bases de données HFSQL sont livrés en

standard avec WinDev. Ils sont accessibles depuis le Centre de Contrôle HFSQL.
WinDev sait gérer différents formats de base de données (pour ne pas dire tous). Les formats les
plus courants sont :
• HFSQL, système de base de données intégrée à WinDev et livrée en standard. La base de
données HFSQL est disponible en mode Classic ou Client/Serveur.
• AS/400, Access, Sybase, Informix, ...
• Oracle, SQL Server, MySQL, xBase, …
• Toute base accessible en langage SQL sous Windows.
• Texte (fichiers ASCII).
Pour accéder aux données, il existe différentes techniques (appelées "modes d’accès") :
• Accès Natif,
• Accès OLE DB,
• Accès ODBC direct,
• Accès ODBC via OLE DB.
Les différents modes d’accès aux bases de données
Accès Natif
Un accès natif manipule directement et exclusivement un format de base de données. Ce type
d’accès optimisé est développé spécialement pour chaque format de base de données.
Dans WinDev, il existe un accès natif pour les bases de type :
• HFSQL Classic ou Client/Serveur (en standard)
• xBase (en standard)
• Access (en standard)
• XML (en standard)
• SQLite (en standard)
• Oracle (optionnel)
• AS/400 (optionnel)
• SQL Server (optionnel)
• Sybase (optionnel)
• Informix (optionnel)
• DB2 (optionnel)
• Progress (optionnel)
• MySQL (optionnel et gratuit)
• PostGreSQL (optionnel et gratuit)
D’autres accès natifs seront bientôt disponibles, contactez notre service commercial !
Les fonctions WLangage SQL* et HLit* sont utilisables avec ce type d’accès. Le code est ainsi
portable et indépendant de la base de données.
Accès ODBC direct

Un accès via ODBC direct utilise un standard d’accès multi-bases. Vous devez installer la couche
ODBC 32 bits sur votre machine. Cette couche est en général déjà installée sur les versions ré-
centes de Windows. Vous pouvez le vérifier dans le panneau de configuration de Windows en
choisissant l’option "Administrateur ODBC".
Attention : toutes les bases de données ne sont pas obligatoirement accessibles via cette mé-
thode. Si vous souhaitez utiliser ce type d’accès, vérifiez qu’il existe un pilote ODBC.
Seules les fonctions WLangage SQL* sont utilisables avec ce type d’accès.
Accès OLE DB
Un accès via OLE DB est un accès qui utilise un standard d’accès multi-bases. Ce type d’accès est
basé sur le MDAC (Microsoft Data Access Component) de Microsoft.
Attention !
Si vous utilisez un accès OLE DB, vous devez obligatoirement installer le MDAC
sur les postes utilisateurs (version 2.6 minimum).
Toutes les bases de données ne sont pas obligatoirement accessibles via cette méthode. Si vous
souhaitez utiliser ce type d’accès, vérifiez qu’il existe un pilote OLE DB.
Les fonctions WLangage SQL* et HLit* sont utilisables avec ce type d’accès.
Accès ODBC via OLE DB

En résumé, il s’agit d’un "mélange" de OLE DB et de ODBC. Cette technique est la plus "lourde" et
la moins efficace en terme de performances. Il est déconseillé de l’utiliser sur des bases de petite
taille.
Les fonctions WLangage SQL* et HLit* sont utilisables avec ce type d’accès.
HFSQL
HFSQL est une base de données à la fois très puissante, très rapide et très robuste.
HFSQL fonctionne sous Windows et Linux, sur Mobiles (iOS, Android, Windows), sur les réseaux
de toute taille et de tout type, et gère automatiquement plusieurs centaines d’accès simultanés.
La diffusion de HFSQL est libre et gratuite avec vos applications WINDEV.
HFSQL propose toutes les fonctionnalités d’une base de données, notamment :

• la journalisation,
• les transactions,
• la réplication,
• les triggers.
Pour plus de détails sur la mise en place de ces fonctionnalités, consultez l’aide en ligne.
Dans les différentes parties de ce cours d’auto-formation, nous allons manipuler une base de
données HFSQL Classic puis une base HFSQL Client/Serveur.
Leçon 2.3. Projet et analyse
• Création d’un projet

• Création d’une analyse
Présentation
Pour créer une application avec une base de données, il faut :
• Créer le projet lié à l’application. Ce projet regroupera tous les éléments de l’application (fe-
nêtres, codes, requêtes, états, ...).
• Créer l’analyse liée au projet. L’analyse permet de décrire tous les fichiers de données manipu-
lés par l’application.
Création du projet
Pour créer le projet :

1. Lancez WinDev si ce n’est pas déjà fait. Si nécessaire fermez le projet en cours.
2. Dans la fenêtre de bienvenue, cliquez sur le bouton "Créer un projet", puis sur l’option "Ap-
plication Windows ou Linux". L’assistant de création de projet se lance. Les différents écrans
de l’assistant vont vous aider à créer votre projet. Tous les renseignements indiqués dans cet
assistant pourront être modifiés par la suite.
Astuce : Pour créer un projet, vous pouvez également :

Notes
1. Cliquer sur parmi les boutons d’accès rapide du menu de WinDev.

2. Dans la roue qui s’affiche, cliquer sur "Projet".
3. Le premier écran de l’assistant permet de saisir le nom du projet, son emplacement et sa

description. Dans notre cas, ce projet va simplement s’appeler "WD Ma Première Base De
Données". Par défaut, WinDev propose de créer ce projet dans le répertoire "\Mes projets\
WD Ma Première Base De Données". Vous pouvez conserver cet emplacement ou le modifier
grâce au bouton [...]. Pour le résumé du projet, saisissez "Le projet a pour but de gérer des
clients et leurs commandes".
4. Les différentes étapes de l’assistant sont indiquées à gauche de l’assistant. Ces étapes
sont directement clicables. Les autres écrans de l’étape "Description" n’étant pas fondamen-
taux, cliquez directement sur "Chartes".
5. Cette étape permet de définir la charte de programmation utilisée. Ne modifiez pas les
options proposées. Passez à l’écran suivant à l’aide des flèches situées en bas.
6. Cette étape permet de définir la charte graphique. Sélectionnez "Elegant". Passez à l’écran
suivant à l’aide des flèches situées en bas.
7. Nous choisissons une taille de 800x600 pour les écrans, car notre application n’aura pas
de grandes fenêtres et sera ainsi adaptée à la plupart des résolutions utilisées. Le choix serait
différent pour une application de gestion d’images par exemple.
8. Cliquez sur l’étape "Le saviez-vous". Cet écran permet de gérer l’affichage d’une fenêtre de
type "Le saviez-vous".
Nous n’afficherons pas cette fenêtre : sélectionnez l’option "Ne pas afficher la fenêtre ‘Le
saviez-vous’ au lancement de l’application". Passez à l’écran suivant.
9. Nous allons maintenant donner les renseignements concernant la base de données.
10. Sélectionnez l’option "Oui, créer une nouvelle base de données" et validez. L’assistant de
création de l’analyse se lance.
Pour suivre les différentes leçons de cette partie et optimiser votre apprentis-
sage de WinDev, il est conseillé de créer le projet "WD Ma Première Base De
Données".
Notes
Un exemple corrigé est disponible à tout moment pour vérifier la validité des opé-
rations effectuées.
Pour ouvrir ce projet corrigé, sous le volet "Accueil", dans le groupe "Aide en
ligne", déroulez "Guide d’Auto-formation" puis sélectionnez "Ma première base de
données (Corrigé)".
Création de l’analyse
Les étapes de l’assistant de création d’analyse sont les suivantes :

1. Indiquez le nom et le répertoire de l’analyse. Par défaut, le nom de l’analyse correspond au
nom du projet et le répertoire de l’analyse est un répertoire ".ana" dans le répertoire du projet.
Nous allons conserver ces paramètres par défaut. Passez à l’écran suivant de l’assistant.
2. Vous pouvez ensuite choisir le ou les types de bases de données manipulées par le projet.
Sélectionnez HFSQL Classic (la base de données proposée par défaut avec WinDev).
Passez à l’écran suivant de l’assistant.

3. Validez. L’assistant de création d’un fichier de données se lance automatiquement.
Création de la description des fichiers de données
Notre application de gestion de clients et de commandes va être associée à l’analyse suivante.
Cette analyse comportecinq fichiers de données différents :
• Client
• Commande
• ModeRèglement
• LigneCommande
• Produit
Pour créer les différents fichiers de données de cette analyse, nous allons utiliser différentes mé-
thodes disponibles dans WinDev.
Création d’un fichier de données : utilisation d’un fichier pré-défini
Les étapes de l’assistant de création d’un fichier de données sont les suivantes :
1. Sélectionnez dans l’assistant l’option "Sélectionner une description parmi des fichiers de
données prédéfinis". Passez à l’écran suivant de l’assistant (flèche en bas de l’assistant).
2. La liste des fichiers de données pré-définis est affichée. Nous allons créer le fichier
"Client". Dans la liste des fichiers de données, sélectionnez "Client". Passez à l’écran suivant.
3. L’assistant propose la liste des rubriques à intégrer dans le fichier Client. Cette liste est
impressionnante, mais elle permet de gérer de nombreux types de fichiers Client.
4. Cochez uniquement les rubriques suivantes : IDClient, Société, Nom, Prénom, Adresse, Co-
dePostal, Ville, EtatDep, Pays, Téléphone, Mobile, Email.
5. Validez l’assistant.
6. Cliquez sur "Editeur de WinDev".
Le fichier "Client" est automatiquement créé sous l’éditeur d’analyses.
Il est possible d’agrandir le fichier affiché. Il suffit de cliquer sur le fichier, de sélectionner la poi-
gnée noire en bas du fichier et de déplacer la souris vers le bas.
Création d’un fichier de données : création du fichier et des rubriques

Nous allons maintenant créer le fichier de données contenant les commandes.
Pour créer un fichier de données :
1. Sous le volet "Analyse", dans le groupe "Création", cliquez sur "Nouveau fichier".
2. L’assistant de création d’un nouveau fichier de données se lance.
3. Sélectionnez dans l’assistant l’option "Créer une nouvelle description d’un fichier de don-
nées". Passez à l’écran suivant de l’assistant.
4. Nous allons créer le fichier "Commande". Saisissez son nom "Commande" dans l’assistant.
Ce nom sera utilisé :
- pour manipuler le fichier de données en programmation. La variable associée au fichier sera
"Commande".
- pour construire le nom du fichier de données physique associé (fichier "Commande.fic").
Automatiquement, le libellé et la description des éléments représentés par les enregistre-
ments du fichier de données apparaissent.
Dans l’assistant, le champ "Un enregistrement représente" indique l’information
Notes qui sera utilisée pour décrire les liaisons entre les fichiers de données. Il est im-
portant de renseigner avec soin cette information !
Dans notre cas, saisissez "Une commande".
5. Dans la zone "Identifiant automatique", conservez l’option "Identifiant automatique sur 8

octets". Si un identifiant automatique est défini sur le fichier de données, cela signifie que le
fichier de données possède une clé unique, gérée automatiquement par WinDev.
Pour créer l’identifiant (un identifiant est une clé unique), vous pouvez créer une
rubrique numérique de type "Identifiant automatique".
Notes
Cet identifiant est automatiquement géré par WinDev. Chaque fois qu’un enre-
gistrement est ajouté dans le fichier de données, WinDev affecte automatique-
ment une valeur à l’identifiant du fichier. Cette valeur est unique.
6. Passez à l’écran suivant et sélectionnez le type de la base associée au fichier de données.

Nous allons travailler sur des fichiers de données HFSQL Classic. Passez à l’écran suivant.
7. Cliquez sur le bouton vert pour valider. Le fichier de données est automatiquement créé
dans l’analyse. La fenêtre de description des rubriques s’ouvre.
Nous allons saisir les rubriques du fichier "Commande". Dans la fenêtre de description du fichier
de données, vous pouvez déjà voir qu’une rubrique a été automatiquement créée : "IDCom-
mande". Cette rubrique correspond à l’identifiant automatique du fichier de données. Cette ru-
brique est composée des lettres "ID" et du nom du fichier.
Nous allons créer les autres rubriques de ce fichier de données.
Tout d’abord, nous allons créer la rubrique "Date". Cette rubrique contiendra la date de la
commande.
1. Dans la fenêtre de description des rubriques, cliquez dans la colonne "Nom" de la première
ligne vide deux fois. Cette colonne passe automatiquement en saisie. Saisissez "Date".
2. Cliquez dans la colonne "Libellé". Automatiquement, le nom de la rubrique apparaît. Nous
allons modifier le libellé de la rubrique en cliquant dessus : saisissez "Date de la commande".
Dans la colonne "Type", le type "Texte" est automatiquement sélectionné. Déroulez la liste et
sélectionnez le type "Date".
3. Cette rubrique va être une clé de notre fichier de données : les clés permettent d’accélérer
les accès aux données ou de faciliter les parcours des fichiers de données. Il sera possible de
faire des recherches ou des parcours sur cette rubrique.
La notion de clé fait partie des caractéristiques d’une rubrique. En fait, lors de la
création d’une rubrique, vous avez la possibilité d’indiquer si elle est :
• non clé,
Notes
• clé unique : la valeur de cette clé sera unique dans l’ensemble du fichier de
données (c’est-à-dire dans tous les enregistrements du fichier de données)
• clé avec doublons : la valeur de cette clé pourra être présente plusieurs fois
dans le fichier de données.
4. La définition de la clé se fait de la manière suivante : re-sélectionnez la ligne de la rubrique

"Date" pour activer les champs de description présents sur la droite de l’écran. Il suffit alors de
préciser le type de clé utilisé. Dans notre cas, la date est une clé avec doublons.
Nous allons maintenant créer la rubrique "Etat" qui permet de connaître l’état de la com-
mande.
1. Positionnez-vous sur une nouvelle ligne de la table. Saisissez :
• le nom : Etat
• le libellé : Etat de la commande
• le type : Sélecteur, Liste, Combo. Dans la fenêtre qui s’ouvre, vous pouvez sélectionner le
type de champ utilisé par défaut pour cette rubrique. Ici, ce sera un sélecteur. Validez la fe-
nêtre.
2. Dans la partie basse de l’écran, cliquez sur la double flèche pour afficher les paramètres
du champ lié à la rubrique sélectionnée.
Les informations saisies ici seront automatiquement utilisées lors de la création des fenêtres
liées au fichier de données. Vous retrouvez ici le type du champ et le libellé.
Nous allons saisir les options suivantes dans l’onglet "Contenu" :
• Cliquez sur l’onglet "Contenu".
• Cliquez sur le bouton "+" pour ajouter la première option.
• L’option 1 correspond à En attente. Saisissez "En attente" dans le champ de saisie à droite
du sélecteur.
• Cliquez sur le bouton "+" pour ajouter la seconde option.
• Saisissez "Validée" à la place de "Option 2".
• Cliquez à nouveau sur le bouton "+".
• Saisissez "Annulée" à la place de "Option 3".
3. Cliquez à nouveau sur la double flèche.
4. De la même manière :
• Positionnez-vous sur une nouvelle ligne de la table et créez la rubrique "TotalHT". Cette ru-
brique est de type "Monétaire".
• Positionnez-vous sur une nouvelle ligne de la table et créez la rubrique "TotalTTC". Cette ru-
brique est de type "Monétaire".
5. Voilà, la description du fichier "Commande" est terminée. Validez la fenêtre de description
des rubriques.
6. Le fichier "Commande" apparaît sous l’éditeur d’analyses. Il est possible d’agrandir le fi-
chier affiché. Il suffit de cliquer sur le fichier, de sélectionner la poignée noire en bas du fichier
et de déplacer la souris vers le bas.
Importation d’un fichier CSV

Pour créer le fichier "ModeRèglement", contenant les caractéristiques du règlement, nous allons
utiliser une autre méthode : l’import d’un fichier CSV. À partir du fichier CSV contenant les don-
nées, WinDevva créer :
• la description du fichier de données dans l’analyse,
• le fichier de données HFSQL avec les données présentes dans le fichier CSV.
Pour importer un fichier CSV dans l’analyse :

1. Dans l’explorateur de fichiers de Windows, ouvrez le sous-répertoire de WinDev suivant : "\
Autoformation\Exercices\WD Ma Première Base De Données".
2. Sélectionnez le fichier "ModeRèglement.csv".
3. Réalisez un "Drag and Drop" du fichier "ModeRèglement.csv" vers l’éditeur d’analyses de
WinDev. L’assistant d’importation de fichiers se lance.
4. Passez à l’écran suivant.
5. Sélectionnez le format des fichiers à importer. Ici, sélectionnez "Fichier texte". Passez à
l’écran suivant de l’assistant.
6. WinDev indique le chemin du fichier à importer. Passez à l’écran suivant de l’assistant.

7. Indiquez les paramètres d’importation suivants :
N’oubliez pas de cocher l’option "La première ligne contient les noms des colonnes".
9. La structure du fichier de données qui va être créé apparaît. Conservez les options par
défaut. Passez à l’écran suivant.
10. Le contenu du fichier CSV va être automatiquement converti au format HFSQL. L’assistant
vous propose de créer le fichier HFSQL dans le répertoire du projet. Conservez les options
proposées et passez à l’écran suivant.
11. Validez l’assistant. L’assistant de conversion des données se lance.
Examinons la description du fichier de données importé :
1. Sélectionnez le fichier "ModeRèglement" puis l’option "Description du fichier de données" du
menu contextuel.
2. Dans la fenêtre qui s’affiche, modifiez le libellé du fichier : supprimez "(Importé)".
3. Cliquez sur le bouton "Valider".
4. Cliquez sur l’icône pour afficher la description des rubriques du fichier de données.
5. Ce fichier de données ne contient pas d’identifiant automatique ni de clé unique. Nous
allons passer la rubrique "Code" en clé unique :
• Positionnez le bandeau de sélection si nécessaire sur la rubrique "Code".
• Dans la partie droite de l’écran, cliquez sur "Clé unique".
6. Nous obtenons les données suivantes :
7. Validez la fenêtre de description des rubriques puis la fenêtre de description du fichier.
Importation directe de fichiers de données existants

La dernière méthode que nous allons voir pour créer des fichiers de données est la simple impor-
tation de fichiers de données HFSQL existants. Nous allons utiliser cette méthode pour créer le
fichier "Produit".
Pour importer des fichiers de données HFSQL :

1. Dans l’explorateur de fichiers de Windows, ouvrez le sous-répertoire de WinDev suivant :
"\Autoformation\Exercices\WD Ma Première Base De Données".
2. Sélectionnez le fichier "Produit.fic".
3. Réalisez un "Drag and Drop" du fichier "Produit" vers l’éditeur d’analyses de WinDev.
4. L’assistant d’importation se lance. Validez les différents écrans. Le fichier de données ap-
paraît sous l’éditeur d’analyses.
Tous les fichiers de données nécessaires sont maintenant présents dans l’éditeur d’analyses.
Important : Pour manipuler les données du fichier que vous venez d’importer, copiez les fichiers
"Produit.fic", "Produit.mmo" et "Produit.ndx" (présents dans le répertoire "\Autoformation\Exer-
cices\WD Ma Première Base De Données") vers le répertoire EXE de votre projet.
Notes
Pour ouvrir directement l’explorateur de fichiers sur le répertoire de votre projet,

sous le volet ‘Accueil", dans le groupe "Général", cliquez sur .
Création des liaisons
Nous avons créé toutes les descriptions de fichiers nécessaires à l’application de gestion de
comptes.
Maintenant nous allons créer les liaisons entre les fichiers de données.
Créons tout d’abord la liaison entre le fichier "Client" et le fichier "Commande".
1. Sous le volet "Analyse", dans le groupe "Création", cliquez sur "Nouvelle liaison". Le curseur
de la souris se transforme en crayon.
2. Cliquez sur le fichier "Client" puis sur le fichier "Commande".
3. L’assistant de création de liaison se lance.
4. Répondez aux questions posées par l’assistant :
• Chaque Client a au moins une Commande : Non
• Chaque Client peut avoir plusieurs Commandes : Oui
• Chaque Commande a au moins un Client : Oui
• Chaque Commande peut avoir plusieurs Clients : Non
Notes
Vous pouvez également saisir directement les cardinalités de la liaison dans

l’assistant.
5. Passez à l’écran suivant. L’assistant propose automatiquement la clé utilisée par la liaison
(IDClient).
6. Affichez l’écran suivant de l’assistant. L’assistant propose de créer une nouvelle clé dans le
fichier Commande.
7. Acceptez cette option en passant à l’écran suivant.

8. Validez les règles d’intégrité en passant à l’écran suivant.
9. Cliquez sur la flèche verte. La liaison est automatiquement créée dans l’éditeur d’analyses.
De la même manière, créez une liaison entre le fichier ModeRèglement et Commande.
• Les cardinalités sont les suivantes : ModeRèglement (0,n), Commande (0,1)
• La clé de liaison correspond à la rubrique "Code".
Nous allons maintenant créer une liaison entre le fichier "Produit" et "Commande". Cette
liaison va nous permettre de créer un fichier de liaison.
1. Sous le volet "Analyse", dans le groupe "Création", cliquez sur "Nouvelle liaison". Le curseur
de la souris se transforme en crayon.
2. Cliquez sur le fichier "Commande" puis sur le fichier "Produit".
3. L’assistant de création de liaison se lance.
4. Répondez aux questions posées par l’assistant :
• Chaque Commande a au moins un Produit : Non
• Chaque Commande peut avoir plusieurs Produits : Oui
• Chaque Produit a au moins une Commande : Non
• Chaque Produit peut avoir plusieurs Commandes : Oui
5. Passez à l’écran suivant. L’assistant propose de créer un fichier de relation. Conservez l’op-
tion "Créer automatiquement le fichier de relation" et passez à l’écran suivant.
6. L’assistant propose la clé unique du fichier Commande à utiliser "IDCommande". Passez à
l’écran suivant.
7. Validez la création de la clé en passant à l’écran suivant.
8. Conservez les options par défaut concernant les règles d’intégrité et passez à l’écran sui-
vant.
9. L’assistant propose la clé unique du fichier Produit à utiliser. Sélectionnez "Référence". Pas-
sez à l’écran suivant.
10. Validez la création de la clé en passant à l’écran suivant.
11. Conservez les options par défaut concernant les règles d’intégrité et passez à l’écran sui-
vant.
12. Cliquez sur la flèche verte. Le fichier de relation est automatiquement créé dans l’éditeur
d’analyses.
Nous allons maintenant modifier le fichier de relation qui a été créé par WinDev. En effet, ce fi-
chier va contenir les lignes de commande. Nous allons :
• Modifier le nom du fichier.
• Modifier le nom de ses rubriques.
• Ajouter des rubriques pour connaître la quantité de produit commandé et le total de la ligne de
commande.
Nous allons tout d’abord renommer le fichier. Nous avons déjà réalisé une manipulation
similaire lorsque nous avons changé le libellé du fichier importé. Mais ici, ce n’est pas juste
un libellé qui va être modifié : nous allons également renommer le fichier physique lié à la
description du fichier.
1. Sélectionnez le fichier "Commande_Produit" puis l’option "Description du fichier de données"
du menu contextuel.
2. Dans la fenêtre qui s’affiche, modifiez :
• le nom du fichier : "LigneCommande".
• le nom sur le disque : "LigneCommande".
3. Cliquez sur le bouton "Valider".
Nous allons maintenant modifier les rubriques de ce fichier de relation.
1. Cliquez sur l’icône pour afficher la description des rubriques du fichier de données.
2. Ce fichier comporte 3 rubriques. Positionnez le bandeau de sélection sur la rubrique "ID-

Commande_Produit". Cette rubrique est une clé composée.
Une clé composée est une clé qui est composée de plusieurs rubriques du
même fichier de données.
Notes
Ce type de clé permet de parcourir le fichier de données sur des critères plus
complexes ou de faire des recherches plus précises.
3. Pour renommer cette rubrique :

• Cliquez dans la colonne "Nom".
• Remplacez "IDCommande_Produit" par "IDLigneCommande".
• Cliquez dans la colonne "Libellé".
• Remplacez le libellé actuel par "Identifiant de LigneCommande".
Nous allons maintenant ajouter 3 nouvelles rubriques dans ce fichier de relation : Quantité,
TotalHT et TotalTTC.
1. Positionnez-vous sur une nouvelle ligne et créez la rubrique "Quantité". Cette rubrique est de
type "Numérique".
2. Positionnez-vous sur une nouvelle ligne de la table et créez la rubrique "TotalTTC". Cette
rubrique est de type "Monétaire".
3. Une fenêtre s’affiche, indiquant que la rubrique existe déjà dans l’analyse et proposant de
reprendre ses caractéristiques :
4. Conservez les options sélectionnées par défaut et validez (bouton vert).

5. Positionnez-vous sur une nouvelle ligne de la table et créez la rubrique "TotalHT". Cette ru-
brique est de type "Monétaire". Là encore, reprenez la description existante.
6. La description des rubriques pour le fichier "LigneCommande" est la suivante.
7. Validez la description des rubriques (bouton vert en bas de l’écran) et celle du fichier.
L’analyse est alors la suivante :
Génération de l’analyse
La génération de l’analyse consiste à rendre disponible aux autres modules du projet, les infor-
mations sur les fichiers de données. Ces fichiers de données pourront être manipulés dans les
programmes.
Sans la génération, bien que la description du fichier de données existe, vous ne pourrez pas utili-
ser le fichier de données dans vos programmes.
Lors de la génération de l’analyse, toutes les modifications effectuées sur l’analyse et les fichiers
de données seront automatiquement propagées dans tout le projet (fenêtres, champs reliés,
états, ...).
La génération doit être effectuée à chaque fois que vous voulez que les modifi-
cations effectuées dans l’analyse soient prises en compte dans les programmes
Attention!
utilisant cette analyse.

Si vous modifiez l’analyse plusieurs fois, sans programmer entre chaque modifi-
cation, il n’est pas nécessaire de générer l’analyse à chaque modification. Géné-
rez uniquement l’analyse lorsque toutes les modifications sont faites et que vous
passez à la programmation.
Pour générer l’analyse :

1. Sous l’éditeur d’analyses, sous le volet "Analyse", dans le groupe "Analyse", cliquez sur "Géné-
ration".
2. La génération de l’analyse est automatiquement lancée.
Nous avons modifié les descriptions des fichiers de données présents dans l’analyse.
Pour mettre à jour les fichiers de données de l’application, WinDev lance automatiquement la
procédure de modification des fichiers de données. Cette opération permet de mettre à jour les
fichiers de données (fichiers ".fic") en fonction de leur description dans l’analyse.
L’assistant de modification automatique se lance. Validez les différents écrans jusqu’à
l’écran listant les fichiers à prendre en compte.
• WinDev détecte que le fichier ModeRèglement nécessite une mise à jour. Conservez ce fi-
chier sélectionné et passez à l’écran suivant.
• L’assistant propose de réaliser une sauvegarde des fichiers de données existants, ne chan-
gez rien et passez à l’écran suivant.
• L’assistant propose de saisir des mots de passe de protection des fichiers de données mo-
difiés par la modification automatique. Conservez les options par défaut et passez à l’écran
suivant.
• La liste des fichiers de données à modifier apparaît. Validez l’assistant.
• La mise à jour des fichiers de données est effectuée.
Fermez l’éditeur d’analyses.
Vous venez de découvrir les principales étapes pour la création d’une analyse.
Lorsque votre analyse est décrite et générée, il est également possible de :

• Créer une application complète grâce au RAD (Rapid Application Developpement). Nous allons
créer l’application correspondant à l’analyse de cette manière dans la leçon suivante.
• Créer une application complète entièrement personnalisée. Cette méthode sera utilisée pour
développer une application complète basée sur une base de données dans la partie 3 de ce
cours d’auto-formation. Cette application sera basée sur une analyse correspondant à celle que
vous avez créée dans cette partie.
Leçon 2.4. Le RAD complet
• Qu’est-ce le RAD ?
• Génération du RAD
• Test du projet
Qu’est-ce que le RAD ?
R.A.D. sont les initiales de "Rapid Application Developpement".
Le RAD permet de construire automatiquement une application, c’est-à-dire construire toutes les
fenêtres, les états et les requêtes nécessaires.
Comme nous l’avons vu précédemment, pour développer une application en WinDev, il faut com-
mencer par créer un projet et éventuellement une analyse. L’analyse contient la définition des
structures des fichiers de données manipulés dans les traitements.
Le module RAD de WinDev s’appuie sur cette analyse. Le module RAD est constitué d’un assis-
tant dans lequel vous pouvez choisir le modèle d’application à générer (le pattern RAD) et les
principales options de fonctionnement de votre application.
WinDev est livré avec différents "Patterns RAD", permettant de générer plusieurs
Note
modèles d’application. Vous pouvez également créer vos propres patterns RAD.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Pattern RAD").
Toutes les fenêtres, les états, les requêtes et le code générés par le RAD sont entièrement per-
sonnalisables. Vous avez également la possibilité de modifier les types de champs, les valeurs par
défaut, ...
Le RAD permet également de générer des fenêtres de plusieurs types, c’est le RAD fenêtre. Le
RAD Fenêtre est disponible lorsque vous créez une nouvelle fenêtre dans votre application.
Nous allons ici découvrir comment utiliser le module RAD Projet.
RID (Rapid graphical Interface Design)

WinDev permet également de générer des fenêtres contenant uniquement les
Note
champs liés aux rubriques de l’analyse. Tout le code nécessaire au fonctionne-

ment de ces fenêtres reste à la charge du développeur.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "RID").
Génération du RAD
Pour lancer la génération du RAD :

1. Sous le volet "Projet", dans le groupe "Génération", cliquez sur "RAD Application complète".
L’assistant de génération de l’application RAD se lance.
2. Sélectionnez le modèle à utiliser pour la génération du RAD : par exemple "RAD Simple".
Passez à l’écran suivant de l’assistant.
3. Tous les fichiers de données de l’analyse vont être pris en compte :
4. Affichez l’écran suivant.
5. Les points d’entrée de l’application correspondent aux entrées disponibles dans le menu.
Conservez uniquement les fichiers Client, Commande, ModeRèglement et Produit. Affichez

l’écran suivant.
6. Indiquez si les champs Table générés dans les fenêtres de l’application doivent permettre la
saisie ou non. Dans notre exemple, les champs Tables permettront à l’utilisateur de saisir de
nouvelles informations. Sélectionnez "Oui : Autoriser la saisie dans les champs table". Affichez
l’écran suivant.
7. Indiquez si le groupware utilisateur doit être utilisé dans l’application. Nous le verrons plus
tard dans une prochaine partie de ce cours. Sélectionnez l’option "Non : Ne pas intégrer la
gestion du groupware utilisateur". Passez à l’écran suivant.
8. Indiquez si le menu automatique doit être intégré à l’application. Répondez "Oui : Intégrer
le menu ‘?’".
9. Passez à l’écran suivant. L’assistant de génération du RAD se termine et l’assistant de gé-

nération du menu automatique se lance.
Le menu automatique est un menu d’aide adapté à vos applications. Ce menu

Note
permettra aux utilisateurs de vos applications d’accéder directement à plusieurs

fonctionnalités.
Les différentes étapes de l’assistant de génération du menu automatique sont les suivantes :
1. Conservez l’option "Aide des FAA (Fonctionnalités Automatiques de l’Application)".

2. Terminez l’assistant.
Lors de la création du menu ‘?’, l’option "? .. Aide des FAA (Fonctionnalités Auto-
matiques de l’Application)" a ajouté automatiquement dans votre application :
Notes
• le composant "CCMenu". En effet, cette option utilise une procédure de ce

composant pour fonctionner.
• le fichier "WinDev FAA 19.PDF". Ce fichier sera automatiquement ouvert
lors de l’utilisation de l’option de menu.
L’application est générée et peut être testée.
Des erreurs d’IHM peuvent apparaître dans le volet des erreurs de compilation.
Notes
Ces erreurs signalent des problèmes d’interface notamment dans les états (libel-
lés trop longs par exemple). Pour corriger ces erreurs, il est nécessaire de modi-
fier les états.
Test de l’application
Testons immédiatement l’application générée.
Pour lancer le test de l’application :
1. Cliquez sur parmi les boutons d’accès rapide de WinDev. L’application se lance.
2. Dans le menu, sélectionnez l’option "Clients/Prospects .. Liste des Clients/Prospects".
3. La liste des clients s’affiche.
4. Pour ajouter une nouvelle personne, cliquez sur le bouton "Nouveau". Un formulaire de sai-
sie apparaît.
5. Saisissez des informations concernant un client et validez.

6. Fermez la liste des personnes.
7. Dans le menu, sélectionnez l’option "Produit .. Liste des Produit". La liste des produits appa-
raît.
Modification rapide : Verrouillage de l’application
Bien souvent, lors de l’utilisation d’une application, celle-ci reste en cours sur le poste de l’utilisa-
teur alors que celui-ci n’est pas présent (réunion, repas, ...). Pour éviter l’utilisation de l’application
par des personnes non autorisées, il est possible de verrouiller automatiquement l’application.
Pour se reconnecter, l’utilisateur devra utiliser son identifiant et son mot de passe Windows.
Pour utiliser cette fonctionnalité, quelques clics de souris suffisent.
Pour verrouiller une application :
1. Affichez la description du projet : sous le volet "Projet", dans le groupe "Projet", cliquez sur
"Description".
2. Affichez l’onglet "Avancé".
3. Spécifiez les options de verrouillage (par exemple 2 minutes).
Si l’application n’est pas utilisée pendant 2 minutes, la fenêtre suivante sera affichée :
L’utilisateur n’aura qu’à saisir son mot de passe Windows pour continuer à utiliser l’application.
Si le Groupware Utilisateur est utilisé par l’application (voir "Identifier l’utilisa-

Notes
teur : le groupware utilisateur", page 264), le mot de passe à utiliser sera celui
défini pour le Groupware Utilisateur.
Pour tester le verrouillage de l’application, lancez le test de l’application et attendez 2

minutes.
La fenêtre de demande de mot de passe apparaît. Saisissez votre mot de passe Windows et
validez.
Pour ne pas alourdir nos prochains tests, nous allons supprimer cette option.
Affichez à nouveau la description du projet :
1. Sous le volet "Projet", dans le groupe "Projet", cliquez sur "Description".
2. Dans l’onglet "Avancé", décochez l’option "Verrouiller l’application...". Validez.
PARTIE 3
Application
complète avec
données
136 Partie 3 : Application complète avec données (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite
• Présentation de l’application réalisée dans cette partie
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Partie 3 : Application complète avec données 137
Présentation de l’application réalisée dans cette partie
Dans cette partie, nous allons réaliser une application manipulant des fichiers de données au
format HFSQL Classic.
Cette application de gestion de commandes permettra de :
• Visualiser, saisir et modifier des produits,
• Imprimer des états,
• Afficher des statistiques,
• Gérer des niveaux d’utilisation,
• Envoyer des emails,
• ...
Le développement de cette application nous permettra également d’aborder le déploiement et la
diffusion de l’application auprès des clients finaux.
Vous verrez ainsi tous les points importants du développement d’une application.
Projets fournis
Projet exemple
Nous avons déjà vu dans la partie précédente comment créer un projet et une analyse. Nous n’y
reviendrons pas. Nous allons travailler sur un projet contenant déjà une analyse et des fichiers de
données pré-remplis. L’analyse de l’application est une version améliorée de l’analyse que vous
avez créée dans la partie précédente.
Pour ouvrir ce projet sous WinDev :
1. Si nécessaire, fermez le projet en cours pour faire apparaître la fenêtre de bienvenue.
2. Dans la fenêtre de bienvenue, cliquez sur "Cours d’auto-formation" et sélectionnez le projet
"Application complète (Exercice)".
"Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez l’option "Application com-
plète (Exercice)".
Avant de commencer à développer l’application, arrêtons-nous un instant sur l’analyse associée

au projet "WD Application complète".
Pour afficher l’analyse liée au projet, cliquez sur parmi les boutons d’accès rapide.
L’éditeur d’analyses s’affiche :
Cette analyse contient la description de 5 fichiers de données :
• Client,
• Commande,
• LigneCommande,
• Produit,
• ModeRèglement.
Cette analyse est volontairement simple et permet de gérer un cas classique de gestion de com-
mandes.
Fermez l’éditeur d’analyses (cliquez sur la croix en haut à droite du menu).
Projets corrigés
Vous hésitez sur le résultat à obtenir ? ou vous n’avez pas le temps de réaliser toutes les manipu-
lations ? Un projet corrigé de l’application est disponible.
L’application que nous allons réaliser ensemble étant relativement longue (c’est une application
complète qui va nous permettre de découvrir les principales fonctionnalités de WinDev), nous
vous proposons deux projets corrigés :
• Un projet corrigé correspondant aux leçons 3.2 à 3.4. Ce projet contient toutes les fenêtres
réalisées dans ces leçons.
Pour utiliser ce projet corrigé :
"Application complète (Avec fenêtres)".
plète (Avec fenêtres)".
• Un projet corrigé correspondant aux leçons 3.5 à 3.9. Ce projet contient la totalité de l’applica-
tion proposée.
Pour utiliser ce projet corrigé :
"Application complète (Corrigé)".
plète (Corrigé)".
Leçon 3.2. Fenêtres d’ajout et de
modification
• Création d’une fenêtre de menu listant les produits.

• Création d’une fiche produit.
• Gestion de l’ajout et de la modification d’un produit.
Présentation
Nous allons créer les différentes fenêtres permettant de lister, ajouter et modifier des produits.
Ces manipulations vous feront découvrir plusieurs aspects de la gestion des fichiers de données
et vous feront également utiliser certaines fonctionnalités bien utiles de WinDev.
Si vous n’avez pas ouvert le projet "WD Application Complète" dans la leçon précédente :
"Application complète (Exercice)".
plète (Exercice)".
Un projet corrigé est disponible. Ce projet contient les différentes fenêtres

Corrigé
créées dans cette leçon. Pour ouvrir le projet corrigé, sous le volet "Accueil", dans
le groupe "Aide en ligne", déroulez "Guide d’auto-formation" puis sélectionnez
Création d’une fenêtre listant les produits

Pour créer la fenêtre listant les produits, nous allons tout d’abord créer une fenêtre vierge, puis
ajouter tous les champs : nous verrons ainsi toutes les étapes nécessaires à la programmation
d’une telle fenêtre.
Pour créer une fenêtre listant les produits :

1. Créez une nouvelle fenêtre vierge.
• Cliquez sur parmi les boutons d’accès rapide.
• Dans la roue qui s’affiche, cliquez sur "Fenêtre".
• Cliquez sur l’onglet "Basée sur un modèle" et choisissez "Utiliser : FENMOD_Modèle". Vali-
dez l’assistant.
Qu’est-ce qu’un modèle de fenêtres ?
Un modèle de fenêtres permet de donner un look homogène aux différentes
fenêtres d’une application.
Un modèle de fenêtres contient tous les éléments graphiques communs à l’en-
semble des fenêtres de l’application. Un modèle de fenêtres peut également
contenir du code. Dans ce cas, ce code sera également commun à toutes les
Notes
fenêtres de l’application.
Pour cet exemple nous avons créé le modèle de fenêtres FENMOD_Modèle. Ce
modèle contient un logo qui apparaîtra sur toutes les fenêtres :
2. La nouvelle fenêtre apparaît sous l’éditeur.

3. Enregistrez la fenêtre : cliquez sur parmi les boutons d’accès rapide.
4. Dans la fenêtre qui s’affiche, indiquez le titre de la fenêtre : "Menu".
5. Le nom de la fenêtre (qui sera utilisé par exemple en programmation) est automatique-
ment déduit du titre de la fenêtre. Si ce nom ne vous convient pas, il est possible de le modi-
fier et de spécifier un titre différent du nom de la fenêtre.
6. Validez.
Nous avons appelé cette fenêtre "Menu" car cette fenêtre est la fenêtre princi-
Notes
pale de notre application. Elle va servir de menu mais également afficher des
informations.
Création des champs
Pour créer la liste des produits, nous allons utiliser un champ Table. Ce champ va être lié au
fichier de données "Produit".
Qu’est-ce qu’un champ Table ?

Il ne faut pas confondre "Table" et "champ Table".
On parle de Table pour une base de données de type SQL.
On parle de champ Table pour visualiser en tableau des données (ou "browse"
ou encore "feuille de données"). Dans ce cas, ces données peuvent être saisies
ou provenir d’un fichier de données (ou d’une table).
Notes
Le champ Table WinDev permet de visualiser ou de modifier des données :

• en mémoire : on parle alors de champ Table mémoire ou champ Table
rempli par programmation.
• provenant de fichiers de données ou de requêtes : on parle alors de champ
Table fichier.
• provenant de variables WLangage : on parle alors de champ Table sur
source.
Pour créer le champ Table :

1. Sous le volet "Création", dans le groupe "Données", déroulez "Table et liste" et sélectionnez
"Table (Verticale)". Le champ en création suit alors le mouvement de la souris.
2. Cliquez dans la fenêtre : l’assistant de création du champ Table se lance.
3. Le champ Table que nous sommes en train de créer doit afficher les enregistrements du fi-
chier de données "Produit". Dans l’assistant, sélectionnez l’option "Afficher des données d’un
fichier ou d’une requête existante". Passez à l’écran suivant en cliquant sur la flèche en bas
de l’écran.
4. L’écran suivant de l’assistant propose les différents fichiers de données et les requêtes
présents dans le projet en cours. Dépliez "Analyse" si nécessaire et sélectionnez le fichier
"Produit". Passez à l’écran suivant.
5. L’assistant propose la liste des rubriques présentes dans le fichier de données. Par défaut,
toutes les rubriques sont cochées pour être affichées dans le champ Table. Dans notre cas,
nous allons afficher toutes les rubriques SAUF l’identifiant "IDProduit", qui correspond à l’iden-
tifiant automatique du fichier de données.
Décochez "IDProduit" et passez à l’écran suivant.

6. L’assistant propose ensuite de sélectionner la rubrique de tri. Cette rubrique va être utilisée
pour trier les données affichées dans le champ Table. Les rubriques proposées dans l’assis-
tant correspondent à des rubriques définies comme clés dans l’analyse. Nous allons trier les
produits selon leur libellé.
Cliquez sur la ligne "Libellé" et passez à l’écran suivant.
7. Les écrans suivants correspondent à des paramètres supplémentaires. Conservez les op-
tions par défaut jusqu’à la fin de l’assistant puis validez l’assistant.
8. Le champ Table est automatiquement créé dans la fenêtre.
Nous allons repositionner le champ dans la fenêtre et l’agrandir :
1. Sélectionner le champ à l’aide de la souris : des poignées apparaissent tout autour du champ.
2. Déplacez le champ à l’aide de la souris pour le positionner en haut à gauche de la fenêtre.
Lorsque le champ atteint le bandeau "WD Application Complète", vous pouvez voir apparaître
des traits spécifiques : ce sont les règles de positionnement qui permettent d’optimiser le
positionnement des champs les uns par rapport aux autres dans la fenêtre.
3. Agrandissez le champ Table vers le bas à l’aide des poignées pour qu’il occupe la totalité de
la fenêtre.
Agrandissement du champ Table

Notes
Par défaut, le champ Table s’agrandit par ligne entière. Pour agrandir le champ
Table sans tenir compte de la hauteur des lignes, maintenez la touche SHIFT
enfoncée lors de l’agrandissement.
Arrêtons-nous un instant sur le champ que nous venons de créer : les données sont déjà affichées
dans le champ, même sous l’éditeur. C’est le concept du "Live data" : le contenu des fichiers de
données présents sur le poste de développement est utilisé dans les fenêtres ou les états mani-
pulés sous l’éditeur. Cette fonctionnalité est très intéressante par exemple pour définir la taille
des champs présents dans une fenêtre.
Test de la fenêtre
Nous allons tout de suite tester la fenêtre que nous venons de créer.
2. La fenêtre apparaît automatiquement avec ses données en exécution.
3. Vous pouvez faire défiler les produits grâce à l’ascenseur.
Mettons-nous quelques instants à la place de l’utilisateur final pour voir les possibilités du
champ Table en exécution.
Quelques remarques :
• Tout d’abord, en exécution le champ Table a le même aspect que sous l’éditeur : c’est la
notion de WYSIWYG ("What You See Is What You Get") : ce que vous voyez correspond à ce
que vous obtenez.
• Des petits pictogrammes apparaissent en haut des colonnes :
• la double flèche indique que la colonne peut être triée (colonne "Référence" ou "Libellé" par
exemple).
Par exemple, cliquez deux fois successivement sur la colonne "Libellé" : les données affi-
chées sont triées différemment. Une flèche à gauche de la colonne indique que la colonne
est triée ainsi que le sens de tri.
• la loupe indique qu’une recherche peut être réalisée directement dans la colonne.
Par exemple, cliquez sur la loupe de la colonne "Référence". Une zone de saisie apparaît et
vous permet de saisir la référence recherchée. Saisissez "REF-010". Automatiquement, le
produit correspondant à cette référence est affiché.
• Un menu contextuel est disponible sur le champ Table et sur chacune de ses colonnes. Ce
menu contextuel peut être affiché :
• par un clic droit sur la colonne du champ Table.
• par clic sur la flèche située à l’extrémité des en-têtes de colonnes.
Ce menu contextuel permet notamment d’exporter le contenu du champ Table au format
Excel, de l’imprimer, ...
En quelques minutes, nous venons de voir et de tester quelques fonctionnalités qui sont automa-
tiquement incluses avec le champ Table. Vous n’avez rien à programmer pour proposer ces fonc-
tionnalités à vos utilisateurs. Ces fonctionnalités sont appelées "FAA" (Fonctionnalités Automa-
tiques de l’Application).
De nombreux champs proposent des FAA par défaut. Si ces fonctionnalités ne
Notes doivent pas être proposées (pour des raisons de sécurité ou de confidentialité),
il est possible de les désactiver sous l’éditeur ou par programmation. Pour plus
de détails, consultez l’aide en ligne (mot-clé : "Fonctionnalités automatiques de
l’application").
Avoir la liste des produits, c’est bien, mais pouvoir modifier un produit, c’est mieux. Maintenant,
nous allons créer une fenêtre affichant le détail du produit afin de pouvoir le modifier.
Fermez la fenêtre en cours de test grâce à la croix située en haut de l’écran. L’éditeur de
WinDev réapparaît.
Création d’une fenêtre "Fiche produit"
Pour créer une fenêtre affichant le détail d’un produit :

1. Ouvrez si nécessaire le projet "WD Application Complète".
• Dans l’onglet "Basée sur un modèle", choisissez "Utiliser : FENMOD_Modèle" et validez l’as-
sistant.
3. Enregistrez la fenêtre ( ou CTRL S). Cette fenêtre a pour titre "Fiche du produit", son nom
"FEN_Fiche_du_produit" est automatiquement proposé. Validez la fenêtre de sauvegarde.
Création des champs de saisie

La fenêtre que nous allons créer est destinée à afficher les caractéristiques du produit sélec-
tionné dans le champ Table. Ce type de fenêtre est appelé une "Fiche" simplement car elle corres-
pond à une fiche descriptive de l’élément voulu.
Dans notre cas, cette fenêtre va afficher le contenu des différentes rubriques présentes dans le
Pour créer les champs dans la fenêtre :
1. Affichez si nécessaire le volet "Analyse" : sous le volet "Accueil", dans le groupe "Environne-
ment", déroulez "Volets" et sélectionnez "Analyse". Les différents fichiers de données décrits
dans l’analyse "WD Application Complète" apparaissent dans le volet.
2. Cliquez sur l’icône "+" à gauche du fichier "Produit" : les rubriques du fichier de données
sont listées.
3. Sélectionnez à l’aide de la souris l’ensemble des rubriques affichées dans le volet (sauf la
rubrique "IDProduit"). Vous pouvez par exemple utiliser le lasso de la souris ou la multisélec-
tion en maintenant la touche CTRL enfoncée.
4. Effectuez un "Drag and Drop" (glisser/déplacer) de ces rubriques vers la fenêtre que vous
venez de créer.
5. Différents champs sont automatiquement créés dans la fenêtre. Ces champs sont automa-
tiquement liés à la rubrique correspondante dans le fichier de données. Pour le vérifier :
• Sélectionnez par exemple le champ "Référence".
• Affichez le menu contextuel (clic droit) et sélectionnez l’option "Description".
• Affichez l’onglet "Liaison" de la fenêtre de description :
Cet onglet permet de voir que le champ de saisie en cours est lié à la rubrique "Référence" du
6. Fermez la fenêtre de description.
Repositionnez les champs dans la fenêtre et redimensionnez la fenêtre afin d’obtenir
l’interface suivante :
Création des boutons
La fenêtre "FEN_Fiche_du_produit" va permettre d’ajouter un nouveau produit ou encore de modi-
fier un produit présent dans la liste.
Nous allons tout de suite ajouter un bouton de validation et un bouton d’annulation.
Pour créer le bouton "Valider" :
flèche située sous ).
2. La liste des boutons prédéfinis s’affiche.
3. Cliquez sur "Valider" : la forme du bouton apparaît sous la souris.
4. Cliquez ensuite à droite des champs de saisie pour créer le bouton.
Ajoutez le bouton "Annuler" en utilisant le même principe.
2. Dans la liste des boutons prédéfinis, cliquez sur "Annuler" : la forme du bouton apparaît
sous la souris.
3. Cliquez ensuite en dessous du bouton "Valider" pour créer le bouton.
Améliorations de l’interface de la fenêtre

Cette fenêtre étant une fenêtre relativement simple, essayons d’améliorer son interface. De nom-
breux petits détails peuvent vite devenir gênants pour l’utilisateur, alors autant les traiter dès le
début.
Alignement des champs
Une des premières optimisations à faire consiste à aligner les champs et à leur donner la
même taille :
1. Sélectionnez le champ "Libellé" puis tous les autres champs de saisie de la fenêtre (par
exemple en maintenant la touche CTRL appuyée et en cliquant sur les différents champs). Le
premier champ sélectionné va servir de référence pour la taille des autres champs.
2. Affichez le volet "Alignement" du menu de WinDev. Ce volet contient toutes les options d’ali-
gnement disponibles pour les champs.
3. Nous voulons que les bords externes et internes des champs soient alignés. Cliquez sur
l’option "Justifier (Int et Ext)".
Si vous ne savez pas quel alignement choisir, survolez les différentes options
proposées par le volet "Alignement" de WinDev. Lors du survol avec la souris
d’une option, les champs sélectionnés dans la fenêtre sont automatiquement
Notes
positionnés en fonction de l’option survolée.

Si le positionnement vous convient, il suffit de cliquer sur l’option.
Si le positionnement ne vous convient pas, il suffit de cliquer dans la fenêtre : les
champs sont replacés à leur position d’origine.
Gestion des ancrages
Voyons maintenant le rendu visuel de notre fenêtre :

1. Sous le volet "Modification", dans le groupe "Aperçu", cliquez sur "Aperçu". Ce mode d’exécu-
tion permet d’afficher uniquement l’interface de la fenêtre. Les différents codes ne sont pas
exécutés.
2. Agrandissez la fenêtre à l’aide de la poignée d’agrandissement au bas de la fenêtre. La
position des champs n’est pas modifiée et la fenêtre affiche une grande zone vide. Pour remé-
dier à ce problème, deux possibilités :
• Interdire le redimensionnement de la fenêtre
• Gérer les ancrages, c’est-à-dire gérer le comportement des champs lors d’un redimension-
nement de la fenêtre. C’est ce que nous allons faire.
3. Fermez l’aperçu : cliquez soit sur le bouton "Fermer" de la télécommande, soit sur la croix
en haut à droite de la fenêtre.
Comment gérer les ancrages dans une fenêtre ?

Pour gérer les ancrages :
1. Sous l’éditeur, réduisez la fenêtre à sa taille minimale. Tous les bords exté-
Notes
rieurs de la fenêtre doivent être "collés" à un champ.

2. Passez les champs en revue un à un et posez-vous la question suivante
"Comment doit réagir le champ lors de l’agrandissement de la fenêtre ?". Ap-
pliquez alors l’ancrage correspondant.
Pour cette fenêtre, nous allons définir les ancrages ensemble :

1. Les boutons "Valider" et "Annuler" doivent toujours être collés à droite.
• Sélectionnez ces deux champs.
• Affichez le menu contextuel (clic droit) et sélectionnez l’option "Ancrage".
• Dans la fenêtre de définition des ancrages, sélectionnez l’option "Droite" et validez.
• Des petites flèches rouges apparaissent sous l’éditeur indiquant que les champs sont an-
crés à droite.
2. Les champs de saisie doivent s’agrandir en largeur :
• Sélectionnez les 4 champs de saisie.
• Affichez le menu contextuel (clic droit) et sélectionnez l’option "Ancrage".
• Dans la fenêtre de définition des ancrages, sélectionnez l’option "Largeur" ( ).
• Validez.
3. Nous allons tester à nouveau le fonctionnement de cette fenêtre en aperçu :
• Sous le volet "Modification", dans le groupe "Aperçu", cliquez sur "Aperçu".
• Agrandissez la fenêtre : les champs suivent bien l’agrandissement en largeur. Maintenant, il
reste à définir le fonctionnement lors de l’agrandissement en hauteur.
4. Le champ "Description" peut contenir une description du produit plus ou moins importante.
C’est le champ le plus important de la fenêtre : il est nécessaire qu’il occupe le maximum de
place disponible. Appliquez-lui un ancrage en largeur et hauteur ( ).
5. Le champ "Prix HT" est automatiquement encadré en rouge : l’éditeur de fenêtres indique
un problème d’ancrage. En effet, si le champ "Description" s’étire vers le bas, le champ "Prix
HT" doit lui aussi se déplacer de la même manière vers le bas.
6. Ouvrez la fenêtre des ancrages du champ "Prix HT". L’ancrage idéal est automatiquement
proposé : "Largeur et bas" (une coche verte est présente). Sélectionnez l’ancrage proposé et
validez.
7. Nous allons tester à nouveau le fonctionnement de cette fenêtre en aperçu :
• Sous le volet "Modification", dans le groupe "Aperçu", cliquez sur "Aperçu".
• Agrandissez la fenêtre : les champs suivent bien l’agrandissement en largeur et en hauteur.
8. Fermez l’aperçu de la fenêtre pour revenir sous l’éditeur.

9. Enregistrez la fenêtre ( ou CTRL S).
Affichage de la fiche depuis la liste des produits
Nous allons maintenant voir comment afficher la fiche du produit sélectionné dans la liste des
produits. Le principe est simple : l’utilisateur sélectionnera le produit dans le champ Table et affi-
chera le détail grâce à un bouton.
Nous allons tout d’abord modifier la fenêtre "FEN_Menu" afin de créer un bouton de modifi-
cation :
1. Placez-vous sur la fenêtre "Menu" : cliquez sur le bouton "FEN_Menu" dans la barre des bou-
tons :
2. Actuellement le champ Table occupe la totalité de la fenêtre. Agrandissez la taille de la fe-

nêtre vers la droite. Le champ Table s’agrandit également grâce au mécanisme de l’ancrage.
3. Diminuez la largeur du champ Table afin que toutes les colonnes soient affichées. Nous
avons maintenant de la place à droite de la table pour créer le bouton de visualisation du
produit.
Pour créer le bouton de visualisation du produit :
2. Dans la liste des boutons prédéfinis, cliquez sur "Modifier". La forme du bouton apparaît
sous la souris. Cliquez ensuite à droite du champ Table pour créer le bouton.
3. Faites un clic droit sur le bouton et dans le menu qui s’affiche, sélectionnez l’option "Code".
4. Dans la fenêtre de code qui apparaît, saisissez le code suivant dans le traitement "Clic sur" :
Ouvre(FEN_Fiche_du_produit)
Laissez-vous guider par l’assistance à la saisie de code : dès que vous allez ta-
per la parenthèse ouvrante "(", une liste déroulante va s’ouvrir proposant le nom
de toutes les fenêtres existantes dans le projet. Il suffit de sélectionner la fenêtre
Notes
au clavier ou à la souris.
Si vous ne trouvez pas le nom de la fenêtre que vous cherchez dans la liste, c’est
que celle-ci n’a pas été sauvegardée précédemment.
5. Examinons ce code : la fonction Ouvre permet d’ouvrir la fenêtre "FEN_Fiche_du_produit".

Nous avons déjà vu cette fonction dans la première partie de ce cours.
6. Enregistrez les modifications en cliquant sur parmi les boutons d’accès rapide.
7. Fermez la fenêtre de code (cliquez sur la croix en haut à droite de l’éditeur de code).
Nous allons maintenant modifier la fenêtre "FEN_Fiche_du_produit" pour afficher le produit sélec-
tionné dans le champ Table.
Affichez la fenêtre "FEN_Fiche_du_produit" sous l’éditeur : cliquez sur le bouton correspon-
dant dans la barre de boutons.
Pour afficher les données du produit :
1. Affichez les traitements associés à la fenêtre :
• Dans la zone à côté de la fenêtre, faites un clic droit de souris.
• Dans le menu contextuel qui s’affiche, sélectionnez "Code".
• L’éditeur de code apparaît.
2. Dans le traitement "Fin d’initialisation de FEN_Fiche_du_produit", saisissez le code suivant :
// Affecte le contenu des rubriques aux champs
FichierVersEcran()
La fonction FichierVersEcran permet d’afficher dans les champs les données présentes dans le
fichier de données, pour l’enregistrement en cours. Dans notre cas, l’enregistrement en cours
sera l’enregistrement sélectionné dans le champ Table de la fenêtre "FEN_Menu".
Affichez la fenêtre "FEN_Menu" sous l’éditeur : cliquez sur le bouton correspondant dans la
barre de boutons.
Testez la fenêtre ( parmi les boutons d’accès rapide).
• Dans la liste des produits, cliquez sur un des produits avec la souris.
• Cliquez sur le bouton "Modifier".
• La fenêtre de détail du produit s’affiche.
Fermez les fenêtres en utilisant la croix (x) en haut à droite des fenêtres.
Gestion de la modification d’un produit
Nous allons maintenant modifier la fenêtre "FEN_Fiche_du_produit" afin de gérer la modification
d’un produit.
Nous allons :
• permettre à l’utilisateur de modifier l’image du produit.
• ajouter des boutons pour enregistrer ou annuler les modifications effectuées dans la fiche.
Modification de l’image du produit

L’utilisateur va pouvoir modifier l’image du produit dans la fiche Produit. Pour cela, nous allons lui
proposer un bouton "Modifier" situé en dessous de l’image du produit. Ce bouton ouvrira un sélec-
teur de fichiers permettant de sélectionner l’image à utiliser.
Tout d’abord, affichez si nécessaire la fenêtre "FEN_Fiche_du_produit" sous l’éditeur : cliquez
sur le bouton correspondant dans la barre de boutons.
Pour créer le bouton de modification :
2. La forme du bouton apparaît sous la souris. Cliquez ensuite dans la fenêtre, sous l’image
du produit.
3. Sélectionnez le champ puis tapez sur la touche "Entrée" du clavier. Le libellé du bouton
passe en édition. Saisissez "Modifier" et appuyez sur la touche "Entrée" du clavier.
4. Redimensionnez si nécessaire le bouton (à l’aide des poignées) pour que le bouton ait la
même largeur que le champ Image.
5. Faites un clic droit sur le bouton. Dans le menu qui s’affiche, sélectionnez l’option "Code".
fSélecteurImage(
7. L’éditeur de code propose un assistant de code.

• Cliquez sur "Assistant de la fonction fSélecteurImage".
• L’assistant de code se lance.
WinDev propose de nombreux assistants de code qui à l’aide de questions

Notes
simples vont écrire la ou les ligne(s) de code correspondant. N’hésitez pas à les
utiliser, vous éviterez ainsi des erreurs de syntaxe.
8. Conservez toutes les options par défaut de l’assistant et validez. Le code correspondant est
automatiquement inséré.
sFichier est une chaîne
// Ouvre le sélecteur d’images

sFichier = fSélecteurImage("", "", "Sélectionnez une image...")
9. Ajoutez le code suivant à la suite :

// Si un fichier a été sélectionné
SI sFichier <> "" ALORS
// Affecte l’image au champ Image
IMG_Visuel = sFichier
FIN
Ce code permet d’affecter le fichier sélectionné au champ Image présent dans la fenêtre.
10. Fermez l’éditeur de code (cliquez sur la croix en haut à droite de l’éditeur de code).
Nous testerons cette fonctionnalité lorsque la gestion des modifications effectuées dans la fiche
sera finie.
Validation des modifications du produit

Nous avons déjà créé 2 boutons dans la fenêtre "FEN_Fiche_du_produit" :
• un bouton "Valider" pour gérer la validation des modifications
• un bouton "Annuler" pour gérer le retour à la liste des produits.
Nous allons maintenant saisir le code WLangage nécessaire à leur fonctionnement.
Tout d’abord, affichez si nécessaire la fenêtre "FEN_Fiche_du_produit" sous l’éditeur : cliquez
sur le bouton correspondant dans la barre de boutons.
Nous allons maintenant saisir le code du bouton "Valider".
1. Faites un clic droit sur le bouton puis sélectionnez l’option "Code" dans le menu contextuel.
2. Dans le traitement "Clic sur", saisissez le code suivant :
EcranVersFichier()
HModifie(Produit)
Ferme()
Examinons ce code :
• La fonction EcranVersFichier permet d’initialiser les rubriques avec les valeurs des champs
liés, pour l’enregistrement courant. Cette fonction est donc équivalente aux lignes sui-
vantes :
Produit.Référence = SAI_Référence
Produit.Libellé = SAI_Libellé
Produit.Description = SAI_Description
...
Notre fenêtre utilise moins de 10 champs et déjà l’avantage se fait sentir ; pensez simple-
ment aux fenêtres qui contiennent plusieurs dizaines de champs : 1 seule ligne de code ef-
fectue toutes les affectations !
• La fonction HModifie permet de mettre à jour les données du fichier de données pour l’enre-
gistrement courant.
Les modifications réalisées dans la fenêtre "Fiche du produit" doivent être prises en compte
dans le champ Table listant les produits. Pour cela, nous allons simplement modifier le code
du bouton "Modifier" dans la fenêtre "FEN_Menu".
1. Affichez la fenêtre "FEN_Menu" sous l’éditeur : cliquez sur le bouton correspondant dans la
barre de boutons.
2. Sélectionnez le bouton "Modifier" et affichez l’éditeur de code (option "Code" du menu
contextuel du bouton).
3. Modifiez le traitement "Clic sur" de la manière suivante :
TableAffiche(TABLE_Produit, taCourantBandeau)
Examinons ce code :
• La fonction TableAffiche permet de mettre à jour le champ Table.
• La constante taCourantBandeau permet de spécifier que le champ Table doit être mis à jour
à partir de la position du bandeau de sélection.
Test de la modification d’un produit
Pour tester la modification d’un produit :

1. Lancez le test du projet ( parmi les boutons d’accès rapide).
2. WinDev demande de sélectionner la première fenêtre du projet. Dans notre cas, cette fe-
nêtre correspond à "FEN_Menu". Sélectionnez cette fenêtre et validez.
La première fenêtre du projet correspond à la première fenêtre ouverte au lance-

ment de l’application.
La première fenêtre du projet peut être définie :
• lors d’un test du projet.
Notes
• lors de la création de l’exécutable.

• sous l’explorateur de projet : il suffit de sélectionner la fenêtre voulue, d’affi-
cher le menu contextuel et de sélectionner l’option "Première fenêtre du pro-
jet".
Lorsqu’une première fenêtre du projet est définie, un petit 1 rouge apparaît de-
vant le nom de la fenêtre sous l’explorateur de projet.
3. Dans la liste des produits, sélectionnez un produit dans le champ Table (par exemple le
premier) et cliquez sur le bouton "Modifier".
4. Le détail du produit sélectionné apparaît dans la fenêtre fiche.
5. Modifiez le prix de 100,23 euros et saisissez 200,00 euros puis ensuite cliquez sur le bou-
ton "Valider".
6. De retour sur la liste des produits, vous pouvez constater que le prix de cet article a été mis
à jour.
7. Affichez à nouveau le détail du produit.
8. Cliquez sur le bouton "Modifier" sous l’image. Le sélecteur d’images s’affiche. Sélectionnez
une image et validez. L’image apparaît dans la fiche.
9. Cliquez sur le bouton "Annuler". La modification de l’image n’a pas été prise en compte
dans le fichier de données.
10. Fermez l’application en cliquant sur la croix.
Création d’un nouveau produit
Le principe de la création d’un produit va être le suivant :
• Dans la fenêtre de la liste des produits, nous allons ajouter un bouton "Nouveau" qui va per-
mettre d’ouvrir la fenêtre "Fiche du produit".
• Nous modifierons ensuite le code de la fenêtre "Fiche du produit" pour gérer l’ajout dans le
fichier de données Produit.
Ajout d’un bouton
Pour ajouter un bouton "Nouveau" dans la fenêtre "FEN_Menu" :

1. Affichez la fenêtre "FEN_Menu" sous l’éditeur : cliquez sur le bouton correspondant dans la
barre de boutons.
2. Sous le volet "Création", dans le groupe "Champs usuels", déroulez "Bouton" et sélectionnez
"Nouveau".
3. La forme du bouton apparaît sous la souris. Cliquez ensuite dans la fenêtre : le bouton est
créé.
4. Positionnez le bouton au-dessus du bouton "Modifier" (si nécessaire modifiez la position du
bouton "Modifier").
5. Modifiez le code de ce bouton :

• Faites un clic droit sur le bouton puis sélectionnez l’option "Code" dans le menu contextuel.
• Dans le traitement "Clic sur", saisissez le code suivant :
HRaz(Produit)
TableAffiche(TABLE_Produit, taCourantEnreg)
Examinons ce code :
• La fonction HRaz initialise les variables des rubriques du fichier "Produit" avec les valeurs
par défaut pour gérer un nouvel enregistrement.
• La fonction Ouvre permet d’ouvrir la fiche du produit pour saisir le nouvel enregistrement.
• La fonction TableAffiche permet de réafficher le champ Table. Dans ce code, la constante
taCourantEnreg est utilisée : le champ Table est réaffiché à partir de l’enregistrement cou-
rant.
Ajout dans le fichier de données
Maintenant, nous allons modifier la fenêtre de la fiche du produit pour gérer l’ajout d’un
nouvel enregistrement.
1. Affichez la fenêtre "FEN_Fiche_du_produit" sous l’éditeur.
2. Nous allons modifier le code du bouton de validation :
• Faites un clic droit sur le bouton "Valider" puis sélectionnez l’option "Code" dans le menu
contextuel.
• Dans le traitement "Clic sur", remplacez le code par le code suivant :
EcranVersFichier()
SI Produit..NouvelEnregistrement ALORS
HAjoute(Produit)
SINON
HModifie(Produit)
FIN
Ferme()
Examinons ce code :
• La propriété ..NouvelEnregistrement permet de savoir si l’enregistrement en cours doit être
créé.
• Si la fonction HRaz a été appelée précédemment, la propriété renvoie Vrai (cas du clic sur
"Nouveau produit") et l’enregistrement doit être créé par la fonction HAjoute.
• Dans le cas contraire, l’enregistrement en cours existe déjà et doit être modifié par la fonc-
tion HModifie.
• La fonction HAjoute ajoute l’enregistrement dans le fichier de données. Cette fonction prend
les valeurs en mémoire et écrit le contenu des rubriques du fichier dans le fichier de don-
nées lui-même. Les index sont immédiatement et automatiquement mis à jour. Ici, le fichier
de données mis à jour est bien entendu le fichier "Produit".
Test de l’ajout d’un produit
Pour tester l’ajout d’un produit :

2. Dans la liste des produits, cliquez sur le bouton "Nouveau".
3. Saisissez un nouveau produit avec les caractéristiques suivantes :
• Référence : REF-337
• Libellé : Surf 19
• Description : Surf aux couleurs de WinDev
• Prix : 150
4. Validez. Le nouveau produit apparaît dans la liste des produits.
5. Cliquez à nouveau sur le bouton "Nouveau".
6. Saisissez un nouveau produit avec les caractéristiques suivantes :
• Référence : REF-337
• Libellé : Surf WB 19
• Description : Surf aux couleurs de WebDev
• Prix : 150
7. Validez. Une fenêtre spécifique apparaît :
Cette fenêtre signale à l’utilisateur qu’il existe un doublon : en effet, la référence (qui est une
clé unique) est identique pour deux produits. Cette fenêtre permet de modifier la valeur de la
référence (affichée dans une zone rouge) : saisissez par exemple "REF-338".
Cette fenêtre est une des fenêtres de gestion automatique des erreurs HFSQL, disponible en stan-
dard.
Lors de l’ajout ou de la modification d’un enregistrement, plusieurs types d’er-
reurs peuvent survenir : erreur de doublons, erreur d’intégrité, erreur de mot de
passe, ...
WinDev propose plusieurs modes de gestion de ces erreurs :
• le mode automatique : pour chaque erreur rencontrée lors de la gestion
des enregistrements de la base de données, une fenêtre spécifique est af-
fichée à l’utilisateur. Cette fenêtre permet à l’utilisateur de modifier directe-
Notes
ment ses données.

• le mode programmé avancé : pour chaque erreur rencontrée lors de la
gestion des enregistrements de la base de données, une procédure ou
une fenêtre personnalisée de gestion des erreurs est appelée.
L’exemple didactique "Detection Erreurs" livré avec WinDev permet de tester ces
différents modes de gestion des erreurs. Cet exemple peut être ouvert :
• soit par la fenêtre de bienvenue de WinDev (option "Ouvrir un projet"),
• soit par le volet "Assistants, Exemples et composants".
Visualiser les enregistrements saisis

Les nouveaux enregistrements que nous avons saisis peuvent être visualisés immédiatement
dans le champ Table de la fenêtre "FEN_Menu".
Mais dans certains cas, lors de tests par exemple, il peut être nécessaire de voir directement le
contenu du fichier de données.
WinDev propose un outil simple permettant de voir le contenu des fichiers de données pendant
le développement de l’application (lorsque par exemple, les fenêtres de visualisation n’ont pas
encore été créées).
Cet outil s’appelle WDMAP. Nous allons l’utiliser pour voir le contenu du fichier Produit.
Pour lancer WDMAP :
1. Sous le volet "Outils", dans le groupe "Base de données", cliquez sur "WDMap".
2. Sélectionnez le fichier "Produit". Le contenu du fichier de données s’affiche.
3. En triant les éléments par référence (cliquez sur l’en-tête de la colonne "Référence"), les
deux enregistrements que nous avons ajoutés apparaissent.
Leçon 3.3. Recherche simple et
parcours des enregistrements
• Gestion de la recherche d’enregistrements

• Parcours des enregistrements
Présentation
Nous avons géré l’ajout et la modification d’enregistrements. C’est bien. Mais ce serait encore
mieux de pouvoir rechercher un enregistrement (pour le modifier par exemple). C’est ce que nous
allons faire maintenant.
Nous allons modifier la fenêtre principale de l’application "WD Application Complète" pour utiliser
des volets d’onglet.
Le premier onglet permettra d’afficher la liste des produits et de gérer l’ajout et la modification
des produits (les manipulations ont été réalisées dans les leçons précédentes).
Le second onglet proposera la recherche d’un client selon son nom. La fiche du client sera affi-
chée dans l’onglet.
Nous allons mettre en place deux modes de recherche :
• une recherche à l’identique,
• une recherche générique.
Ensuite, il sera possible de parcourir les enregistrements présents dans le fichier de données à
partir du client affiché.

Corrigé
Modification de la fenêtre : utilisation d’un champ Onglet
Dans cet exemple, la recherche ne va pas s’effectuer dans une nouvelle fenêtre : nous allons utili-
ser la fenêtre FEN_Menu. Actuellement, cette fenêtre affiche la liste des produits.
Pour afficher plusieurs données différentes dans cette fenêtre, nous allons utiliser des onglets.
Les onglets permettent de regrouper des informations par thème. L’utilisateur peut accéder direc-
tement à un thème en cliquant sur le "volet" voulu.
Ce système est utilisé dans toutes les fenêtres de description de WinDev.
Création du champ Onglet
Pour afficher les données de la fenêtre "FEN_Menu" dans un onglet :

1. Affichez si nécessaire la fenêtre "FEN_Menu" :
• soit depuis la barre des boutons.
• soit en double-cliquant sur son nom dans l’explorateur de projet.
2. Sélectionnez les champs de la fenêtre et déplacez-les dans la zone d’accueil de la fenêtre.
Cette manipulation peut sembler "bizarre", mais ainsi il sera plus simple de travailler sur le
champ Onglet puis d’associer les champs à l’onglet voulu.
3. Créez un champ Onglet dans la fenêtre :

• Sous le volet "Création", dans le groupe "Conteneurs", déroulez "Onglets et associés" et sé-
lectionnez "Onglet".
• Cliquez dans la fenêtre pour créer le champ Onglet.
• Positionnez le champ Onglet en haut à gauche de la fenêtre et agrandissez-le pour occuper
toute la fenêtre.
• Par défaut, un champ Onglet est créé avec deux volets.
4. Sélectionnez les champs présents dans la zone d’accueil de la fenêtre et déplacez-les vers
le volet 1.
5. Un cadre vert apparaît lors du survol des champs sur le champ Onglet. Ce cadre indique
que les champs posés sur le volet en cours seront automatiquement associés au volet.
6. Agrandissez si nécessaire la fenêtre et le champ Onglet pour afficher le champ Table et les
boutons dans le champ Onglet.
Manipulations de champs dans un champ Onglet :

• Pour vérifier que tous les champs sont bien associés au volet d’onglet en
Notes
cours, cliquez sur un autre volet d’onglet.

• Pour redimensionner le champ Onglet sans prendre en compte l’ancrage des
champs présents dans le volet, utilisez la touche [SHIFT] pendant le redimen-
sionnement.
Modifications du champ Onglet
Modifiez le nom du champ Onglet :

1. Double-cliquez sur le champ Onglet que vous venez de créer : la fenêtre de description du
champ s’affiche.
2. Modifiez le nom du champ. Le champ a pour nom "ONG_Visualisation".
Deux volets sont créés par défaut. Nous allons modifier leur libellé directement :
1. Sélectionnez le champ Onglet.
2. Cliquez sur "Volet 1". Le volet passe en édition : saisissez le libellé "Liste des produits".
Validezavec la touche ENTREE.
3. Cliquez sur "Volet 2". Le volet s’affiche. Cliquez à nouveau sur "Volet 2". Saisissez le libellé
"Recherche de clients". Validez avec la touche ENTREE.
Nous allons associer une image à chaque volet de l’onglet. Pour cela :
1. Affichez la fenêtre de description du champ Onglet (double-clic sur le champ par exemple).
L’onglet "Général" de la fenêtre de description permet de configurer les caractéristiques de
chaque volet d’onglet. Les volets sont présents dans la partie haute et leurs caractéristiques
sont modifiables dans la partie basse.
2. Dans la fenêtre de description, cliquez sur l’onglet "Liste des produits".
3. Dans la zone basse de la fenêtre, cliquez sur "Détails (volet)". Nous allons associer une
image à l’onglet grâce au catalogue d’images de WinDev.
Dès qu’une image peut être affichée dans un champ ou dans une fenêtre, Win-
Notes Dev propose d’utiliser le catalogue d’images grâce au bouton "Catalogue". Ce
catalogue contient plusieurs milliers d’images, de cliparts, ...
4. Cliquez sur le bouton "Catalogue". La fenêtre du catalogue d’images apparaît.

5. Dans la zone de recherche, indiquez "Produit" et sélectionnez le thème "Flat Soft". Lancez la
recherche en cliquant sur la loupe.
6. Sélectionnez l’image proposée et validez (bouton vert).

7. L’écran de paramétrage de l’image générée apparaît. Cet écran permet de modifier les ca-
ractéristiques de l’image à générer : taille, luminosité, ... Conservez les options par défaut et
validez.
8. L’image est générée dans le répertoire du projet et le fichier correspondant est automati-
quement associé à l’élément en cours.
9. Dans la fenêtre de description, cliquez sur l’onglet "Recherche de clients".
10. Dans la zone basse de la fenêtre, cliquez sur "Détails (volet)".
12. Dans la zone de recherche, indiquez "Personne" et sélectionnez le thème "Flat Soft".
Lancezla recherche en cliquant sur la loupe.
13. Parmi les images proposées, sélectionnez l’icône présentant deux personnes ( ) et vali-
dez.
14. Conservez les options de l’écran de paramétrage de l’image générée et validez.
15. Validez la fenêtre de description du champ Onglet.
Nous venons de créer un nouveau champ : il est nécessaire de s’occuper de son ancrage
dans la fenêtre. Lorsque la fenêtre va s’agrandir, il est nécessaire que le champ Onglet
s’agrandisse également pour occuper tout l’espace disponible. Le champ doit donc s’étirer
vers la droite et vers le bas.
2. Affichez le menu contextuel (clic droit) et sélectionnez l’option "Ancrage".
3. Dans la fenêtre de définition de l’ancrage, sélectionnez l’option et validez.
4. Enregistrez la fenêtre en cliquant sur parmi les boutons d’accès rapide.
Mise en place de la recherche
Nous avons fini de préparer la fenêtre "FEN_Menu". Nous pouvons maintenant nous concentrer
sur le contenu de l’onglet de recherche des clients.
Cet onglet va être divisé en plusieurs zones :
• Une zone de saisie des éléments à rechercher.
• Une zone d’affichage des informations trouvées.
• Une zone contenant les boutons de parcours.
Zone d’affichage des informations trouvées

Nous allons tout d’abord créer les différents champs qui afficheront les informations sur le client
trouvé.
Pour créer les champs de saisie dans la fenêtre, nous allons procéder de la même manière que
pour la fenêtre fiche du produit : un simple "Drag and Drop" depuis le volet "Analyse".
Pour créer les différents champs affichant les informations sur le client :
1. Affichez la fenêtre FEN_Menu sous l’éditeur et cliquez sur l’onglet "Recherche de clients". Le
volet d’onglet vide apparaît.
2. Affichez si nécessaire le volet "Analyse" : sous le volet "Accueil", dans le groupe "Environne-
ment", déroulez "Volets" et sélectionnez "Analyse". Les différents fichiers de données décrits
dans l’analyse "WD Application Complète" apparaissent dans le volet.
3. Cliquez sur l’icône "+" à gauche du fichier "Client" : les rubriques du fichier de données sont
listées.
4. Sélectionnez à l’aide de la souris l’ensemble des rubriques affichées dans le volet. Vous
pouvez par exemple utiliser le lasso de la souris ou la multisélection en maintenant la touche
CTRL enfoncée.
5. Effectuez un "Drag and Drop" (glisser/déplacer) de ces rubriques vers l’onglet "Recherche
de clients".
6. Les champs sont automatiquement créés dans l’onglet. Ces champs sont automatique-
ment liés à la rubrique correspondante dans le fichier de données.
Nous allons aligner les champs et à leur donner la même taille :
1. Sélectionnez le champ "Ville" puis tous les autres champs de saisie de la fenêtre (par exemple
en maintenant la touche CTRL appuyée et en cliquant sur les différents champs). Le premier
champ sélectionné va servir de référence pour la taille des autres champs.
2. Sous le volet "Alignement", dans le groupe "Interne et externe", cliquez sur l’option "Justifier
(Int et Ext)".
Testez la fenêtre ( parmi les boutons d’accès rapide). Cliquez sur le volet d’onglet
"Recherche de clients". La fenêtre apparaît avec tous les champs vides.
Recherche à l’identique
Pour effectuer la recherche à l’identique, nous allons sélectionner le nom du client dans un champ
Combo. Le bouton "Rechercher" permettra d’afficher la fiche de la personne correspondante. Une
seule personne correspond au nom sélectionné.
Le champ Combo va venir se placer au-dessus des champs que nous venons de créer. Si vos
champs sont placés trop près de l’onglet, il est nécessaire de les déplacer vers le bas. Pour
cela :
1. Sélectionnez l’ensemble des champs présents dans l’onglet :
• Utilisez la combinaison de touches CTRL A : tous les champs de la fenêtre et du volet en
cours sont sélectionnés.
• Appuyez sur la touche CTRL.
• Cliquez sur l’onglet : seuls les champs du volet d’onglet sont sélectionnés.
2. Déplacez un des champs sélectionnés vers le bas à l’aide de la souris.
3. Tous les champs sont déplacés vers le bas.

Pour créer le champ de recherche :
1. Créez un champ de type combo : sous le volet "Création", dans le groupe "Champs usuels",
cliquez sur "Combo".
2. Cliquez ensuite dans le volet "Recherche de client", dans la zone entre le volet d’onglet et le
champ "Identifiant de Client".
3. L’assistant de création des combos s’affiche. Nous allons créer une combo basée sur le
fichier de données "Client".
4. Sélectionnez l’option "Afficher les données d’un fichier ou d’une requête existante". Passez
à l’écran suivant de l’assistant.
5. Sélectionnez le fichier de données "Client". Passez à l’écran suivant.
6. Nous allons afficher le nom et le prénom de la personne.
• Désélectionnez la rubrique "IDClient".

• Sélectionnez la rubrique "NomComplet".
Passez à l’écran suivant.
7. La rubrique "NomComplet" sera également utilisée pour trier la liste des clients affichés
dans le champ Combo. Sélectionnez la rubrique "NomComplet". Passez à l’écran suivant.
8. La valeur retournée par le champ Combo sera l’identifiant "IDClient". C’est cette valeur qui
sera recherchée dans le fichier Client. Sélectionnez la rubrique "IDClient" et passez à l’écran
suivant.
9. Le champ Combo ne sera lié à aucune rubrique. Conservez l’option "Non" et passez à
l’écran suivant.
10. Validez l’écran suivant avec la flèche jaune.
11. Donnez un nom au champ (par exemple "COMBO_Client") et un libellé (par exemple "Client
recherché").
12. Validez. Positionnez le champ Combo dans la fenêtre (par exemple en haut à gauche).
13. Sélectionnez le champ Combo et à l’aide des poignées, modifiez sa taille afin de voir le
nom complet du client s’afficher.
Pour créer le bouton de recherche :

1. Créez un bouton : sous le volet "Création", dans le groupe "Champs usuels", cliquez sur .
2. Positionnez le bouton à côté de la combo qui vient d’être créée.
3. Ce champ a pour nom "BTN_RechercheIdentique" et pour libellé "Recherche identique".
4. Si nécessaire, adaptez la taille du bouton pour que le libellé apparaisse correctement dans
le bouton.
5. Saisissez le code suivant :
// Recherche le client par son identifiant
HLitRecherchePremier(Client, IDClient, COMBO_Client)
SI HTrouve(Client) ALORS
// Affiche les données du client
FichierVersEcran()
FIN
6. Examinons ce code :
• La fonction HLitRecherchePremier permet de réaliser une recherche à l’identique. Dans cet
exemple, la recherche se fait sur le fichier Client et sur la rubrique IDClient. La valeur recher-
chée correspond au dernier paramètre de la fonction. Ici, la valeur recherchée correspond à
la valeur sélectionnée dans la combo. Cette valeur est obtenue en utilisant directement le
nom de la combo (COMBO_Client).
• La fonction HTrouve permet de tester le résultat de la recherche. Si la fonction HTrouve ren-
voie Vrai, une valeur a été trouvée, si la fonction HTrouve renvoie Faux, aucune valeur n’a
été trouvée. Lorsqu’un enregistrement a été trouvé, cet enregistrement est lu : il devient
l’enregistrement courant du fichier de données.
• Dans ce code, si l’enregistrement a été trouvé, il est affiché grâce à la fonction FichierVersE-
cran.
La fonction FichierVersEcran effectue l’opération inverse de la fonction

Note
EcranVersFichier : les données présentes dans les rubriques du fichier de don-

nées sont affichées dans les champs correspondants.
7. Fermez l’éditeur de code.

Réalisons un test de la fenêtre :
1. Lancez le test de la fenêtre ( parmi les boutons d’accès rapide).
2. Cliquez sur l’onglet "Recherche de clients".
3. Sélectionnez une valeur dans la combo et cliquez sur le bouton de recherche.
4. Le résultat est immédiat.

5. Fermez la fenêtre de test pour retourner sous l’éditeur.
Recherche générique
Nous allons maintenant effectuer une recherche générique. Au lieu de rechercher exactement la
valeur saisie, nous allons rechercher tous les éléments qui commencent par la valeur saisie.
Pour effectuer cette recherche, nous allons créer un champ de saisie afin de saisir le nom recher-
ché et un bouton pour lancer la recherche.
Pour créer le champ de recherche :
1. Affichez si nécessaire l’onglet "Recherche de clients" de la fenêtre "FEN_Menu" sous l’édi-
teur.
2. Créez un champ de saisie : sous le volet "Création", dans le groupe "Champs usuels", cli-
quez sur .
3. Cliquez dans la fenêtre sous le champ Combo "Client recherché". Le champ de saisie est
créé.
4. Ce champ a pour nom "SAI_Nom_recherché" et pour libellé "Nom recherché".
Pour créer le bouton de recherche :
1. Créez un bouton : sous le volet "Création", dans le groupe "Champs usuels", cliquez sur .
2. Positionnez le bouton à côté du champ de saisie qui vient d’être créé.
3. Ce champ a pour nom "BTN_RechercheGénérique" et pour libellé "Recherche générique".

4. Si nécessaire, adaptez la taille du bouton pour que le libellé apparaisse correctement dans
le bouton.
// Recherche un client par son nom
HLitRecherche(Client, NomComplet, SAI_Nom_Recherché)
SI HTrouve(Client) ALORS
FichierVersEcran()
SINON
Erreur("Aucun client ne correspond")
FIN
La fonction HLitRecherche permet de réaliser une recherche générique. Dans cet exemple, la
recherche se fait sur le fichier "Client" et sur la rubrique "NomComplet". La valeur recherchée
correspond à la valeur saisie dans le champ "SAI_Nom_Recherché". Cette valeur est obtenue
en utilisant directement le nom du champ.
Il est possible de faire une recherche à l’identique avec la fonction HLitRe-

Note
cherche : il suffit d’utiliser la constante hIdentique.

3. Saisissez une valeur dans le champ de saisie (par exemple "BEEF") et cliquez sur le bouton
de recherche.
4. Le résultat est immédiat. Cependant, si plusieurs enregistrements correspondent, seul le
premier est affiché.
5. Arrêtez le test et revenez sous l’éditeur.
Parcours des fiches

Nous allons maintenant ajouter quatre boutons permettant de parcourir les différents enregistre-
ments du fichier "Client". Ces boutons sont de type "boutons magnéto".
Ils sont constitués uniquement d’une icône et permettent d’afficher :

• le premier enregistrement,
• l’enregistrement précédent,
• l’enregistrement suivant,
• le dernier enregistrement.
Pour créer le bouton affichant le premier enregistrement du fichier de données :
1. Si nécessaire, affichez l’onglet "Recherche de clients" sous l’éditeur.
3. La forme du bouton apparaît sous la souris. Cliquez ensuite dans l’onglet, sous le champ
"Recherche générique". Le bouton est automatiquement créé.
Pour uniformiser l’interface des fenêtres d’un projet, nous utilisons un gabarit. Ce gabarit
définit le style de tous les champs des fenêtres. Pour chaque bouton magnéto, un style
spécifique est défini. Pour appliquer ce style :
1. Sélectionnez si nécessaire le bouton.
2. Affichez le menu contextuel (clic droit) et sélectionnez l’option "Choisir un style".
3. Dans la fenêtre qui s’affiche, tous les styles définis pour les boutons s’affichent. Sélection-
nez le style "BTN_Premier".
4. Validez.
Modifiez le nom du champ Bouton :
1. Affichez la fenêtre de description du champ :
• Sélectionnez le champ Bouton.
• Affichez le menu contextuel (clic droit) et sélectionnez l’option "Description".
2. Ce champ a pour nom "BTN_Premier".
3. Validez la fenêtre de description.
Nous allons maintenant saisir le code WLangage associé à ce champ :
1. Faites un clic droit sur le champ. Dans le menu qui s’affiche, sélectionnez l’option "Code".
// Lit le premier client
HLitPremier(Client)
SI HEnDehors(Client) = Vrai ALORS
// Pas de client
Info("Aucune fiche à visualiser.")
SINON
FichierVersEcran()
FIN
La fonction HLitPremier permet de lire le premier enregistrement du fichier de données, selon

la clé utilisée pour la dernière recherche (NomComplet dans notre cas).
De la même manière, créez 3 nouveaux boutons.
• Ces boutons ont pour nom : "BTN_Précédent", "BTN_Suivant" et "BTN_Dernier".
• Ces boutons sont respectivement associés aux styles : "BTN_Précédent", "BTN_Suivant" et
"BTN_Dernier".
• Le code du bouton "BTN_Précédent" est le suivant :
// Lit le client précédent
HLitPrécédent(Client)
// Si le début du fichier est dépassé
Info("Début du fichier atteint.")
SINON
FichierVersEcran()
FIN
• Le code du bouton "BTN_Suivant" est le suivant :
// Lit le client suivant
HLitSuivant(Client)
// Si la fin du fichier est dépassée
Info("Fin du fichier atteinte.")
SINON
FichierVersEcran()
FIN
• Le code du bouton "BTN_Dernier" est le suivant :
// Lit le dernier client

HLitDernier(Client)
// Pas de client
Info("Aucune fiche à visualiser.")
SINON
FichierVersEcran()
FIN
Dans ces différents codes :

• La fonction HLitDernier permet de lire le dernier enregistrement du fichier de données, selon la
clé utilisée pour la dernière recherche.
• La fonction HLitSuivant va lire l’enregistrement qui a la valeur de clé immédiatement supérieure
à celle de l’enregistrement en cours.
• La fonction HLitPrécédent va lire l’enregistrement qui a la valeur de clé immédiatement infé-
rieure à celle de l’enregistrement en cours.
Dans tous les cas :
• la fonction HEnDehors permet de savoir si le fichier de données est vide.
• la fonction FichierVersEcran permet d’afficher l’enregistrement à l’écran.
Enregistrez la fenêtre en cliquant sur parmi les boutons d’accès rapide.
Test de la fenêtre

3. Recherchez un client (par exemple, une recherche générique sur "BEEF").
4. Parcourez le fichier de données en cliquant sur chacun des boutons de parcours.
5. Arrêtez le test pour revenir sous l’éditeur.
Leçon 3.4. Recherche multicritère
• Création d’une requête paramétrée.

• Création de l’interface de sélection des critères de recherche.
• Passage de paramètres à une requête.
• Affichage du résultat d’une requête dans un champ Table.
Présentation
Nous avons vu dans la leçon précédente comment réaliser une recherche sur un seul critère (le
nom du client). Dans cette leçon, nous allons permettre à l’utilisateur de faire une recherche mul-
ticritère.
Dans notre exemple, cette recherche se fera sur le fichier "Commande". L’utilisateur pourra sélec-
tionner :
• l’état de la commande,
• son mode de règlement,
• les dates de commandes prises en compte.
L’interface de la fenêtre "FEN_Menu" sera la suivante :
Cette interface est composée :

• de champs permettant de sélectionner les critères de recherche.
• de boutons permettant de lancer la recherche ou d’imprimer le résultat.
• d’un champ Table permettant d’afficher le résultat de la recherche. Ce champ Table est basé
sur une requête. Cette requête va permettre de sélectionner les enregistrements à afficher. Le
champ Table listera le résultat de la recherche.
La première étape consiste à créer la requête de sélection des enregistrements.

Corrigé
Création de la requête pour rechercher les commandes
Création de la requête
Pour créer une requête, nous allons utiliser l’éditeur de requêtes.

"Requête". L’assistant de création de requêtes se lance.
2. Sélectionnez l’option "Sélection (SELECT)".
En effet, la requête que nous allons créer va nous permettre de sélectionner des enregistre-
ments. Passez à l’écran suivant.
3. La fenêtre de description de la requête apparaît. Nous allons construire la requête en sélec-
tionnant les éléments que nous voulons dans le résultat.
4. Double-cliquez sur les rubriques présentes dans l’analyse à gauche de la fenêtre de des-
cription. Les rubriques prises en compte apparaissent alors au centre de l’écran.
Nous voulons afficher :
• les renseignements concernant la commande. Dans le fichier "Commande", double-cliquez
sur les rubriques : IDCommande, Date, Etat et TotalHT.
• les renseignements concernant le client. Dans le fichier "Client", double-cliquez sur la ru-
brique "NomComplet".
• les renseignements concernant le mode de règlement. Dans le fichier "ModeRèglement",
double-cliquez sur la rubrique "Libellé".
La fenêtre de description de la requête est la suivante :
5. Nous allons trier les données par date.
• Dans la liste des éléments de la requête, sélectionnez la rubrique "Commande.Date", puis
cliquez sur le bouton "Trier" et sélectionnez l’option "Trier sur la rubrique sélectionnée".
• Dans la fenêtre qui s’affiche, indiquez un tri croissant sur la rubrique et validez.
6. Une flèche rouge avec le numéro 01 apparaît à droite de la rubrique "Commande.Date".
Cette flèche indique qu’un tri croissant est fait sur cette rubrique. Le chiffre "01" indique que
ce tri sera réalisé en premier.
7. Donnez un nom à la requête : saisissez "REQ_RechercheCommandes" à la place de "REQ_

SansNom1" dans la zone "Nom de la requête" :
8. Validez la fenêtre de description de la requête (bouton vert en bas de l’écran).
9. La représentation graphique de la requête est affichée :
10. Enregistrez la requête en cliquant sur parmi les boutons d’accès rapide.
11. Validez si nécessaire la fenêtre de sauvegarde de la requête.
Test de la requête
Comme tous les éléments d’un projet WinDev, il est possible de tester immédiatement la requête
que nous venons de créer :
1. Cliquez sur .
2. Le résultat s’affiche dans une fenêtre :
Le résultat affiché liste TOUTES les commandes.
Dans notre cas, nous souhaitons afficher uniquement les commandes correspondant aux
critères de recherche. Pour cela, il est nécessaire d’utiliser une requête paramétrée.
Si vous faites un clic droit sur le résultat de la requête, un menu contextuel appa-
raît. Vous avez alors la possibilité d’exporter le résultat vers :
Notes
• un fichier XLS (Excel).

• un fichier XML (eXtensible Markup Language).
• un fichier texte.
Utilisation de paramètres dans la requête

Dans notre exemple, l’utilisateur va pouvoir sélectionner une valeur pour les critères de recherche
suivants :
• Etat de la commande.
• Mode de règlement de la commande.
• Date de la commande.
Nous devons modifier la requête afin que ces critères de recherche correspondent à des para-
mètres de la requête.
Pour définir les paramètres de la requête, affichez la fenêtre de description de la requête :
double-cliquez sur le fond de la représentation graphique de la requête.
Pour gérer le paramètre "état de la commande" :
1. Sélectionnez au centre de l’écran la rubrique Commande.Etat.
2. Déroulez le bouton "Condition de sélection" et sélectionnez "Nouvelle condition".
3. Dans la fenêtre qui s’affiche, nous allons indiquer que la condition de sélection correspond
à un paramètre :
• Sélectionnez "Est égal à".

• Cochez "au paramètre".
• Indiquez le nom du paramètre "pEtat".
4. Validez la fenêtre de description de la condition. Le chiffre "1" apparaît à droite de la ru-
brique "Commande.Etat", indiquant qu’une condition de sélection a été définie.
Nous allons maintenant définir une condition sur le mode de règlement. Cette rubrique n’est
pas présente dans le résultat de la requête mais nous souhaitons tout de même lui appliquer
une condition. Pour cela, nous allons intégrer la rubrique dans le résultat de la requête et la
rendre invisible pour qu’elle ne soit pas présente dans le résultat.
1. Sur la partie gauche de la fenêtre de description de la requête, dans le fichier "Commande",
double-cliquez sur la rubrique "IDModeRèglement". La rubrique "IDModeRèglement" apparaît
dans la liste des éléments de la requête.
2. Pour ne pas afficher cette rubrique dans le résultat :
• Cliquez sur .
• Dans le menu qui s’affiche, sélectionnez "Ne pas afficher".
3. Pour définir une condition de sélection sur la rubrique "Commande.IDModeRèglement" :
• Sélectionnez au centre de l’écran la rubrique "Commande.IDModeRèglement".
• Déroulez le bouton "Condition de sélection" et sélectionnez "Nouvelle condition".
• Dans la fenêtre qui s’affiche, indiquez que la condition de sélection correspond à un para-
mètre :
• Indiquez le nom du paramètre "pIDModeRèglement".
4. Validez la définition de la condition de sélection.
La dernière condition de sélection à définir concerne la date de la commande. Cette date doit
être comprise entre deux dates saisies par l’utilisateur.
1. Sélectionnez dans la liste des éléments de la requête la rubrique "Commande.Date".
2. Affichez le menu contextuel de la rubrique (clic droit) et sélectionnez "Condition de sélection
.. Nouvelle condition".
3. Dans la fenêtre qui s’affiche :
• Sélectionnez la condition "Est compris entre".
• Cliquez sur "au paramètre".
• Indiquez le nom du paramètre "pDébutPériode".
• Cliquez sur le second "au paramètre".
• Indiquez le nom du paramètre "pFinPériode".
4. Validez la définition de la condition de sélection.
5. Validez la fenêtre de description de la requête. Le graphe de la requête est modifié pour
prendre en compte les conditions de sélection que nous avons définies.
6. Enregistrez la requête en cliquant sur parmi les boutons d’accès rapide.
Test de la requête paramétrée
Pour tester la requête paramétrée :

1. Cliquez sur .
2. Une fenêtre s’affiche permettant de saisir les différents paramètres de la requête.
3. Saisissez les données suivantes :
• Décochez le paramètre pEtat.
• Sélectionnez le paramètre pDébutPériode. Dans la partie basse de l’écran, saisissez
"01/01/2011".
• Sélectionnez le paramètre pFinPériode. Dans la partie basse de l’écran, saisissez
"31/03/2011".
• Sélectionnez le paramètre pIDModeRèglement. Dans la partie basse de l’écran, saisissez
"1".
4. Validez la fenêtre. Le résultat de la requête correspondant aux paramètres spécifiés s’af-

fiche.
Nous allons maintenant créer l’interface permettant d’indiquer les paramètres de cette requête,
de l’exécuter et d’afficher le résultat.
Création de l’interface pour réaliser une recherche multicri-

tère
Modifications du champ Onglet

Nous allons ajouter un volet d’onglet dans la fenêtre "FEN_Menu" pour afficher le résultat de la
recherche multicritères.
Pour ajouter un volet d’onglet :
1. Affichez si nécessaire la fenêtre "FEN_Menu" sous l’éditeur.
3. Affichez la fenêtre de description du champ (option "Description" du menu contextuel).
4. Dans l’onglet "Général" de la fenêtre de description, cliquez sur le bouton "Nouveau". Un
troisième volet d’onglet apparaît.
5. Cliquez sur "Volet 3".
6. Dans la zone basse de la fenêtre, dans la partie "Général (volet)", saisissez le libellé "Re-
cherche de commandes".
7. Dans la zone basse de la fenêtre, cliquez sur "Détails (volet)". Nous allons associer une
image à l’onglet grâce au catalogue d’images de WinDev.
9. Dans la zone de recherche, indiquez "Recherche" et sélectionnez le thème "Flat Soft".
Lancezla recherche en cliquant sur la loupe.
10. Parmi les images proposées, sélectionnez l’icône représentant les jumelles et validez.
11. Conservez les options de l’écran de paramétrage de l’image générée et validez.
Création des champs de paramétrage des critères et affichage du résultat
Passons maintenant à l’affichage du résultat de notre recherche multicritères.
Nous allons tout d’abord créer un champ Table basé sur la requête puis créer les différents
champs qui permettront à l’utilisateur de sélectionner les critères de recherche.
Création du champ Table
Pour créer le champ Table affichant le résultat de la recherche :

1. Dans la fenêtre "FEN_Menu", cliquez sur le volet "Recherche de commandes". Le volet d’on-
glet vide apparaît.
2. Créez un champ Table : sous le volet "Création", dans le groupe "Données", déroulez "Table
et liste" et sélectionnez "Table (Verticale)".
3. Cliquez dans le volet d’onglet : l’assistant de création du champ Table se lance.
4. Le champ Table va être basé sur la requête "REQ_RechercheCommandes" (que nous avons
créée précédemment). Sélectionnez l’option "Afficher les données d’un fichier ou d’une re-
quête existante". Passez à l’écran suivant de l’assistant.
5. Sélectionnez la requête qui sera la source de données du champ Table :
• Déroulez si nécessaire le groupe "Requêtes".
• Sélectionnez la requête "REQ_RechercheCommandes".
• Passez à l’écran suivant de l’assistant.
6. Sélectionnez toutes les rubriques proposées. Passez à l’écran suivant de l’assistant.
7. Conservez les options par défaut dans les différents écrans de l’assistant et validez la créa-
tion du champ Table.
8. Le champ Table est automatiquement créé dans l’onglet "Recherche des commandes".
9. Si nécessaire, modifiez la position du champ Table pour qu’il apparaisse entièrement dans
le volet d’onglet.
Pour plus de lisibilité, nous allons renommer les libellés des colonnes du champ Table.
1. Affichez la description du champ Table (double-cliquez sur le champ).
La fenêtre de description d’un champ Table est composée de deux zones :

• la zone supérieure présentant le nom du champ, des colonnes et leur type.
• la zone inférieure composée des différents onglets de description.
Notes
Si le nom du champ Table est sélectionné, la partie inférieure présente les carac-
téristiques du champ Table.
Si une colonne est sélectionnée, la partie inférieure présente les caractéris-
tiques des colonnes.
2. Cliquez sur la colonne "COL_IDCommande". Le titre de la colonne apparaît dans la partie
basse de l’écran. Remplacez le libellé "Identifiant de la commande" par "ID".
3. Cliquez sur la colonne "COL_NomComplet". Remplacez le libellé "Nom complet" par "Client".
4. Cliquez sur la colonne "COL_Libellé". Remplacez le libellé "Libellé" par "Mode de règlement".
5. Validez la fenêtre de description du champ Table. Le champ est automatiquement mis à

jour avec les changements effectués.
6. Agrandissez la taille des colonnes ID, Date et Etat du champ Table :
• Survolez le séparateur de colonne à droite de la colonne à agrandir. Le curseur de la souris
se transforme en double flèche.
• Cliquez et maintenez le bouton de la souris enfoncé pendant l’agrandissement de la co-
lonne.
• Une fois que la colonne est à la taille voulue, relâchez le bouton de la souris.
7. Diminuez la taille de la colonne "Mode de règlement" afin que toutes les colonnes appa-
raissent dans le champ Table :
• Affichez l’extrémité de la table en utilisant l’ascenseur horizontal (comme si la fenêtre était
en exécution).
• Survolez le séparateur de colonne à droite de la colonne "Mode de règlement". Le curseur
de la souris se transforme en double flèche.
• Cliquez et maintenez le bouton de la souris enfoncé pendant la diminution de la colonne.
• Une fois que la colonne est à la taille voulue, relâchez le bouton de la souris.
8. Enregistrez la fenêtre en cliquant sur parmi les boutons d’accès rapide. Nous allons
vérifier les tailles des colonnes en exécutant la fenêtre.
Pourquoi le Live Data ne marche pas dans ce champ ?

Notes
Les données ne sont pas affichées directement dans le champ Table car ce
champ est basé sur une requête. Les données affichées dépendent du résultat
de la requête et ne peuvent être connues qu’en exécution.
Nous allons faire un premier test de cette fenêtre :

2. Cliquez sur l’onglet "Recherche de commandes". Seules 22 commandes s’affichent,
comme lors du dernier test de la requête réalisé sous l’éditeur, lorsque nous avions spécifié
les paramètres dans la fenêtre de test de la requête.
3. Fermez la fenêtre de test pour revenir sous l’éditeur.
Regardons les traitements associés au champ Table :
1. Sélectionnez le champ Table.
2. Affichez le menu contextuel (clic droit) et sélectionnez l’option "Code".
3. Le traitement "Initialisation de TABLE_REQ_RechercheCommandes" contient le code sui-
vant :
// Paramètres de la requête ‘REQ_RechercheCommandes’
//MaSource.pEtat = <Valeur du paramètre pEtat>
MaSource.pIDModeReglement = "1"
MaSource.pDébutPériode = "20110101"
MaSource.pFinPériode = "20110331"
Les paramètres de test ont été récupérés comme paramètres par défaut pour l’exécution.
Nous allons maintenant modifier la fenêtre pour que les paramètres soient saisis par
l’utilisateur, à l’aide de champs.
4. Fermez l’éditeur de code (utilisez la croix en haut à droite de l’éditeur).
Nous allons maintenant créer dans notre fenêtre les différents champs permettant à l’utilisateur
de sélectionner les différents paramètres de la requête. Ces champs vont être placés au-dessus
du champ Table.
Si nécessaire, déplacez le champ Table dans la fenêtre et diminuez sa hauteur afin de laisser
de l’espace pour créer les différents champs de sélection des critères.
Premier paramètre : Etat de la commande
Une commande peut avoir 3 états :

• en attente,
• payée,
• annulée.
Dans notre analyse, l’état de la commande est enregistré dans la rubrique "Etat" présente dans le
fichier de données "Commande". Cette rubrique est de type sélecteur.
Pour permettre à l’utilisateur de sélectionner un de ces trois états, nous allons utiliser le champ
Sélecteur associé à la rubrique "Etat" du fichier de données "Commande".
Les sélecteurs d’options sont également appelés "case d’options". Ils permettent
de sélectionner une option et une seule, parmi celles proposées.
Comment différencier le sélecteur et l’interrupteur ?
Notes
Le sélecteur est également appelé "Bouton radio". Un moyen mnémotechnique

simple : pensez aux anciennes radios : le bouton permettait de sélectionner une
seule fréquence !
Le sélecteur permet de sélectionner une seule option.
Pour créer le champ Sélecteur :
1. Affichez si nécessaire le volet "Analyse" : sous le volet "Accueil", dans le groupe
"Environnement", déroulez "Volets" et sélectionnez "Analyse". Les différents fichiers de données
décrits dans l’analyse "WD Application Complète" apparaissent dans le volet.
2. Cliquez sur l’icône "+" à gauche du fichier "Commande" : les rubriques du fichier de don-
nées sont listées.
3. Sélectionnez la rubrique "Etat" présente dans le fichier Commande et réalisez un "Drag and
Drop" de cette rubrique vers la fenêtre "FEN_Menu".
4. Le champ Sélecteur est automatiquement créé. Positionnez ce champ au-dessus du champ
Table.
Nous allons maintenant passer la valeur sélectionnée dans le champ Sélecteur en paramètre
à la requête :
1. Affichez les traitements associés au champ Table :
• Sélectionnez le champ Table.
• Affichez le menu contextuel (clic droit) et sélectionnez l’option "Code".
2. Dans le traitement d’initialisation du champ Table, remplacez la ligne :
//MaSource.pEtat = <Valeur du paramètre pEtat>
par
MaSource.pEtat = SEL_Etat
Dans ce code, SEL_Etat est le nom du champ Sélecteur que nous venons de créer. La valeur
de ce champ est associée au paramètre pEtat attendu par la requête.
Avant de tester, nous allons créer un bouton pour réafficher le contenu du champ Table en
fonction de la valeur sélectionnée dans le champ Sélecteur :
1. Créez un champ Bouton :
• sous le volet "Création", dans le groupe "Champs usuels", cliquez sur .
• cliquez ensuite dans la fenêtre, en haut à droite.
2. Sélectionnez le champ puis tapez sur la touche "Entrée" du clavier. Le libellé du bouton
passe en édition. Saisissez "Rechercher" et appuyez sur la touche "Entrée" du clavier.
3. Modifiez le style du champ :
• Affichez le menu contextuel du champ (clic droit) et sélectionnez l’option "Choisir un style".
• Dans la fenêtre qui s’affiche, sélectionnez "BTN_Recherche" et validez.
4. Redimensionnez le champ si nécessaire.
5. Affichez le code associé à ce champ : appuyez sur la touche [F2].
6. Dans le traitement "Clic sur ...", saisissez le code suivant :
// Actualise l’affichage du champ Table
TableAffiche(TABLE_REQ_RechercheCommandes, taInit)
Dans ce code, la constante taInit permet de réexécuter le traitement d’initialisation du

champ Table (le traitement dans lequel les paramètres sont passés à la requête).
Nous allons tester le passage du premier paramètre :
3. Sélectionnez si nécessaire l’onglet "Recherche de commandes".
4. Changez l’état des commandes grâce au sélecteur puis cliquez sur le bouton "Rechercher".
Le contenu du champ Table est modifié.
Second paramètre : Mode de règlement
Une commande peut avoir plusieurs modes de règlement : espèces, chèques, ... Les différents
modes de règlement possibles sont stockés dans le fichier de données "ModeRèglement".
Nous allons utiliser un champ Combo basé sur ce fichier de données pour permettre à l’utilisateur
de sélectionner le mode de règlement voulu.
Le champ "Combo" permet d’afficher une liste d’éléments et de sélectionner un

élément dans cette liste.
A la différence d’une liste, une combo n’est pas déroulée : elle se déroule à la
demande ou lors du positionnement du curseur sur la liste.
Notes
Les éléments apparaissant dans une combo peuvent être déterminés lors de la
création du champ sous l’éditeur. Ces éléments :
• sont déterminés par programmation.
• proviennent d’un fichier de données ou d’une requête.
Pour créer un champ Combo :

1. Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur "Combo".
2. Cliquez dans la fenêtre à l’emplacement où le champ doit être créé (par exemple à côté du
sélecteur précédemment créé).
3. L’assistant de création du champ Combo se lance.
4. Sélectionnez l’option "Afficher les données d’un fichier ou d’une requête existante" et pas-
5. Sélectionnez le fichier de données "ModeRèglement" et passez à l’écran suivant.
6. La rubrique à afficher dans le champ Combo est "Libellé". Décochez "IDModeRèglement" et
cochez "Libellé". Passez à l’écran suivant.
7. Sélectionnez la rubrique de tri : "Libellé". Passez à l’écran suivant.
8. Sélectionnez la valeur de retour "IDModeRèglement". Cette valeur de retour est très impor-
tante car c’est elle qui sera passée en paramètre à la requête. Passez à l’écran suivant.
9. Conservez les options par défaut dans les différents écrans de l’assistant et validez la créa-
tion du champ Combo.
10. Le champ Combo est automatiquement créé dans la fenêtre.
Nous allons modifier quelques caractéristiques du champ Combo :
1. Sélectionnez le champ Combo et affichez la fenêtre de description du champ (option
"Description"du menu contextuel).
2. Dans l’onglet "Général", modifiez le libellé du champ : remplacez "Combo ModeRèglement"
par "Mode de règlement".
3. Dans l’onglet "Contenu", spécifiez la valeur initiale affichée par le champ Combo. Dans
notre cas, saisissez "1". Cette valeur correspond au paiement en espèces.
Changez le look du champ : pour occuper moins de place, nous allons sélectionner un style
affichant le libellé au-dessus du champ.
1. Sélectionnez le champ Combo.
2. Dans le menu contextuel (clic droit), sélectionnez l’option "Choisir un style".
3. Dans la fenêtre qui s’affiche, sélectionnez le style "COMBO_Interne" et validez.
4. Diminuez la taille du champ.
Nous allons maintenant passer la valeur sélectionnée dans le champ Combo en paramètre à
la requête :
2. Dans le traitement d’initialisation du champ Table, remplacez la ligne :
MaSource.pIDModeRèglement = 1
par
MaSource.pIDModeRèglement = COMBO_ModeRèglement
Dans ce code, COMBO_ModeRèglement est le nom du champ Combo que nous venons de
créer. La valeur de retour de ce champ est associée au paramètre pIDModeRèglement
attendu par la requête.
Nous allons tester le passage des deux premiers paramètres :
2. Sélectionnez si nécessaire l’onglet "Recherche des commandes".
3. Changez l’état des commandes grâce au sélecteur et modifiez le mode de règlement grâce
au champ Combo puis cliquez sur le bouton "Rechercher". Le contenu du champ Table est
modifié.
Dernier paramètre : Date de commande
Le dernier paramètre de la requête correspond à la date des commandes prises en compte. Au
niveau de l’interface, l’utilisateur doit pouvoir saisir un intervalle de dates. Nous allons utiliser
pour cela un modèle de champs.
Un modèle de champs est une fenêtre spécifique contenant différents champs.

Dans cette fenêtre, vous pouvez mettre tout type de champs. Un modèle de
champs est un fichier d’extension "WDT".
L’intérêt premier d’un modèle de champs est la ré-utilisabilité. Un modèle de
Notes
champs présent dans un projet peut être réutilisé dans n’importe quelle fenêtre
du projet.
Les modèles de champs peuvent être surchargés : du code peut être ajouté, les
champs peuvent être déplacés dans la fenêtre utilisant le modèle de champs.
Les champs peuvent être modifiés.
Pour gérer la date de la commande :

1. Dans l’explorateur de projet, déroulez le dossier "Modèle de champs".
2. Sélectionnez le modèle de champs "MDLC_ChoixPériode" dans l’explorateur de projet et
réalisez un "Drag and Drop" vers la fenêtre "FEN_Menu" (à côté du champ "Mode de règle-
ment").
3. Sélectionnez le modèle de champs créé et affichez sa description (option "Description" du

menu contextuel).
4. Dans la fenêtre de description, renommez le modèle de champs. Le nouveau nom est
"CMOD_ChoixPériode".
6. Repositionnez et alignez les champs si nécessaire.
Nous allons maintenant passer les dates sélectionnées en paramètre à la requête :
2. Dans le traitement d’initialisation du champ Table, remplacez les lignes :
MaSource.pDébutPériode = "20110101"
MaSource.pFinPériode = "20110331"
par :
MaSource.pDébutPériode = SAI_DateDébut
MaSource.pFinPériode = SAI_DateFin
Dans ce code, SAI_DateDébut et SAI_DateFin sont les noms des deux champs de saisie
présents dans le modèle de champs. Leurs valeurs sont associées aux paramètres pDébut-
Période et pFinPériode attendus par la requête.
Nous allons tester le passage des paramètres :
3. Définissez les différents paramètres de la recherche :
• Etat des commandes,
• Mode de règlement,
• Fourchette de dates prises en compte.
4. Cliquez sur le bouton "Rechercher". Le contenu du champ Table est modifié.
Leçon 3.5. Imprimer le contenu d’un
champ Table
• Imprimer le contenu d’un champ Table

• Imprimer un bon de commande
Présentation
WinDev permet d’imprimer vos données :
• directement par programmation.
• via les états. Un état est le nom donné à la représentation graphique d’une édition. Un état est
créé grâce à l’éditeur d’états.
WinDev propose de nombreux types d’états :
• Vierge
• Fiche
• Etiquette
• Tableau
• Tableau croisé
• Tableau hiérarchique
• Diagramme de Gantt
• Agenda ou planning
• Etat multicolonne
• Mailing
• Formulaire
• Composite
Nous allons maintenant découvrir comment créer différents types d’états dans l’application "WD
Application Complète".
Si vous n’avez pas créé les fenêtres des leçons précédentes, vous pouvez suivre
cette leçon en ouvrant un projet corrigé : sous le volet "Accueil", dans le groupe
Corrigé "Aide en ligne", déroulez "Guide d’auto-formation" puis sélectionnez "Application
complète (Avec fenêtres)".
Un projet corrigé complet de l’application est également disponible : sous le vo-
let "Accueil", dans le groupe "Aide en ligne", déroulez "Guide d’auto-formation"
puis sélectionnez "Application complète (Corrigé)".
Impression du contenu d’un champ Table

Dans la leçon précédente, nous avons créé un champ Table permettant d’afficher le résultat d’une
recherche multicritère. Nous allons étudier maintenant les différentes possibilités pour imprimer
le contenu de ce champ Table.
Impression directe via la FAA (Fonctionnalité automatique de l’application)

Dans les leçons précédentes, nous avons déjà vu que WinDev proposait de nombreuses fonction-
nalités automatiques (appelées FAA). Pour l’impression du contenu d’un champ Table, il existe
une FAA.
La liste complète des FAA (Fonctionnalités automatiques de l’application) est

disponible dans le fichier WinDev FAA 19.PDF. Ce fichier est automatiquement
Note
intégré dans votre application si vous choisissez l’option "Aide des FAA" lors de la
création du menu automatique.
Faisons un test rapide :

1. Affichez si nécessaire la fenêtre "FEN_Menu" sous l’éditeur de fenêtres.
4. Définissez les différents paramètres de la recherche :
• Etat des commandes
• Mode de règlement
• Fourchette de dates prises en compte.
5. Cliquez sur le bouton "Rechercher".
6. Lorsque les données sont affichées dans le champ Table, affichez le menu contextuel du
champ (icône en haut à droite ou clic droit sur le champ).
7. Cliquez sur l’option "Imprimer".
8. Si nécessaire, choisissez d’imprimer en mode "Paysage" le contenu du champ Table. L’état
correspondant au champ est aussitôt affiché dans une fenêtre d’aperçu.
En mode test, le contenu du champ Table est directement imprimé.
En exécution, l’utilisateur final a la possibilité d’imprimer directement ou de lan-
Note cer le logiciel "Etats et Requêtes" pour créer l’état correspondant. Pour plus de
détails sur le logiciel Etats et Requêtes, consultez "Diffusez "Etats & Requêtes"
avec vos applications", page 315.
9. Fermez la fenêtre d’aperçu et arrêtez le test de l’application.

Vous voulez personnaliser l’état proposé par défaut ? Il suffit de créer un état automatique sur
le champ Table. Cet état (s’il existe) sera automatiquement utilisé par l’option d’impression du
champ Table.
Création d’un état automatique sur un champ Table

Pour créer un état imprimant les données d’un champ Table, il suffit de créer un "Etat sur champ
table" : l’état correspondant à la table est créé automatiquement.
Pour créer un "Etat sur champ table" :

"Etat sur champ table".
2. Notre fenêtre contenant 2 champs Table sur des volets d’onglet différents, WinDev de-
mande de sélectionner le champ Table voulu. Dans notre cas, sélectionnez "TABLE_REQ_Re-
chercheCommandes" et validez.
3. La forme d’un bouton apparaît sous le curseur de la souris. Ce bouton est automatique-
ment créé et contient le code permettant de lancer l’impression du contenu du champ Table.
Cliquez dans la fenêtre à la position où le bouton doit être créé (par exemple en dessous du
bouton "Rechercher").
4. L’état est immédiatement créé.
5. Une fenêtre s’affiche proposant d’ajouter l’état au projet. Validez.
6. L’éditeur d’états apparaît avec l’état qui a été automatiquement créé.
7. Enregistrez l’état en cliquant sur parmi les boutons d’accès rapide.
8. Vous retrouvez dans cet état les titres des colonnes du champ Table présent dans la fe-
nêtre. Nous allons juste faire une petite modification dans cet état : nous allons modifier le
titre :
• Sélectionnez le champ correspondant au titre de l’état ("Table REQ_RechercheCommandes"
est affiché dans le champ) et double-cliquez sur ce champ.
• Dans la fenêtre de description, modifiez le libellé et saisissez "Commandes recherchées".
• Validez.
10. Revenez sur la fenêtre "FEN_Menu" (par exemple en cliquant sur le bouton "FEN_Menu"
présent dans la barre des éléments ouverts sous WinDev).
11. Modifiez si nécessaire la taille et la position du bouton "Imprimer" (pour qu’il ait la même
taille que le bouton "Rechercher").
13. Testez la fenêtre. Utilisez le bouton d’impression ou l’option "Imprimer" du menu contex-
tuel du champ Table : l’état que vous venez de créer est utilisé dans les deux cas.
Leçon 3.6. Imprimer une commande
• Créer un état basé sur une requête

• Lancer l’impression d’un état basé sur une requête paramétrée
Présentation
Nous allons maintenant donner la possibilité à l’utilisateur d’imprimer directement le détail de la
commande recherchée. L’état pourra être imprimé directement via le menu contextuel du champ
Table.
"Aide en ligne", déroulez "Guide d’auto-formation" puis sélectionnez "Application
Corrigé

Création de l’état "Bon de commande"

Nous allons tout d’abord lister les informations qui doivent être affichées dans l’état :
• Les caractéristiques de la commande : date et numéro de commande.
• Les coordonnées du client : nom, adresse, code postal, ville et pays.
• Les caractéristiques des lignes de commande :
• Quantité commandée
• Référence du produit
• Libellé du produit
• Total HT
• Total TTC
Pour créer simplement cet état, nous allons rassembler toutes les données à imprimer dans une
requête. Cette requête pourra être utilisée par l’état ou par tout autre élément du projet WinDev
(champ Table, champ Zone répétée, ...).
WinDev propose de créer des états à partir de nombreuses sources de données :

fichiers de données, requêtes, champs, fichiers texte, ...
Dans la majorité des cas, il est conseillé de rassembler les données à imprimer
via une requête, puis de créer un état sur cette requête. Si une information doit
Note
être ajoutée dans l’état, il suffira d’ajouter la rubrique correspondante dans la

requête.
Les états réalisés directement sur les fichiers de données doivent être réser-
vés à des états simples, c’est-à-dire affichant des données provenant d’un seul
fichier de données.
Création de la requête
Pour créer la requête de base de l’état, nous allons utiliser l’éditeur de requêtes.
"Requête". L’assistant de création de requêtes se lance.
2. Sélectionnez l’option "Sélection (SELECT)".
En effet, la requête que nous allons créer va nous permettre de sélectionner les enregistre-
ments qui seront imprimés dans l’état. Passez à l’écran suivant.
3. La fenêtre de description de la requête apparaît. Nous allons construire la requête en sélec-
tionnant les éléments que nous voulons dans le résultat.
4. Double-cliquez sur les rubriques présentes dans l’analyse à gauche de la fenêtre de
description. Les rubriques prises en compte apparaissent alors au centre de l’écran.
Nous voulons imprimer dans l’état :
• les renseignements concernant le client. Dans le fichier "Client", double-cliquez sur les ru-
briques NomComplet, Adresse, CodePostal, Ville et Pays.
• les renseignements concernant la commande. Dans le fichier "Commande", double-cliquez
sur les rubriques IDCommande et Date.
• les renseignements concernant le produit. Dans le fichier "Produit", double-cliquez sur les
rubriques Référence, Libellé et PrixHT.
• les renseignements concernant la ligne de commande. Dans le fichier "LigneCommande",
double-cliquez sur les rubriques Quantité et TotalHT.
• les renseignements sur le prix total de la commande. Dans le fichier "Commande", double-
cliquez sur les rubriques TotalHT et TotalTTC.
L’ordre dans lequel les rubriques sont insérées dans la requête est important. En
effet, cet ordre correspond à celui utilisé pour afficher les données dans l’état. Si
Note
cet ordre est correctement défini, la création de l’état correspondant sera d’au-
tant plus simple.
La fenêtre de description de la requête est la suivante :
A ce stade, cette requête permet de sélectionner toutes les commandes et les lignes de com-
mande correspondantes.
Nous voulons sélectionner les données correspondant à une seule commande dont l’identifiant
est connu. Nous allons donc définir en paramètre le numéro de commande.
Pour gérer le paramètre "Identifiant de la commande" :
1. Sélectionnez au centre de l’écran la rubrique Commande.IDCommande.
2. Déroulez le bouton "Condition de sélection" et sélectionnez "Nouvelle condition".
3. Dans la fenêtre qui s’affiche, nous allons indiquer que la condition de sélection correspond
à un paramètre :
Effectuez les opérations suivantes :
• Indiquez le nom du paramètre "pIDCommande".
4. Validez la fenêtre de description de la condition. Le chiffre "1" apparaît à droite de la ru-
brique Commande.IDCommande, indiquant qu’une condition de sélection a été définie.
5. Donnez un nom à la requête : saisissez "REQ_BonDeCommande" à la place de "REQ_Sans-
Nom1" dans la zone "Nom de la requête" :
6. Validez la fenêtre de description de la requête (bouton vert en bas de l’écran).

7. La représentation graphique de la requête est affichée :
8. Enregistrez la requête en cliquant sur parmi les boutons d’accès rapide. Validez si né-
cessaire les informations de sauvegarde.
Création de l’état basé sur une requête
Pour créer un état :

1. Cliquez sur le bouton parmi les boutons d’accès rapide.
2. Dans la roue qui s’affiche, cliquez sur "Etat". L’assistant de création d’états se lance.
3. L’assistant de création d’états propose plusieurs types d’états :
4. Sélectionnez "Tableau". Passez à l’écran suivant.

5. Sélectionnez la source des données de l’état. L’état va être basé sur la requête que vous
venez de créer. Sélectionnez "D’un fichier de données ou d’une requête existante". Passez à
l’écran suivant.
6. Dans la liste des fichiers de données et des requêtes, sélectionnez la requête "REQ_BonDe-
Commande". Passez à l’écran suivant.
7. L’assistant demande d’indiquer s’il y a une rupture. Dans cet état nous n’utilisons pas de
rupture. Nous verrons ce concept un peu plus loin dans ce cours. Répondez "Non". Passez à
l’écran suivant.
8. Vous allez ensuite indiquer dans quel ordre sont imprimées les rubriques et leur répartition
dans les différents blocs. Dans l’assistant, les rubriques sont listées dans l’ordre défini dans
la requête :
• Les rubriques concernant le client vont être affichées dans le bloc "En-tête de page". En ef-
fet, ces informations ne doivent pas être répétées pour chaque ligne de la commande.
Pour les rubriques NomComplet, Adresse, CodePostal, Ville et Pays, cliquez sur la ligne cor-
respondant à la rubrique. Dans la colonne "Bloc", déroulez la combo et sélectionnez "En-tête
de page".
• Les rubriques concernant la commande vont également être affichées dans le bloc "En-tête
de page". En effet, ces informations ne doivent pas être répétées pour chaque ligne de la
commande. Pour les rubriques IDCommande et Date, cliquez sur la ligne correspondant à la
rubrique. Dans la colonne "Bloc", déroulez la combo et sélectionnez "En-tête de page".
• De plus, nous allons en profiter pour modifier le libellé de la rubrique "IDCommande".
• Sélectionnez la ligne contenant la rubrique IDCommande.
• Cliquez dans la colonne Libellé et saisissez "N° Commande".
• Les rubriques concernant les lignes de commande vont rester dans le corps de l’état. Ces
rubriques seront affichées pour toutes les lignes de commandes de la commande.
• Les rubriques concernant les totaux de la commande seront affichées en bas de page. En
effet, ces informations ne doivent pas être répétées pour chaque ligne de la commande.
Pour les rubriques TotalHT_Co et TotalTTC, cliquez sur la ligne correspondant à la rubrique.
Dans la colonne "Bloc", déroulez la combo et sélectionnez "Pied de page".
Passez à l’écran suivant

9. L’assistant propose de créer un compteur, une somme ou une moyenne sur les rubriques
numériques présentes dans l’état. Dans cet état, les calculs sont faits par la requête. Cliquez
sur le bouton "Aucun calcul". Passez à l’écran suivant.
10. Cet écran permet de définir la mise en page de l’état.
Nous garderons les valeurs par défaut avec l’orientation "Portrait".
Marges d’impression
Lors du choix des marges d’impression, n’oubliez pas de tenir compte des
Notes marges physiques des imprimantes. Les marges physiques sont les marges
réservées par l’imprimante dans lesquelles il n’est pas possible d’imprimer. De
plus, les marges physiques diffèrent en fonction des modèles d’imprimante.

12. Cet écran permet de sélectionner le gabarit utilisé pour l’état. Il est conseillé d’utiliser
le même gabarit que pour les fenêtres. Dans notre cas, sélectionnez par exemple le gabarit
"Gensteel" et passez à l’écran suivant.
13. Il ne reste plus qu’à donner un nom et un titre à l’état.
• Saisissez le titre "Bon de commande".
• Le nom "ETAT_Bon_de_commande" est aussitôt proposé.
14. Validez.
15. L’état étant trop grand pour être imprimé en mode Portrait, l’éditeur d’états propose :
• soit d’imprimer sur plusieurs pages,
• soit d’utiliser le mode paysage,
• soit de réduire le tableau.
Dans notre cas, sélectionnez le mode paysage et validez.
16. L’état apparaît en édition sous l’éditeur d’états :
17. Les différentes lignes de la commande sont regroupées sous forme de tableau.
18. Enregistrez l’état en cliquant sur parmi les boutons d’accès rapide. Validez si néces-
saire les informations de sauvegarde.
Exécutez cet état en cliquant sur parmi les boutons d’accès rapide.
1. L’éditeur d’états demande la destination de l’impression. La destination de l’impression peut
être au choix :
Choisissez "Aperçu avant impression" et validez.
2. L’éditeur d’états demande les paramètres de la requête utilisée par l’état. Rappelez-vous,
nous avons, en effet, utilisé un paramètre pour spécifier le numéro de la commande à impri-
mer. Pour l’exemple, saisissez la valeur de test "1".
Validez.
3. L’exécution de l’état s’affiche à l’écran.
Vous pouvez :
• Directement imprimer la page en cours ou la totalité du document en cliquant sur l’impri-
mante .
• Créer un duplicata.
• Sélectionner un niveau de zoom plus ou moins important avec les icônes .
• Enregistrer l’état sous forme d’un document Word (au format RTF).
• Enregistrer l’état au format HTML.
• Enregistrer l’état au format PDF.
• Enregistrer l’état au format XML.
• Créer un e-mail avec l’état au format HTML en corps du message.
• Créer un e-mail avec l’état au format PDF en document lié.
• Annoter le document.
• Effectuer une recherche dans le document.
• Ajouter des filigranes.
Modifications de l’état "Bon de commande"

Nous allons effectuer quelques modifications de mise en page dans l’état que nous venons de
créer.
Supprimez le nombre de pages affiché dans l’état :
1. Sélectionnez le champ [NUMPAGE]/[NBPAGES].
2. Appuyez sur la touche [SUPPR] du clavier.
Nous allons maintenant positionner les informations concernant le client et la commande
dans le haut de page :
1. Supprimez le libellé "Bon de commande" présent en haut de page.
2. Supprimez les libellés devant les informations client (Nom complet, ...).
3. Positionnez la rubrique contenant la ville à côté du code postal.
4. Sélectionnez les informations concernant le client et déplacez-les à l’aide de la souris sur
la droite de l’état.
5. Remontez le numéro de commande et la date de la commande (en haut du bloc "Haut de
page").
Nous allons positionner les totaux correctement dans le bas de page :
1. Sélectionnez les champs (libellés et rubriques) correspondant aux totaux présents dans le
bas de page.
2. Positionnez ces champs à l’aide de la souris en bas à droite du tableau.
Modifiez les options d’impression du bloc "Bas de page" :
1. Affichez la fenêtre de description du bloc "Bas de page" :
• Cliquez dans le bloc "Bas de page".
• Affichez le menu contextuel (clic droit) et sélectionnez "Description du bloc".
2. Dans l’onglet "Général", cochez les options suivantes :
• Imprimer le bloc "Fin de document" APRES le bloc "Bas de page" sur la dernière page.
• Le bloc "Bas de page" ne s’imprime pas en bas de la page, il se colle aux blocs précédents.
4. L’état est affiché sous l’éditeur d’états :
Notre état "Bon de commande" est terminé.
Affichage de l’état imprimé depuis une option de menu
Dans notre application, l’état "ETAT_Bon_de_commande" va être imprimé depuis une option du
menu contextuel du champ Table listant les commandes recherchées.
Par défaut, nous l’avons déjà vu, le champ Table propose un menu automatique. Nous voulons
conserver les options de ce menu automatique et ajouter une option qui permettra d’imprimer le
bon de commande sélectionné.
Le principe utilisé est le suivant :
1. Nous allons créer un nouveau menu contextuel. Ce menu contiendra le code WLangage per-
mettant de lancer l’impression de l’état.
2. Nous allons lier ce menu contextuel au champ Table et indiquer que le menu contextuel par
défaut viendra à la suite du menu contextuel défini pour le champ Table.
Création du menu contextuel
Pour créer un menu contextuel dans la fenêtre "FEN_Menu" :

1. Ouvrez si nécessaire la fenêtre "FEN_Menu" sous l’éditeur (double-cliquez sur son nom dans
l’explorateur de projet par exemple).
2. Sous le volet "Fenêtre", dans le groupe "Barres et menus", déroulez "Menus contextuels" et
sélectionnez "Nouveau menu contextuel".
3. Un nouveau menu contextuel apparaît sous l’éditeur. Ce menu possède une seule option
"Option de menu".
4. Affichez la description du menu contextuel :

• Sélectionnez "Option de menu".
• Affichez le menu contextuel (clic droit).
• Sélectionnez l’option "Description du menu contextuel".
5. Donnez un nom au menu contextuel "MENU_Commande" et validez.
Menus contextuels et fenêtres

Notes
Un menu contextuel est associé à une fenêtre. Si une fenêtre possède plusieurs
menus contextuels (menu contextuel de la fenêtre, menus contextuels des
champs, ...), tous ces menus sont enregistrés avec la fenêtre.
Nous allons maintenant définir le libellé de l’option et son code.
1. Sélectionnez l’option "Option de menu".
2. Appuyez sur la touche [Espace] du clavier : le libellé passe en édition. Saisissez le nouveau
libellé "Imprimer le bon de commande" et validez.
3. Affichez le code associé à l’option :
• Sélectionnez l’option.
// Aperçu avant impression

iAperçu()
// Initialise la requête de l’état

iInitRequêteEtat(ETAT_Bon_de_commande, ...
TABLE_REQ_RechercheCommandes.COL_IDCommande)
// Lance l’impression de l’état
iImprimeEtat(ETAT_Bon_de_commande)
Dans ce code :
• La fonction iAperçu permet d’indiquer que l’impression de l’état sera effectuée dans
l’aperçu avant impression.
• La fonction iInitRequêteEtat permet de spécifier les paramètres attendus par la requête as-
sociée à l’état. Dans notre cas, la requête attend en paramètre le numéro de commande.
Ce numéro de commande est présent dans la colonne COL_IDCommande du champ Table
TABLE_REQ_RechercheCommandes pour la ligne en cours.
• La fonction iImprimeEtat permet de lancer l’impression de l’état spécifié (ici, l’état ETAT_
Bon_de_commande).
5. Fermez la fenêtre de code et la fenêtre contenant le menu contextuel.
6. Enregistrez la fenêtre "FEN_Menu".
Association du menu contextuel au champ Table
Dernière étape : nous allons lier le menu contextuel au champ Table.

1. Dans la fenêtre "FEN_Menu", affichez l’onglet "Recherche de commandes".
2. Sélectionnez le champ Table et affichez sa description (option "Description" du menu
contextuel du champ).
3. Dans l’onglet "IHM", déroulez la combo "Menu Ctx.".
4. Cochez l’option "Ajouter un menu contextuel", sélectionnez le menu "MENU_Commande" et
sélectionnez l’option "Au début" pour indiquer que le menu est placé avant le menu système.
5. Validez.
Test de l’impression
Il ne reste plus qu’à effectuer un test en réel :

1. Lancez le test de la fenêtre "FEN_Menu".
2. Sélectionnez le volet d’onglet "Recherche de commandes".
3. Spécifiez les critères et lancez une recherche.
4. Sélectionnez une des commandes affichée dans le champ Table.
5. Imprimez la commande via le menu contextuel.
6. Fermez l’aperçu avant impression ainsi que la fenêtre de test.
Leçon 3.7. Imprimer une liste de
clients
• Créer un état avec ruptures

• Lancer l’impression d’un état
Présentation
Cette leçon permet d’imprimer une liste des clients, regroupés par pays et par département ou
province.
Pour cela, nous allons utiliser un état de type tableau, qui permet de représenter clairement une
liste de données.
Corrigé

Création de l’état
Pour créer un état :

1. Cliquez sur le bouton parmi les boutons d’accès rapide.
2. Dans la roue qui s’affiche, cliquez sur "Etat". L’assistant de création d’états se lance. L’as-
sistant de création d’états propose plusieurs types d’états :
3. Sélectionnez "Tableau". Passez à l’écran suivant.
4. Sélectionnez la source des données de l’état. L’état va être basé sur le fichier Client. Sélec-
tionnez "D’un fichier de données ou d’une requête existante". Passez à l’écran suivant.
5. Dans la liste des fichiers de données et des requêtes, sélectionnez le fichier "Client". Pas-
6. Définissez la clé de parcours du fichier. Dans notre cas, nous allons parcourir le fichier
Client selon le nom complet du client. Sélectionnez la clé de parcours "NomComplet". Passez
à l’écran suivant.
7. Nous allons maintenant définir les options de tri des données dans l’état. Par défaut, l’as-
sistant propose la rubrique utilisée comme clé de parcours du fichier de données. Comme
nous voulons faire un état listant les clients par pays et par département, nous allons ajouter
un tri sur ces deux rubriques.
8. Pour ajouter un tri sur le pays :
• Cliquez sur le bouton "+" pour ajouter une rubrique de tri.
• Dans la fenêtre qui s’affiche, sélectionnez la rubrique Client.Pays.
• Validez.
9. Pour ajouter un tri sur le département :
• Cliquez sur le bouton "+" pour ajouter une rubrique de tri.
• Dans la fenêtre qui s’affiche, sélectionnez la rubrique Client.EtatProvinceRégion.
• Validez.
10. Modifiez l’ordre des rubriques de tri. Les clients doivent être triés par pays, région puis par
ordre alphabétique.
• La rubrique "Client.Pays" apparaît en seconde rubrique de tri. Sélectionnez cette rubrique et
déplacez-la en première rubrique de tri à l’aide des boutons fléchés.
• La rubrique "Client.EtatProvinceRégion" apparaît en troisième rubrique de tri. Sélectionnez
cette rubrique et déplacez-la en seconde rubrique de tri à l’aide des boutons fléchés.

11. L’assistant demande d’indiquer s’il y a une rupture.
Qu’est-ce qu’une rupture ?
Une Rupture est une opération qui consiste à regrouper des enregistrements (ou
lignes) suivant un ou plusieurs critères. Attention, les enregistrements (ou lignes)
sont bien entendu imprimés.
Une rupture est OBLIGATOIREMENT liée à un tri.
Notez la présence d’un en-tête de rupture et d’une fin de rupture.
Notes
Les informations communes aux différentes lignes sont présentes dans l’en-tête
de rupture.
Les totaux, compteurs, ... sont présents dans la fin de rupture.
Cette rupture permet de regrouper une série d’enregistrements par rapport à
un même critère. Dans notre exemple, la rupture concerne le pays et permet de
regrouper tous les clients d’un même pays.
12. Répondez "Oui". Passez à l’écran suivant.

13. Indiquez sur quelle rubrique de tri la rupture doit s’effectuer. Dans notre cas, nous allons
utiliser plusieurs ruptures :
• la première rupture s’effectue sur le pays.
• la seconde rupture s’effectue la province.
Décochez la rubrique "Client.NomComplet".
15. Vous allez ensuite indiquer dans quel ordre sont imprimées les rubriques et leur réparti-
tion dans les différents blocs. Dans notre exemple :
• seul le pays sera dans le bloc "haut de rupture 1". La rubrique "Pays" est automatiquement
associée au "Haut de rupture 1".
• seul l’état sera dans le bloc "haut de rupture 2". La rubrique "EtatProvinceRégion" est auto-
matiquement associée au "Haut de rupture 2".
• seules les rubriques NomComplet, Adresse, CodePostal, Ville, EtatProvinceRégion et Pays
seront affichées dans l’état.
Décochez les rubriques IDClient, Complément, Téléphone, Mobile et Email. Passez à l’écran
suivant.
16. Cet écran permet de définir la mise en page de l’état.
Nous garderons les valeurs par défaut avec l’orientation "Portrait".
Marges d’impression
Lors du choix des marges d’impression, n’oubliez pas de tenir compte des
Notes
marges physiques des imprimantes. Les marges physiques sont les marges
réservées par l’imprimante dans lesquelles il n’est pas possible d’imprimer. De
plus, les marges physiques diffèrent en fonction des modèles d’imprimante.

18. Cet écran permet de sélectionner le gabarit utilisé pour l’état. Il est conseillé d’utiliser
le même gabarit que pour les fenêtres. Dans notre cas, sélectionnez par exemple le gabarit
"Gensteel" et passez à l’écran suivant.
19. Il ne reste plus qu’à donner un nom et un libellé à l’état et à le sauvegarder.
• Saisissez le titre "Liste des clients".
• Conservez le nom proposé par défaut : "ETAT_Liste_des_clients".
20. Validez.
21. L’état est trop large. Sélectionnez l’option "Utiliser le mode paysage" et validez.
22. Sélectionnez l’option "Réduire le tableau à XX% de l’original" et validez.
23. L’état apparaît sous l’éditeur d’états. Enregistrez l’état.
L’état est terminé. Nous allons immédiatement le tester pour voir le résultat.
Exécutez cet état en cliquant sur parmi les boutons d’accès rapide.
La destination de l’impression peut être au choix :
Choisissez "Aperçu avant impression" et validez.
L’exécution de l’état s’affiche à l’écran.
Vous pouvez imprimer directement la page en cours ou la totalité du document en cliquant sur
l’imprimante .
Lancement de l’impression d’un état par programmation

Notre état étant terminé, nous allons créer un menu dans notre fenêtre "FEN_Menu" pour lancer
directement l’impression de cet état.
Pour insérer un menu dans la fenêtre "FEN_Menu" :
1. Affichez la fenêtre "FEN_Menu" sous l’éditeur (double-cliquez sur son nom dans le volet "Ex-
plorateur" par exemple).
2. Sous le volet "Fenêtre", dans le groupe "Barres et menus", déroulez "Menu principal" et
sélectionnez l’option "Ajouter le menu principal".
3. Un menu s’insère dans la fenêtre sous la barre de titre. Ce menu contient par défaut une
option qui se nomme "Menu".
4. Sélectionnez l’option "Menu" :
• Sélectionnez l’option "Ajouter après".
5. Dans la zone de saisie, saisissez "Etats".
6. Sélectionnez l’option "Etats" :

• Sélectionnez l’option "Transformer pour dérouler un sous-menu".
7. Dans la zone de saisie qui s’affiche, saisissez "Liste des clients". Validez avec la touche
[ENTREE].
Pour saisir le code de l’option "Liste des clients" :

1. Sélectionnez l’option "Liste des clients" sous l’éditeur.
2. Affichez le menu contextuel (clic droit).
3. Sélectionnez l’option "Code". L’éditeur de code apparaît.
4. Dans le traitement "Sélection du menu", saisissez le code suivant :
// L’impression se fait dans un aperçu
iAperçu()
// Imprime l’état
iImprimeEtat(ETAT_Liste_des_clients)
Examinons ce code :
• La fonction iAperçu (ou iDestination) permet de paramétrer la destination de l’impression. Il
est par exemple possible d’imprimer :
• dans un fichier texte,
• au format HTML,
• au format PCL,
• au format PDF, RTF, XLS, XML,
• sur un fax.
Dans notre cas, l’impression se fera dans la fenêtre d’aperçu avant impression.
• La fonction iImprimeEtat (comme son nom l’indique) permet d’imprimer un état.
Testez la fenêtre et ses options de menu en cliquant sur parmi les boutons d’accès
rapide.
Nous allons maintenant finir ce menu en ajoutant une option pour quitter l’application.
1. Sous l’éditeur, sélectionnez l’option "Menu".
2. Dans le menu contextuel (clic droit), sélectionnez l’option "Transformer pour dérouler un
sous-menu".
3. Dans la zone de saisie qui s’affiche, saisissez "Quitter".
4. Nous allons associer cette option de menu au raccourci clavier "ALT + F4" :
• Sélectionnez l’option de menu "Quitter".
• Dans le menu contextuel (clic droit), sélectionnez l’option "Description de l’option".
• Dans l’onglet "Général", dans la zone "Raccourci clavier", sélectionnez "F4" et cochez "Alt".
• Validez
5. Affichez le code de l’option et dans le traitement "Sélection du menu", saisissez le code
suivant :
// Demande à l’utilisateur s’il souhaite quitter l’application

SI OuiNon(Non,"Quitter l’application ? ") = Oui ALORS
// Fin de l’application
FinProgramme()
FIN
Examinons ce code :
• La fonction OuiNon permet de dialoguer avec l’utilisateur en lui posant une question. L’utili-
sateur peut répondre à la question à l’aide de 2 boutons : oui ou non.
• La fonction FinProgramme (appelée si l’utilisateur clique sur "Oui") permet de terminer l’ap-
plication.
Testez la fenêtre en cliquant sur parmi les boutons d’accès rapide.
Leçon 3.8. Statistiques : champs
Graphe et Tableau Croisé Dynamique
• Afficher les données sous forme de graphe

• Réaliser des tableaux de synthèse grâce au Tableau Croisé Dynamique
Présentation
Dans une application de gestion, la présentation de statistiques ou de tableaux récapitulatifs est
souvent nécessaire :
• voir l’évolution des commandes dans le temps
• voir l’évolution du chiffre d’affaires
• voir l’évolution des stocks
• ...
Tout décideur demande ces informations.
Pour inclure rapidement et simplement ces informations dans vos applications, WinDev propose
de nombreux champs. Dans cette leçon, nous allons utiliser deux champs spécifiques :
• le champ Graphe.
• le champ Tableau croisé dynamique.
Corrigé

Affichage de données dans un champ Graphe

Pour manipuler le champ Graphe en conditions réelles, nous allons réaliser dans l’application
"WD Application Complète" un champ Graphe présentant l’état des ventes.
Nous allons tout d’abord réaliser une requête pour sélectionner les données à afficher dans le
champ Graphe, puis nous créerons le champ Graphe.
Sélection des données à afficher dans le champ Graphe

Pour réaliser notre graphe, nous voulons la somme des commandes effectuées par date.
Nous allons créer une requête qui effectue une somme. En effet, nous allons faire le cumul du
montant total des commandes (rubrique TotalTTC dans le fichier de données Commande).
Nous allons calculer le total de toutes les commandes par date (le Chiffre d’Affaires par date).
Créez une nouvelle requête :
2. Dans la roue qui s’affiche, cliquez sur "Requête".
3. Nous allons réaliser une requête de sélection. Sélectionnez l’option "Sélectionner (SE-
LECT)". Passez à l’écran suivant.
4. La fenêtre de description de la requête apparaît.
5. Ajoutez les rubriques Commande.Date et Commande.TotalTTC à la requête :
• Sur la gauche, déroulez le fichier "Commande".
• Double-cliquez sur la rubrique Date puis sur la rubrique TotalTTC.
• Les deux rubriques apparaissent au centre de l’écran (dans la zone "Liste des éléments de
votre requête").
Pour effectuer la somme des valeurs de "Commande.TotalTTC" :
1. Sélectionnez la rubrique "Commande.TotalTTC" au centre.
2. Dans les "Actions", sur la droite, cliquez sur "Somme".
3. Validez la description de la somme. La somme des "TotalTTC" a été ajoutée dans la liste du
résultat de la requête.
Au fur et à mesure de la création de la requête, l’éditeur de requêtes de WinDev

crée les requêtes en langage naturel (et également en SQL).
Notes
Vous pouvez ainsi vérifier que vous ne vous êtes pas trompé par rapport à l’ob-
jectif de votre requête.
Nous allons maintenant regrouper les données par année et les trier :
1. Sélectionnez la rubrique "Commande.Date" au centre.
2. Dans les "Actions", sur la droite, cliquez sur "Année, Département" et sélectionnez "Année".
3. Validez la fenêtre qui s’affiche.

4. La rubrique "Année" s’affiche au centre de la description de la requête.
5. Sélectionnez la rubrique "Année" et définissez le tri :
• Affichez le menu contextuel de la rubrique "Année".
• Sélectionnez l’option "Trier la rubrique .. Trier par ordre croissant".
• Une flèche indiquant le tri apparaît dans la description de la requête.
La requête est créée. Nous allons lui donner un nom et la sauvegarder.
1. En haut de l’écran, saisissez le nom "REQ_EvolutionsVentes".
2. Saisissez le libellé "Somme des commandes par date".
3. Validez.
4. La représentation graphique de la requête est la suivante :
5. Cliquez sur pour sauvegarder la requête. Il ne reste plus qu’à tester la requête.
6. Cliquez sur pour tester la requête.
Création du champ Graphe

Nous allons intégrer le champ Graphe dans un nouvel onglet de la fenêtre FEN_Menu.
Pour créer un nouvel onglet dans la fenêtre "FEN_Menu" :
2. Double-cliquez sur le champ Onglet : la fenêtre de description du champ s’affiche.
3. Dans l’onglet "Général", sélectionnez le volet d’onglet "Recherche de commandes" et cli-
quez sur le bouton "Nouveau". Un nouveau volet apparaît.
4. Sélectionnez le nouveau volet (nommé "Volet 4").
5. Dans la partie basse de l’écran, sélectionnez le volet "Général (volet)" et saisissez le libellé
du volet d’onglet : "Graphe".
6. Dans la partie basse de l’écran, sélectionnez le volet "Détails (volet)" et sélectionnez une
image dans le catalogue d’image :
• Cliquez sur le bouton "Catalogue".
• Dans la zone de recherche, saisissez "Graphe".
• Sélectionnez le thème "Flat Soft" et validez.
• Sélectionnez la seconde icône proposée et validez les différents écrans.
8. Le nouvel onglet apparaît dans la fenêtre.
Pour créer le champ Graphe :
1. Dans la fenêtre "FEN_Menu", sélectionnez l’onglet "Graphe" si nécessaire.
2. Sous le volet "Création", dans le groupe "Champs graphiques", cliquez sur "Graphe". Le
champ apparaît sous le curseur de la souris.
3. Cliquez dans l’onglet "Graphe". L’assistant de création d’un champ Graphe se lance.
4. Dans l’assistant, sélectionnez un graphe de type "Histogramme". Passez à l’écran suivant
de l’assistant.
5. Saisissez les paramètres du graphe :
• le titre du graphe : "Evolution des ventes".
• la légende : le graphe est sans légende.
• les étiquettes doivent être affichées.

6. Saisissez les paramètres des axes :
• Titre de l’axe des X : Année
• Titre de l’axe des Y : CA
Conservez les options par défaut et passez à l’écran suivant.
7. Nous allons maintenant définir la source des données.
• Pour les étiquettes (valeurs affichées en bas du graphe, dans notre exemple, ce sont les
années) :
• la source correspond à : "Parcours d’un fichier ou d’une requête",
• les données correspondent à la rubrique Année dans la requête REQ_EvolutionsVentes.
• Pour les séries (valeurs affichées dans le champ Graphe) : le champ graphe va afficher une
seule série correspondant au total TTC calculé par la requête REQ_EvolutionsVentes.
• Double-cliquez dans le tableau "Source des séries".
• Saisissez le libellé "Série 1".
• la source correspond à : Parcours d’un fichier ou d’une requête,
• les données correspondent à la rubrique "La_somme_TotalTTC" dans la requête REQ_Evolu-
tionsVentes.

8. Nous n’allons pas associer d’image de fond au champ Graphe. Passez à l’écran suivant.
9. Donnez un nom au champ Graphe : "GRF_EvolutionsVentes" et validez l’assistant.
10. Le champ Graphe est automatiquement créé sous l’éditeur.
11. Agrandissez le champ Graphe pour occuper tout le volet.
12. Cliquez sur pour sauvegarder la fenêtre puis sur pour tester la fenêtre.
13. Cliquez sur l’onglet "Graphe" pour visualiser le graphe.
Fonctionnalités automatiques du champ Graphe (FAA)

Comme le champ Table, le champ Graphe propose plusieurs fonctionnalités au-
tomatiques accessibles via son menu contextuel.
Notes
Il est possible par exemple :

• de changer le type du graphe,
• d’enregistrer le graphe,
• d’imprimer le graphe, ...
14. Terminez le test et revenez sous l’éditeur.
Pour maîtriser l’utilisation d’un champ Graphe, n’hésitez pas à étudier les
Exemple exemples fournis avec WinDev :
• Exemple unitaire : Champ Graphe
• Exemple didactique : WD Graphe
Ces exemples sont disponibles dans le volet "Assistants, Exemples et Compo-
sants".
Création de tableaux de synthèse grâce au champ Tableau

Croisé Dynamique
Pour manipuler le champ Tableau croisé dynamique en conditions réelles, nous allons réaliser un
champ Tableau croisé dynamique permettant de visualiser les ventes de produits par pays et par
an en quantité et en chiffre d’affaires.
Comme pour le champ Graphe, nous allons créer le champ Tableau croisé dynamique dans un
nouvel onglet de la fenêtre FEN_Menu.
Pour créer un nouvel onglet dans la fenêtre "FEN_Menu" :
2. Double-cliquez sur le champ Onglet : la fenêtre de description du champ s’affiche.
3. Dans l’onglet "Général", sélectionnez le volet d’onglet "Graphe" et cliquez sur le bouton
"Nouveau". Un nouveau volet apparaît.
4. Sélectionnez le nouveau volet (nommé "Volet 5").
5. Dans la partie basse de l’écran, sélectionnez le volet "Général (volet)" et saisissez le libellé
du volet d’onglet : "Tableau croisé dynamique".
6. Dans la partie basse de l’écran, sélectionnez le volet "Détails (volet)" et sélectionnez une
image dans le catalogue d’images :
• Cliquez sur le bouton "Catalogue".
• Dans la zone de recherche saisissez "Tableau".
• Sélectionnez le thème "Flat Soft" et validez.
• Sélectionnez la seconde icône proposée et validez les différents écrans.
8. Le nouvel onglet apparaît dans la fenêtre.
Création du champ Tableau Croisé Dynamique
Pour créer un champ Tableau croisé dynamique :

1. Dans la fenêtre "FEN_Menu", sélectionnez l’onglet "Tableau croisé dynamique" si nécessaire.
"Tableau croisé dynamique (TCD)". Le champ apparaît sous le curseur de la souris.
3. Cliquez dans l’onglet "Tableau croisé dynamique". L’assistant de création d’un champ Ta-
bleau croisé dynamique se lance.
5. Dans les cellules, nous voulons afficher deux informations :
• le total des ventes
• la quantité vendue
Dans l’assistant, nous allons tout d’abord sélectionner le fichier source : LigneCommande.
Pour la première information, sélectionnez :
• Afficher : "La somme de"
• Source : "TotalTTC"
Cliquez sur le bouton "Ajouter une valeur supplémentaire".
Pour la seconde information, sélectionnez :
• Afficher : "La somme de"
• Source : "Quantité"
6. Dans les en-têtes des colonnes, nous voulons afficher les années. Dans la partie gauche,
déroulez le fichier Commande et double-cliquez sur la rubrique Date.

7. L’assistant propose une liaison pour atteindre le fichier Commande et propose d’afficher en
en-tête trois niveaux d’informations : les années, les trimestres et les mois.
8. Validez et passez à l’écran suivant.
9. Dans les en-têtes des lignes, nous voulons afficher les produits regroupés par pays. Dans
la partie gauche :
• déroulez le fichier Client et double-cliquez sur la rubrique Pays.
• déroulez le fichier Produit et double-cliquez sur la rubrique Libellé.

10. L’assistant propose une liaison pour chaque en-tête de ligne (Client.Pays et Produit.Li-
bellé). Validez chaque liaison et passez à l’écran suivant.
11. Donnez un nom au champ Tableau Croisé Dynamique : TCD_Ventes.
12. Le champ Tableau Croisé Dynamique est automatiquement créé dans la fenêtre, ainsi
qu’un bouton "Calculer". Ce bouton va permettre à l’utilisateur de lancer le calcul des don-
nées à afficher dans le Tableau croisé dynamique. Ce bouton peut être placé à n’importe quel
endroit dans la fenêtre.
13. Adaptez la taille du champ Tableau Croisé dynamique pour qu’il occupe tout l’onglet.
14. Enregistrez la fenêtre ( parmi les boutons d’accès rapide).
Test du Tableau Croisé dynamique
Testez la fenêtre ( parmi les boutons d’accès rapide). Cliquez sur l’onglet "Tableau croisé
dynamique" puis sur le bouton "Calculer".
ATTENTION : Selon la taille de la base de données et le nombre d’en-têtes de

Notes
lignes et de colonnes, les temps de calcul peuvent être plus ou moins longs.
Vous pouvez sauvegarder le résultat du tableau croisé dynamique pour éviter le
recalcul à chaque interrogation.
Cliquez sur les "+" pour dérouler les différentes colonnes et lignes.
Arrêtez le test. Nous allons faire une petite amélioration dans ce tableau croisé dynamique.
En effet, rien n’indique qu’un des chiffres dans les cellules correspond à une quantité. Nous
allons utiliser un masque d’affichage spécifique pour cette valeur.
Pour mettre un masque d’affichage dans une cellule :
1. Affichez la description du champ Tableau croisé dynamique (double-clic sur le champ).
2. Dans l’onglet "Contenu", cliquez sur "VAL_SansNom2". La description des valeurs affichées
dans les cellules apparaît.
3. Dans la zone "Masque", ajoutez le préfixe "Qt : ".

5. Relancez le test de la fenêtre.
Leçon 3.9. Envoyer un email
• Comment envoyer un email depuis une application WinDev

• Comment intégrer un superchamp à une fenêtre
• Comment définir l’ordre de navigation sur une fenêtre
• Comment ouvrir une fenêtre non modale
Présentation
Le WLangage possède toutes les fonctions de programmation nécessaires pour gérer la récep-
tion ou l’envoi de messages Internet (appelés "emails"). De plus, grâce à WinDev, vous pourrez
connaître toutes les caractéristiques d’un email :
• expéditeur, destinataires
• date d’envoi, sujet, message
• pièces jointes ...
WinDev permet de gérer les emails grâce à plusieurs méthodes :
• Les protocoles POP3/SMTP (méthode la plus courante). Ces protocoles sont des protocoles
de gestion des emails reconnus par tous les fournisseurs de service. Ces protocoles vous
permettent de dialoguer directement avec le serveur, disponible chez votre fournisseur d’ac-
cès.
• L’API "Simple Mail API" (appelé aussi SMAPI ou Simple MAPI) : ce mode de gestion des em-
ails est utilisé par la plupart des applications Microsoft et principalement Microsoft Ex-
change.
• Le logiciel de messagerie Lotus Notes ou Outlook : grâce à ces logiciels, il est possible
d’envoyer et de recevoir des emails.
• Le protocole IMAP : ce protocole de réception d’emails permet de laisser les emails sur le
serveur dans le but de pouvoir les consulter de différents clients de messagerie ou webmail.
Dans cette leçon, nous allons créer une fenêtre permettant à l’utilisateur d’envoyer un email de-
puis l’application "WD Application Complète". Cette fenêtre est la suivante :
Pour cela, nous allons utiliser les protocoles POP3/SMTP. En effet, c’est le mode qui est actuelle-
ment le plus utilisé dans le monde.
Pour plus de détails sur les autres méthodes, consultez l’aide en ligne.
Corrigé

Exemple
Pour plus de détails sur la gestion des emails, consultez l’exemple "WD Mail"
(exemple complet), livré en standard avec WinDev. Cet exemple est accessible
depuis le volet "Assistants, Exemples et Composants" de WinDev.
Une fenêtre pour envoyer des emails

La fenêtre que nous allons créer va contenir tous les champs permettant à l’utilisateur de saisir
les différents éléments de l’email. Un bouton "Envoyer" regroupera tous les traitements permet-
tant d’envoyer l’email.
Créez une nouvelle fenêtre :

• Dans l’onglet "Basée sur un modèle", sélectionnez "Utiliser : FENMOD_Modèle" et validez
l’assistant.
3. Enregistrez la fenêtre ( ou CTRL S). Cette fenêtre a pour titre "Envoi d’un email", son
nom "FEN_Envoi_d_un_email" est automatiquement proposé. Validez les informations propo-
sées.
Création des champs de paramétrage de l’envoi

Nous allons dans un premier temps créer tous les champs permettant de paramétrer le serveur
SMTP utilisé pour l’envoi des messages. Quatre champs de saisie sont nécessaires :
• Serveur SMTP
• Port du serveur SMTP
• Nom de l’utilisateur
• Mot de passe de l’utilisateur.
Pour créer le champ de saisie correspondant au nom du serveur SMTP :
2. La forme du champ apparaît sous le curseur de la souris.
3. Cliquez en haut à gauche de la fenêtre : le champ de saisie est automatiquement créé.
4. Sélectionnez le champ et utilisez la touche [ENTREE] du clavier. Le libellé passe en édition.
Saisissez "Serveur SMTP" et validez.
Pour créer le champ de saisie correspondant au port :
1. Sous le volet "Création", dans le groupe "Champs usuels", déroulez "Saisie".
2. Sélectionnez un champ de saisie pré-défini de type Entier.
4. Cliquez sous le champ "Serveur SMTP" : le champ de saisie est automatiquement créé.
Saisissez "Port" et validez.
Pour créer le champ de saisie correspondant au nom de l’utilisateur :
3. Cliquez sous le champ "Port" : le champ de saisie est automatiquement créé.
Saisissez "Utilisateur" et validez.
Pour créer le champ de saisie correspondant au mot de passe de l’utilisateur :
2. Sélectionnez un champ de saisie pré-défini "Mot de passe".
4. Cliquez sous le champ "Utilisateur" : le champ de saisie est automatiquement créé.
Le champ de saisie "Mot de passe" apparaît sous l’éditeur avec une puce et un
oeil.
En exécution, lorsque l’utilisateur saisira son mot de passe, les caractères seront
Astuce
remplacés par des puces. Un clic sur l’oeil permettra de voir le mot de passe
saisi en clair : l’utilisateur pourra ainsi vérifier son mot de passe.
Si nécessaire, cette fonctionnalité peut être désactivée par programmation. Pour
plus de détails, consultez l’aide en ligne.
Alignez les champs que vous venez de créer :

1. Sélectionnez les quatre champs.
2. Sous le volet "Alignement", dans le groupe "Interne et externe", cliquez sur "Justifier (Int et
Ext)".
Création des champs permettant de saisir les caractéristiques de l’email

Pour écrire un email, l’utilisateur doit avoir à sa disposition :
• Un champ permettant de saisir l’adresse de l’expéditeur.
• Un champ permettant de saisir ou sélectionner l’adresse du destinataire.
• Un champ permettant de saisir le sujet de l’email.
• Un champ permettant de saisir le texte de l’email. L’utilisateur doit avoir la possibilité de mettre
en forme le texte de l’email.
• Un champ permettant d’ajouter des pièces jointes.
Nous allons ajouter tous ces champs en quelques clics dans notre fenêtre.
Pour créer le champ de saisie correspondant à l’adresse de l’expéditeur :

2. Sélectionnez le champ de saisie pré-défini "E-Mail".
4. Cliquez sous le champ "Mot de passe" : le champ de saisie est automatiquement créé.
Saisissez "Expéditeur" et validez.
Le champ permettant la saisie de l’adresse du destinataire va être un champ proposant les
adresses des clients présents dans la base de données mais aussi permettant à l’utilisateur
de saisir une autre adresse. Pour cela, nous allons utiliser un champ de type "Combo avec
saisie" lié au fichier de données Client.
1. Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur "Combo".
3. Cliquez sous le champ "Expéditeur" : l’assistant de création du champ Combo se lance auto-
matiquement.
4. Sélectionnez l’option "Afficher des données d’un fichier ou d’une requête existante". Passez
à l’écran suivant.
5. Sélectionnez le fichier "Client". Passez à l’écran suivant.
6. Nous voulons afficher dans le champ les adresses email des clients :
• Décochez la rubrique "IDClient".
• Cochez la rubrique "Email".
7. La rubrique de tri est la rubrique "Email". Passez à l’écran suivant.
8. La valeur de retour est également la rubrique "Email". Passez à l’écran suivant.
9. Conservez les options par défaut. Passez à l’écran suivant.
10. Dans l’écran "Paramètres supplémentaires", cochez l’option "Autoriser la saisie". En effet,
l’utilisateur doit pouvoir saisir une nouvelle adresse email. Passez à l’écran suivant.
11. Modifiez le nom et le libellé du champ Combo :
• Le nom du champ est "COMBO_Destinataire".
• Le libellé du champ devient "Destinataire".
12. Validez l’assistant. Le champ est automatiquement créé dans la fenêtre.
Pour créer le champ de saisie correspondant au sujet de l’email :
3. Cliquez sous le champ "Destinataire" : le champ de saisie est automatiquement créé.
Saisissez "Sujet" et validez.
Pour le corps du message, nous allons utiliser un champ de saisie HTML : l’utilisateur pourra
ainsi mettre en forme facilement le texte de l’email grâce à une barre d’outils spécifique.
2. Sélectionnez un champ de saisie pré-défini "Texte HTML".
4. Cliquez sous le champ "Sujet" : le champ de saisie est automatiquement créé.
5. Agrandissez le champ afin que plusieurs lignes soient visibles.
6. Affichez la fenêtre de description du champ (double-cliquez sur le champ).
• Sous l’onglet "Général", modifiez le mode d’affichage de la barre d’outils du formatage.
Cette barre d’outil doit être toujours visible.
• Validez la fenêtre de description du champ.
7. Si nécessaire, repositionnez le champ pour que la barre d’outils soit correctement affichée.
Pour que l’utilisateur puisse ajouter une pièce jointe, nous allons lui proposer un sélecteur de
fichiers. Mais au lieu de le créer de toutes pièces, nous allons utiliser le superchamp
correspondant livré en standard avec WinDev.
Comme le modèle de champs, le superchamp est une des solutions disponible

dans WinDev pour réutiliser un ensemble de champs.
Le superchamp est un type de champ avancé. Un superchamp regroupe un
Note
ensemble de champs dans un but spécifique (par exemple sélecteur de dates,

sélecteur de fichiers, ...). Le superchamp contient :
• les champs nécessaires,
• le code nécessaire à son fonctionnement.
1. Affichez si nécessaire le volet "Assistants, Exemples et Composants" : sous le volet "Accueil"

du menu, dans le groupe "Environnement", déroulez "Volets" et sélectionnez "Assistants,
Exemples et Composants".
2. Cliquez sur le bouton "Champs" puis sur "Superchamps". La liste des superchamps dispo-
nibles par défaut s’affiche.
3. Sélectionnez le superchamp "Sélecteur de fichiers" et réalisez un "Drag and Drop" du volet

vers la fenêtre "FEN_Envoi_d_un_email" : lâchez le champ en dessous du champ "Texte
HTML". Le sélecteur de fichiers est immédiatement créé. Ce champ est composé d’un champ
de saisie et d’un bouton permettant de sélectionner le fichier.
Alignez les différents champs présents dans la fenêtre.
Nous allons maintenant créer le bouton permettant d’envoyer les emails.
Envoi de l’email
Pour créer le bouton d’envoi :

2. Cliquez à l’emplacement de création du bouton (par exemple en bas de la fenêtre).
3. Sélectionnez le bouton et modifiez son libellé (par exemple en utilisant la touche ENTREE).
Le nouveau libellé est "Envoyer".
4. Editez le code de ce bouton : dans le menu contextuel du bouton (clic droit), sélectionnez
l’option "Code".
5. Saisissez les différents codes suivants dans le traitement "Clic sur" :
• le code de connexion et d’ouverture de la session SMTP :
MaSession est un EmailSessionSMTP
MaSession.Nom = SAI_Utilisateur
MaSession.MotDePasse = SAI_Mot_de_passe
MaSession.AdresseServeur = SAI_Serveur_SMTP
MaSession.Port = SAI_Port
// Ouvre la session SMTP

SI PAS EmailOuvreSession(MaSession) ALORS
Erreur("Impossible de se connecter au serveur SMTP.", ...
ErreurInfo())
RETOUR
FIN
Ce code utilise une variable avancée de type EmailSessionSMTP. Les différentes propriétés
de cette variable permettent de définir les caractéristiques de la session SMTP. La fonction
EmailOuvreSession utilisée avec cette variable permet ensuite d’ouvrir la session.
• le code de préparation de l’email :
MonMessage est un Email
// Vide la variable Email

EmailRAZ(MonMessage)
MonMessage..Expediteur = SAI_Expéditeur
MonMessage..Sujet = SAI_Sujet
MonMessage..HTML = SAI_Texte_HTML
MonMessage..Message = HTMLVersTexte(SAI_Texte_HTML)
// Ajoute un destinataire
Ajoute(MonMessage..Destinataire, ...
COMBO_Destinataire..ValeurAffichée)
// Ajoute la pièce jointe si besoin

SI SC_SelecteurFichier <> "" ALORS
EmailChargeFichierAttaché(MonMessage, SC_SelecteurFichier)
FIN
Ce code utilise une variable de type Email. Les différentes propriétés de cette variable
permettent de définir les caractéristiques de l’email à envoyer. Ce code associe donc le
contenu des différents champs de la fenêtre aux propriétés de la variable de type Email.
• le code d’envoi de l’email :
// Envoie l’email
SI EmailEnvoieMessage(MaSession, MonMessage) = Faux ALORS
Erreur("Message non envoyé.", ErreurInfo())
SINON
// Message envoyé
ToastAffiche("Message envoyé", toastCourt, ...
cvMilieu, chCentre)
FIN
L’envoi de l’email est simplement réalisé avec la fonction EmailEnvoieMessage. Il suffit de lui
passer en paramètre la variable contenant les caractéristiques de la session SMTP et la
variable contenant les caractéristiques de l’email à envoyer.
Si l’email est envoyé, un message de type Toast indiquant que l’email a été envoyé est
affiché. Un message Toast correspond à un message furtif.
• le code de fermeture de la session SMTP :
// Ferme la session SMTP
EmailFermeSession(MaSession)
Ce code ferme la session grâce à la fonction EmailFermeSession.

Enregistrez la fenêtre et son code ( ou CTRL S).
Améliorations de la fenêtre
Nous allons apporter quelques améliorations à notre fenêtre :
• Ajouter un bouton de fermeture
• Remettre en forme la fenêtre grâce à la gestion des ancrages et l’ordre de navigation.
• Lancer la fenêtre depuis la fenêtre "FEN_Menu".
Fermeture de la fenêtre
Pour ajouter un bouton permettant de fermer la fenêtre :

1. Sous le volet "Création", dans le groupe "Champs usuels", déroulez "Bouton" : la liste des bou-
tons pré-définis s’affiche.
2. Cliquez sur le bouton "Fermer".
3. Cliquez dans la fenêtre à la position où le bouton doit être créé (par exemple, en bas, à
droite du bouton Envoyer).
Mise en forme
Pour définir les ancrages :

• Sélectionnez les champs "Expéditeur", "Destinataire" et "Sujet" : ces champs doivent être
ancrés en largeur.
• Sélectionnez le champ "Texte HTML" : ce champ doit être ancré en largeur et en hauteur.
• Sélectionnez les boutons : ces champs doivent être ancrés à droite et en bas.
• Sélectionnez le superchamp de sélection de fichier : ce champ doit être ancré en largeur et
en bas.
Pour définir l’ordre de navigation :
L’ordre de navigation des champs est l’ordre dans lequel l’utilisateur pourra sai-
sir les valeurs dans les différents champs de la fenêtre. Le passage d’un champ
à un autre sera effectué lors de l’appui sur la touche [TAB] pendant l’exécution.
L’ordre de saisie par défaut correspond à l’ordre de création des champs. Il peut
Note
être modifié :
• soit en donnant un ordre de saisie automatique : le premier champ en sai-
sie sera le champ situé le plus en haut à gauche, le deuxième sera celui
qui est immédiatement situé à droite ou immédiatement en dessous ...
• soit en spécifiant un ordre de saisie par sélection.
1. Affichez l’ordre de navigation grâce à la touche F5.

2. Définissez l’ordre de navigation automatique : sous le volet "Fenêtre", dans le groupe
"Ordre", déroulez "Navigation" et sélectionnez "Définir en automatique".
3. Les numéros sont modifiés et apparaissent désormais dans l’ordre.
4. Appuyez à nouveau sur la touche F5 pour faire disparaître les numéros.
Ouverture non modale de la fenêtre

La fenêtre de gestion des emails va être ouverte directement depuis la fenêtre "FEN_Menu". Son
mode d’ouverture va être spécifique car cette fenêtre ne doit pas bloquer la consultation des dif-
férentes informations affichées dans la fenêtre "FEN_Menu".
Pour ouvrir la fenêtre "FEN_Envoi_d_un_email" depuis la fenêtre "FEN_Menu" :
1. Affichez la fenêtre "FEN_Menu" sous l’éditeur (double-cliquez sur son nom dans le volet "Ex-
plorateur" par exemple).
2. Sous l’éditeur, déroulez l’option "Menu" et sélectionnez l’option "Quitter".
3. Affichez le menu contextuel de l’option "Quitter" (clic droit) et sélectionnez "Ajouter avant".
4. Saisissez le libellé de l’option "Envoyer un email" et validez.
5. Sélectionnez à nouveau l’option "Quitter".
6. Affichez le menu contextuel de l’option "Quitter" (clic droit) et sélectionnez "Insérer un sépa-
rateur".
7. Affichez le menu contextuel de l’option "Envoyer un email" (clic droit) et sélectionnez "Code".
// Ouvre la fenêtre d’envoi d’email
OuvreFille(FEN_Envoi_d_un_email)
Dans ce code, la fonction OuvreFille permet de réaliser une ouverture "non modale" de la
fenêtre : l’utilisateur pourra à la fois écrire un email et consulter les informations de la
fenêtre principale.
Enregistrez la fenêtre et son code ( ou CTRL S).
Lancez le test du projet ( parmi les boutons d’accès rapide) et ouvrez la fenêtre d’envoi
d’emails.
Leçon 3.10. Identifier l’utilisateur : le
groupware utilisateur
• Qu’est-ce le groupware utilisateur ?

• Intégrer le groupware utilisateur
• Configurer le groupware utilisateur
• Tester le groupware utilisateur
Présentation
Une application peut être utilisée par différents intervenants, ayant tous des profils différents. Il
est souvent nécessaire de prévoir des niveaux d’accès selon les fonctions de l’utilisateur.
Prenons un exemple simple : lors de la mise en place d’une gestion commerciale, l’application
propose les fonctionnalités suivantes :
• Consultation du tarif
• Modification du tarif
• Saisie des commandes
• Saisie des clients.
Selon l’utilisateur, les accès possibles sont différents. Quelques exemples :
• les secrétaires peuvent consulter le tarif et créer des commandes
• les commerciaux peuvent consulter le tarif et établir les commandes, gérer de nouveaux clients.
• les directeurs commerciaux ont accès à toutes les options.
WinDev permet de gérer ces différents niveaux d’accès en quelques clics dans vos applications
grâce au groupware utilisateur.
Nous allons intégrer le groupware utilisateur dans notre application "WD Application Complète" et
le configurer.
Corrigé
complète (Corrigé)".
Intégrer le groupware utilisateur
Pour intégrer le groupware utilisateur dans le projet "WD Application Complète" :

1. Sous le volet "Projet", dans le groupe "Projet", cliquez sur "Groupware Utilisateur". La fenêtre
de paramétrage du groupware utilisateur s’affiche.
2. Dans l’onglet "Intégration", deux modes d’intégration sont disponibles :
• Groupware utilisateur automatique : tous les éléments du groupware utilisateur sont inté-
grés directement dans votre application. Vous profitez ainsi automatiquement de toutes les
évolutions du groupware. De plus, il est possible d’appliquer le gabarit du projet aux fe-
nêtres de groupware.
• Groupware utilisateur personnalisée : tous les éléments du groupware sont intégrés dans
votre application via un composant interne. Il est possible de personnaliser les différents
éléments du groupware utilisateur. Cependant, les évolutions ne seront pas prises en
compte.
3. Sélectionnez l’option "Groupware utilisateur automatique".
4. Sélectionnez l’onglet "Exécution". Deux modes de démarrage sont disponibles :
• Lancement automatique : le groupware est lancé dès le démarrage de l’application.
• Lancement manuel : le groupware sera lancé par programmation.
5. Conservez l’option "Lancement automatique".

6. Sélectionnez l’onglet "Fichiers". Cet onglet permet de définir le format et l’emplacement des
fichiers de données du groupware utilisateur. Dans notre cas, nous utiliserons des fichiers de
données HFSQL Classic, dans l’emplacement spécifié par défaut.
Si vous utilisez (ou si l’utilisateur final utilise) Windows Vista (ou un système
Note
d’exploitation plus récent), il est conseillé d’utiliser le répertoire des données.
7. Dans l’onglet "Fichiers", sélectionnez l’option "Activer l’historique des connexions". Cette
option permet au superviseur de savoir qui s’est connecté, quand et à quelle heure.
8. Sélectionnez l’onglet "Options". Cet onglet permet de définir le mode d’identification de
l’utilisateur :
• gestion par le groupware utilisateur.
• utilisation d’un annuaire LDAP. Dans ce cas, lors de l’installation de l’application, l’utilisa-
teur pourra saisir les paramètres de son annuaire LDAP.
• utilisation de l’authentification Windows.
9. Validez. Un message apparaît indiquant que par défaut, un utilisateur Superviseur est créé.
Par défaut, un seul utilisateur existe, le superviseur. Au premier lancement de
l’application, connectez-vous en utilisant le nom : "superviseur". Vous pourrez
alors définir le mot de passe utilisé par le superviseur.
Note
10. Validez ce message. Le groupware utilisateur est intégré dans l’application.
Nous allons tout de suite tester notre application :

1. Lancez le test du projet ( parmi les boutons d’accès rapide). Une fenêtre de login appa-
raît.
2. Connectez-vous en tant que superviseur.
3. Définissez le mot de passe et donnez sa confirmation. Validez.
4. Un nouveau menu apparaît, permettant soit de tester l’application, soit de configurer l’ap-
plication.
5. Choisissez l’option "Configurer le groupware".
Configurer le groupware utilisateur
La configuration du groupware utilisateur consiste à définir les différents utilisateurs de l’applica-
tion et leurs droits sur les différentes fenêtres et champs de l’application.
La configuration des utilisateurs peut être réalisée :

• lors du développement de l’application. Les fichiers de données nécessaires
Note
(des utilisateurs et de leurs droits) pourront être installés avec l’application.

• lorsque l’application est installée, par l’administrateur de l’application.
Création des utilisateurs et des groupes
Pour configurer le groupware utilisateur, nous allons tout d’abord créer un utilisateur "Test_1"
et l’associer au groupe "Tests". Nous allons ensuite configurer la gestion des droits du
groupe.
Pour créer un utilisateur :

1. Cliquez sur le bouton "Nouveau" en dessous de la zone "Utilisateurs". L’écran de saisie d’un
nouvel utilisateur apparaît.
2. Saisissez les informations suivantes :
• Login : Test_1
• Nom : Test_1
• Mot de passe : Test_1
Par défaut, le mot de passe apparaît masqué lors de la saisie. Pour véri-
Note
fier le mot de passe saisi, cliquez sur l’icône en forme d’oeil : le mot de
passe apparaît en clair tant que le bouton de la souris reste enfoncé.
3. Cliquez sur le bouton "Enregistrer". L’utilisateur "Test_1" apparaît dans la liste des utilisa-
teurs définis pour le groupware utilisateur.
Pour créer un nouveau groupe d’utilisateurs :
1. Cliquez sur le bouton "Nouveau" en dessous de la zone "Groupes". L’écran de saisie d’un
nouveau groupe apparaît.
2. Saisissez le nom du groupe "Tests".
3. Cliquez sur le bouton "Enregistrer". Le groupe "Tests" apparaît dans la liste des groupes défi-
nis pour le groupware utilisateur.
Pour associer l’utilisateur au groupe :
1. Sélectionnez l’utilisateur "Test_1" dans la fenêtre.
2. Réalisez un "Glisser - Déposer" (Drag and Drop) de l’utilisateur "Test_1" vers le groupe
"Tests".
3. L’association est réalisée.
Définition des droits

Nous allons maintenant définir les droits pour le groupe d’utilisateurs "Tests". Ces droits seront
appliqués à tous les utilisateurs du groupe. Dans notre exemple, les utilisateurs du groupe "Tests"
ne pourront pas :
• Afficher la fenêtre d’envoi d’emails.
• Créer ou modifier un produit.
Pour définir les droits :
1. Cliquez sur l’option "Gestion des droits" à gauche de la fenêtre.
2. Sélectionnez le groupe "Tests".
3. Cliquez sur "Suivant".
4. La fenêtre qui s’affiche permet de sélectionner chaque fenêtre ou état de l’application.
• Pour chaque fenêtre ou état, il est possible de spécifier si l’élément sera accessible ou non
par le groupe.
• Pour chaque fenêtre, il est possible de dire si les champs de la fenêtre auront le comporte-
ment de l’application (défaut) ou seront inactifs, invisibles ou grisés.
Pour interdire l’accès à la fenêtre "FEN_Envoi_d_un_email" :
1. Sélectionnez la fenêtre dans la liste.
2. Cliquez sur le bouton "Interdire l’accès".
3. La fenêtre devient interdite.
Définissez les droits sur la fenêtre "FEN_Menu". Cette fenêtre contient une option de menu
permettant d’afficher la fenêtre de gestion des emails ainsi que les boutons "Nouveau" et
"Modifier".
1. Sélectionnez la fenêtre "FEN_Menu".
2. Cliquez sur le bouton "Suivant".
3. La fenêtre de configuration des droits sur les champs de la fenêtre apparaît.
4. Passez en "Grisé" les champs "BTN_Modifier" et "BTN_Nouveau" :
5. Passez en invisible l’option de menu "Envoyer un email" :
6. Cliquez sur le bouton "Enregistrer".

7. La fenêtre de configuration des droits s’affiche. Fermez cette fenêtre (bouton "Fermer").
8. Fermez la fenêtre de configuration.
9. L’éditeur de WinDev s’affiche.
Nous allons maintenant tester l’application en utilisant le login "Test_1".

1. Lancez le test du projet ( parmi les boutons d’accès rapide). Une fenêtre de login appa-
raît.
2. Connectez-vous en tant que "Test_1" avec le mot de passe "Test_1". Validez.
3. L’application se lance. Vous pouvez observer que les boutons "Nouveau" et "Modifier" sont
grisés et que l’option de menu "Envoyer un email" est invisible.
4. Quittez l’application et revenez sous l’éditeur.
Débrancher la gestion du groupware utilisateur

Dans la suite de ce cours, nous n’utiliserons plus le groupware utilisateur. Vous pouvez directe-
ment le débrancher.
1. Sous le volet "Projet", dans le groupe "Projet", cliquez sur "Groupware Utilisateur".
2. Dans la fenêtre qui s’affiche, dans l’onglet "Intégration", sélectionnez "Pas de groupware
utilisateur".
3. Validez.
Si vous effectuez des tests automatiques dans votre application, il est néces-
saire de configurer le groupware utilisateur pour ne pas utiliser la fenêtre de
Note
login. Il suffit de renseigner l’option "Login automatique en mode test" dans l’on-
glet "Exécution" de la fenêtre de paramétrage du groupware.
Leçon 3.11. Réutilisez du code grâce
aux composants externes
• Qu’est-ce qu’un composant externe ?

• Etape par étape, la création d’un composant externe.
• Diffusion d’un composant externe.
Présentation
Un composant externe WinDev est

une brique applicative qui peut
être réutilisée dans un nombre
illimité de projets (et donc d’exécu-
tables).
Un composant externe permet
d’avoir un traitement identique
avec un code source unique pour
réaliser une opération donnée
même si ce traitement doit être
réalisé par plusieurs projets.
Les projets qui utilisent un compo-
sant externe ont accès sous l’édi-
teur WinDev au nom des objets, procédures ou méthodes rendues visibles par le concepteur du
composant. Les projets ne peuvent pas voir ou modifier le code source. La confidentialité et la
stabilité du code sont garanties.
La réalisation d’un composant externe est très simple.
Comment faut-il faire ? Faites comme d’habitude, créez vos fenêtres, procédures, classes. Puis
lorsque vous aurez terminé, au lieu de choisir l’option de création de l’exécutable, prenez l’option
de création d’un composant, c’est tout !
Un composant peut contenir du code, des fenêtres, une analyse, des fichiers de données, etc. !
Pour partager du "code", il y a cinq méthodes principales avec WinDev :

1. Les collections de procédures
Notes
2. Les classes
3. Les superchamps (à travers l’utilisation d’un dictionnaire)
4. Les composants externes
5. Les composants internes
Voici plusieurs cas dans lesquels les composants externes peuvent être intéressants.
Travail en équipe
Un développeur crée et maintient un composant externe qu’il met à la disposition des autres
développeurs. Il ne risque pas d’y avoir des modifications faites "par erreur" !
Les projets volumineux

Les composants externes permettent d’avoir plusieurs projets distincts de tailles réduites et
d’avoir un projet central dans lequel les éléments des autres projets sont visibles. L’utilisabilité
des composants externes est bien meilleure que les bibliothèques (fichiers WDL).
Les bases de données accédées par plusieurs projets
Lorsqu’une même base de données est accédée par plusieurs projets, il est fréquent d’avoir des
incohérences dans la base de données dues à des codes sources modifiés ou trop vieux. En re-
groupant les opérations d’accès (en écriture au moins) à la base de données dans un composant
externe, cela permet d’avoir un seul code source à vérifier/maintenir et donc de limiter le risque
d’incohérences dans la base de données.
De plus, l’utilisation d’un composant évite de recompiler l’application lors d’une modification de
l’analyse.
Les traitements utilisés dans plusieurs projets

Il est fréquent d’avoir des traitements plus ou moins complexes utilisés dans plusieurs pro-
jets. Il est possible de réutiliser ces traitements par l’intermédiaire de "collections de pro-
cédures" ou de "classes". Dans ce cas il existe un risque de modifications non reportées
entre les différents projets, qui rendent ensuite ces éléments incompatibles entre eux.
L’utilisation des composants externes permet d’éviter des modifications intempestives et permet
de conserver des projets compatibles auxquels il est simple d’apporter une modification com-
mune.
De plus avec l’utilisation possible du mot-clé PRIVE, vous pourrez assurer la confidentialité de
votre code à tous les niveaux du composant externe. Lors de la réutilisation de votre composant
externe dans un autre projet WinDev, l’édition du code ne sera pas permise mais la documenta-
tion concernant l’utilisation des fonctions (par exemple des procédures) sera affichée !
La possibilité de diffuser une fonctionnalité ou un ensemble de fonctionnalités

Les composants externes permettent de réaliser une fonctionnalité ou un ensemble de fonction-
nalités. D’autres développeurs WinDev pourront intégrer ces fonctionnalités dans leurs propres
projets. Les développeurs qui utilisent un composant externe peuvent voir les éléments du com-
posant rendus visibles. Cependant, il ne sera pas possible de voir ou de modifier le code source.
Vous pouvez diffuser gratuitement ou même commercialiser des composants externes !
Composant externe multiproduits

Un composant externe peut être prévu pour fonctionner dans :
• une application WinDev,
• une application WebDev,
• une application WinDev Mobile,
• les trois types d’applications (WinDev, WebDev et WinDev Mobile).
Dans ce dernier cas, WinDev permet :
• d’intégrer les éléments provenant des différents produits (WebDev et/ou WinDev Mobile)
dans un même composant externe.
• d’indiquer pour chaque plateforme d’exécution le code WLangage correspondant (par
exemple, l’affichage d’une fenêtre se fait par la fonction Ouvre en WinDev et l’affichage
d’une page se fait par la fonction PageAffiche en WebDev).
Etape par étape
Etape 1 : Création d’un composant externe

Nous allons créer un composant externe à partir du projet "WD Application Complète". Ce projet
permet de gérer des commandes, des produits et des clients. Le composant externe que nous al-
lons créer va nous permettre de connaître dans une autre application instantanément les clients
correspondant à une ville donnée.
Lors de l’appel au composant externe, vous pourrez :
• Passer une ville en paramètre.
• Récupérer une chaîne contenant le nom du client et le montant total de ses commandes.
Pour ne pas avoir à développer le code nécessaire au fonctionnement du composant, le projet
"WD Application Complète" contient tous les éléments nécessaires.
Corrigé

puis sélectionnez "Application complète (Corrigé)"
Pour les besoins du composant, le projet contient :

• une requête "REQ_CommandesParVille". Cette requête est une requête paramétrée permet-
tant d’obtenir pour une ville donnée les clients correspondants ainsi que le montant total de
leurs commandes.
• une collection de procédures "COL_Composant". Cette collection de procédures contient :
• la procédure "DonneCommandesParVille" qui renvoie pour la ville passée en paramètre une
chaîne contenant le nom du client et le montant total de ses commandes.
• la procédure "LocalisationDonnées" qui permet de localiser les données utilisées par le
composant.
• une analyse permettant de décrire les fichiers de données stockant les informations.
Nous allons maintenant créer notre composant. Pour cela, nous devons créer une configura-
tion de projet.
Les configurations de projet permettent de créer à partir d’un même projet plu-
sieurs "cibles" différentes :
• Une application 32 bits,
• Une application 64 bits,
Notes
• Un composant,
• ...
À tout moment, vous pouvez choisir la configuration sur laquelle vous travaillez
et générer en une seule opération tous les éléments pour toutes les configura-
tions d’un projet.
Pour créer une configuration de projet de type "Composant" :
1. Sous le volet "Projet", dans le groupe "Configuration de projet", déroulez "Nouvelle configura-
tion" et sélectionnez "Composant Externe (WDK)".
2. L’assistant de création d’une configuration de projet se lance. WinDev propose de créer
une configuration de projet de type "Composant". Passez à l’écran suivant.
3. Donnez un nom à votre configuration de projet : par exemple "CompoCommandesParVille".
4. Conservez les options proposées par défaut. Passez à l’écran suivant.
5. Sélectionnez les éléments qui constituent la configuration de projet. Dans cet exemple, ce
sont également les éléments qui seront dans le composant.
• Cliquez sur le bouton "Aucun".
• Sélectionnez les éléments "REQ_CommandesParVille" et "COL_Composant".
6. Passez à l’écran suivant et validez la création de la configuration.

7. La nouvelle configuration devient automatiquement la configuration en cours.
Pour connaître et modifier la configuration en cours, utilisez le volet "Explorateur
de projet".
Notes
La configuration en gras correspond à la configuration courante.

Pour changer la configuration courante, double-cliquez sur le nom de la configu-
ration à activer.
Nous allons maintenant générer notre composant.

1. Sous le volet "Projet", dans le groupe "Génération", cliquez sur "Générer".
2. L’assistant de génération du composant se lance. Passez à l’écran suivant de l’assistant.
WinDev liste les éléments à intégrer dans le composant (éléments spécifiés dans la configu-
ration et analyse).
3. Sélectionnez tous les éléments (bouton "Tous") et passez à l’écran suivant.

4. L’assistant vous demande de sélectionner les éléments du composant qui seront acces-
sibles depuis l’application cliente.
Dans notre exemple, seule la collection de procédures "COL_Composant" sera utilisée :

6. WinDev propose d’autoriser la traduction du composant. Cette fonctionnalité est intéres-
sante si votre composant doit être utilisé par des applications multilingues.
Si l’option "Autoriser la traduction du composant" est cochée, il sera possible de traduire à

partir de l’application utilisant le composant les éléments spécifiés du composant.
Cette traduction sera réalisée à l’aide de WDMSG, module indépendant permettant d’extraire
et de réintégrer les messages à traduire d’un projet.
Dans cet exemple, ne cochez pas cette option. Passez à l’écran suivant.
7. Choisissez les langues du composant. Notre exemple contient uniquement le Français.
8. L’assistant propose ensuite de gérer les différentes versions du composant. Dans notre
exemple, le composant vient d’être créé.
Conservez les options par défaut. Passez à l’écran suivant.
9. Saisissez les différentes informations concernant le composant :
• Propriétaire,
• Libellé, Copyright, ...
11. Vous pouvez associer une image à votre composant. Les utilisateurs du composant pour-
ront l’identifier rapidement dans le volet "Catalogue d’exemples". Passez à l’écran suivant.
12. Spécifiez la présentation générale du composant. Cette présentation permettra à l’utilisa-
teur du composant de connaître sa finalité. Saisissez par exemple :
13. Passez à l’écran suivant. L’assistant va maintenant effectuer la génération automatique

de la documentation sur le composant. Cette documentation peut être basée sur les commen-
taires que vous aurez insérés dans votre code source.
14. Passez à l’écran suivant. Vous avez la possibilité de modifier la documentation générée.
Nous n’allons pas y toucher. Passez à l’écran suivant.
15. Vous avez la possibilité de créer un fichier d’aide associé à votre composant (format
CHM). Ce fichier d’aide sera livré avec le composant. Les clients pourront y accéder en faisant
F1 à partir du code du composant.
Nous n’allons pas générer de fichier d’aide. Passez à l’écran suivant.
16. Vous avez la possibilité d’autoriser les utilisateurs finaux du composant à saisir leur propre
code WLangage pour personnaliser vos traitements. Les suggestions peuvent directement
vous être envoyées. Dans cet exemple, nous n’allons pas autoriser la saisie de "Macro Code
Utilisateur". Passez à l’écran suivant.
17. Nous n’allons pas enregistrer le composant dans le GDS. Passez à l’écran suivant.
18. Il ne reste plus alors qu’à donner un nom physique à notre composant.
Validez. Voilà, votre premier composant est maintenant créé, il est prêt à l’emploi !
Le composant apparaît alors dans le volet "Assistants, Exemples et Composants" (bouton
"Composants", rubrique "Composants personnels").
Etape 2 : Utilisation du composant externe

Une fois créé, votre composant est alors utilisable dans n’importe quel autre projet WinDev. Nous
allons maintenant voir comment réutiliser ce composant.
Pour cela, nous allons créer un nouveau projet et importer notre composant dans ce projet.
1. Fermez le projet en cours : sous le volet "Accueil", dans le groupe "Général", déroulez "Fer-
mer" et sélectionnez "Fermer le projet".
2. Validez la fermeture du projet et si nécessaire validez l’enregistrement des modifications.
3. La fenêtre de bienvenue apparaît.
4. Créez un nouveau projet : cliquez sur "Créer un projet" dans la fenêtre de bienvenue.
• Ce projet est une application Windows.
• Ce projet s’appelle "CompoUtilisation" et n’a pas d’analyse.
5. Sous le volet "Projet", dans le groupe "Projet", déroulez "Importer" et sélectionnez l’option
"Un composant Externe .. À partir d’un fichier".
6. Dans le répertoire du projet "WD Application Complète", sélectionnez le sous-répertoire
"EXE\CompoCommandesParVille", puis le fichier "CompoCommandesParVille.wdi". Le projet
"WD Application Complète" est disponible dans le sous-répertoire "Autoformation\Exercices\
WD Application Complète".
7. Après avoir cliqué sur "Ouvrir", la description de notre composant s’est affichée. Cette des-
cription contient :
• Sur l’onglet "Général", les éléments saisis lors de la création du composant externe, ainsi
que son emplacement. Il est également possible de définir le mode de chargement du com-
posant.
• Sur l’onglet "Détail", la description du composant, ainsi que l’aide générée automatique-
ment. Il est ainsi possible de connaître les éléments utilisables du composant.
Il est possible d’accéder à tout moment à la description du composant. Il suf-

Notes
fit de sélectionner le composant dans l’explorateur de projet et de sélectionner

l’option "Description" du menu contextuel.
8. Validez (bouton vert). Le composant est intégré dans votre projet.
Nous allons maintenant créer une nouvelle fenêtre vierge pour utiliser le composant.
1. Créez une fenêtre vierge.
• La fenêtre a pour titre "Clients par ville".
• Le nom de la fenêtre est "FEN_Clients_par_ville".
• Validez.
3. Affichez le code associé à la fenêtre (option "Code" du menu contextuel).
4. Dans le traitement "Fin d’initialisation", nous allons appeler la fonction LocalisationDon-
nées du composant. Cette fonction attend en paramètre le chemin permettant d’accéder aux
fichiers de données manipulés par le composant. Saisissez le chemin d’accès aux données de
l’exemple "WD Application Complète".
COL_Composant.LocalisationDonnées("C:\WinDev\Autoformation\...\")
// Indiquez le chemin de VOS données

6. Dans la fenêtre, ajoutez les champs suivants :
• Un champ de saisie avec pour libellé "Ville" et pour nom "SAI_Ville".
• Un champ Table "TABLE_Résultat" composé de 2 colonnes :
- une colonne "Nom" de type Texte.
- une colonne "Total ventes" de type Numérique.
• Un bouton avec pour libellé "Rechercher" et pour nom "BTN_Rechercher".
Editez maintenant le code du bouton "BTN_Rechercher". Lors du clic sur ce bouton, nous
allons exécuter la procédure de recherche présente dans le composant. Cette procédure :
• attend en paramètre le nom de la ville
• renvoie une chaîne de la forme : Nom du client 1 + TAB + Total vente 1 + RC + Nom du client
2 + TAB + Total vente 2 + ...
Le code du bouton "BTN_Rechercher" doit donc :
• appeler la procédure DonneCommandesParVille du composant en lui passant en para-
mètre le contenu du champ SAI_Ville.
• traiter la chaîne obtenue pour l’ajouter dans la table.
Saisissez le code suivant :
sListeRésultat est une chaîne
// Récupère la liste des clients et leurs commandes

// pour la ville saisie
sListeRésultat = COL_Composant.DonneCommandesParVille(...
SAI_Ville)
// Si la liste n’est pas vide
SI sListeRésultat <> "" ALORS
// Vide la table
TableSupprimeTout(TABLE_Résultat)
// Parcourt les résultats
POUR TOUTE CHAÎNE sUnClient DE sListeRésultat SEPAREE PAR RC
// Ajoute ce client à la table
TableAjoute(TABLE_Résultat, sUnClient)
FIN
SINON // Si la liste est vide
InfoConstruit("Aucun client trouvé pour la ville ""%1""",...
SAI_Ville)
FIN
Sauvegardez votre fenêtre.
Testez la fenêtre en cliquant sur le bouton "GO" parmi les boutons d’accès rapide. Dans le
champ de saisie, saisissez "Paris" puis cliquez sur le bouton "Rechercher". La liste des clients
s’affiche.
Et c’est terminé ! Simple n’est-ce pas ?

Vous savez désormais créer un composant et le réutiliser dans vos applications. Mais vous pour-
riez également décider de gérer des procédures d’installation de vos composants, pour, par
exemple, les redistribuer séparément de vos applications.
Distribution d’un composant externe

Vous avez deux choix possibles pour distribuer un composant :
1. Fournir les fichiers nécessaires "manuellement", c’est une distribution "simple".
2. Créer une distribution plus "professionnelle", grâce à l’éditeur d’installation de WinDev,
WDInst.
Distribution simple
Vous devez dans ce cas fournir tous les fichiers nécessaires au bon fonctionnement de votre com-
posant. Ces fichiers sont créés à la génération du composant (fichiers WDI, WDK, WDO, images,
autres documents, ...). Ces fichiers seront copiés manuellement de leur répertoire d’origine vers
le répertoire de destination. Les projets WinDev qui utiliseront ce composant, iront chercher les
fichiers dépendants dans ce répertoire de destination.
Liste des fichiers à fournir pour une distribution simple :
• les fichiers générés automatiquement par WinDev (WDK, WDI, ...).
• les fichiers de dépendances.
• si le composant utilise des fichiers de dépendances, il faudra fournir le fichier WDO. Ce fi-
chier contient les références aux différents fichiers externes utilisés dans le composant.
Distribution professionnelle
La diffusion des composants à l’aide d’une procédure d’installation consiste à fournir aux utilisa-
teurs du composant WinDev, un programme d’installation. Ce programme installe tous les fichiers
nécessaires à l’utilisation du composant dans le répertoire spécifié par l’utilisateur.
Ce mode d’installation permet de gérer automatiquement :
• le fichier WDO et l’installation des fichiers supplémentaires utilisés par le composant.
• l’installation automatique d’outils nécessaires (MDAC, driver ODBC pour HFSQL, ...).
• la mise à jour automatique des fichiers de données utilisés par le composant (si néces-
saire).
• la désinstallation du composant.
Revenez sur le projet "WD Application Complète". Sélectionnez si nécessaire la configuration

de projet correspondant au composant dans l’explorateur de projet.
Pour créer l’installation, sous le volet "Projet", cliquez sur "Procédure d’installation".
L’assistant de création d’installation du composant se lance.
Nous ne détaillerons pas les différents modes d’installation d’un composant. Suivez les instruc-
tions de l’assistant. Si vous souhaitez obtenir plus de détails concernant l’installation de compo-
sants, consultez l’aide en ligne (mot-clé : "Composant Externe, Distribuer un composant").
Leçon 3.12. Consommer un Webservice
• Présentation
• Importation et consommation d’un Webservice
Présentation
Un service Web est généralement défini comme une application accessible via des protocoles
Internet standard. Les services Web permettent notamment l’interactivité entre plusieurs ordina-
teurs connectés sur le réseau Internet.
Via les services Web, il est possible de faire exécuter des procédures et des traitements sur un
serveur Web (.NET ou J2EE) à distance depuis un poste client.
Avec WinDev, ces services Web sont utilisables en tant que client, via le protocole SOAP sur HTTP
(le protocole standard d’Internet pour le transfert des pages HTML), grâce aux fonctions SOAPxx,
DotNetxx et J2EExx.
Quelle que soit la plate-forme du serveur Web (.NET, J2EE, ...), un service Web est accessible via
l’utilisation de SOAP.
Notes
Avec WinDev, il n’est pas nécessaire de maîtriser ces informations. Un assistant

se charge de ("presque") tout !
Exemple pratique
Pour tester et manipuler un Webservice, nous mettons à votre disposition un Webservice spéci-
fique pour le Cours d’auto-formation.
Intégré au projet "WD Application Complète", ce Webservice permet d’interroger une base fournis-
seur pour vérifier la disponibilité (stock) d’un produit à partir de sa référence.
Nous allons dans un premier temps, importer le Webservice dans le projet "WD Application Com-
plète", puis l’utiliser dans l’application pour vérifier à partir d’une fiche Produit, la disponibilité du
produit affiché.
Importation d’un Webservice
Fermez si nécessaire le projet en cours. La fenêtre de bienvenue apparaît.

Dans la fenêtre de bienvenue, cliquez sur "Cours d’auto-formation" et sélectionnez le projet
"Application complète (Exercice)". Le projet se charge.
"Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez l’option "Application
complète (Exercice)".
Corrigé

Pour importer un Webservice dans le projet :
1. Sous le volet "Projet", dans le groupe "Projet", déroulez "Importer" et sélectionnez "Un Web-
service (Soap, .NET, J2EE)".
2. L’assistant d’importation se lance. Passez à l’écran suivant.
3. Indiquez l’adresse à laquelle la description WSDL du Webservice doit être importée : http://
exemples.webdev.info/WSAUTOFORMATION_WEB/awws/WSAutoformation.awws?wsdl
Rappel : Ce Webservice permet d’interroger une base fournisseur pour vérifier la disponibilité
(stock) d’un produit à partir de sa référence.
4. Passez à l’écran suivant. L’importation du Webservice est réalisée.
5. Validez la fenêtre d’information. Le Webservice importé est présent dans le dossier "Web-
services" de l’explorateur de projet.
Arrêtons-nous un instant sur les informations affichées dans l’explorateur de projet :
La structure est constituée de :

• le nom du Webservice (WSAutoformation dans cet exemple),
• le nom de chaque fonction (ProduitEnStock dans cet exemple),
• le nom d’une structure contenant soit les paramètres d’appel (ProduitEnStock dans cet
exemple), soit les valeurs de retour (ProduitEnStockResponse dans cet exemple),
• le nom de chaque variable de la structure (sRéférenceProduit dans cet exemple).
Dans notre exemple, le Webservice importé se nomme : WSAutoformation. Il contient 1 fonction

ProduitEnStock.
La fonction ProduitEnStock contient 2 structures :
• ProduitEnStock
• ProduitEnStockResponse
La structure ProduitEnStock contient une variable sRéférenceProduit correspondant à la valeur à

passer en paramètre pour l’appel de la fonction ProduitEnStock.
La structure ProduitEnStockResponse contient une variable (ProduitEnStockResult) correspon-

dant à la valeur de retour de la fonction.
Consommation d’un Webservice
Dans notre exemple "WD Application Complète", nous allons intégrer l’appel au Webservice dans
l’onglet permettant de voir la liste des produits. Un bouton "En stock ?" permettra de vérifier la
disponibilité le produit affiché via le Webservice.
Pour utiliser le Webservice :
1. Ouvrez sous l’éditeur la fenêtre "FEN_Menu" (double-cliquez sur son nom dans l’explorateur
de projet par exemple).
2. Dans le volet "Liste des produits", ajoutez un bouton :
• Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur .
• Cliquez dans la fenêtre sous le bouton "Modifier".
• Le bouton est automatiquement créé.
3. Modifiez les caractéristiques du bouton (option "Description" du menu contextuel). Ce
champ a pour nom "BTN_EnStock" et pour libellé "En stock ?".
4. Affichez les traitements associés au bouton (option "Code" du menu contextuel).

5. Dans le traitement "Clic sur BTN_EnStock", saisissez le code suivant :
// Variable qui contient les paramètres d’interrogation
// de la fonction ProduitEnStock du Webservice
MaRequete est un ProduitEnStock
// Variable qui récupère le résultat
// de la fonction ProduitEnStock
MaReponse est un ProduitEnStockResponse
// Définit le paramètre : la référence du produit

MaRequete.sRéférenceProduit = COL_Référence
// Utilise la fonction du Webservice

MaReponse = ProduitEnStock(MaRequete)
// Affiche la réponse du Webservice

InfoConstruit("Nombre de produits ""%1"" en stock : %2", ...
COL_Référence, MaReponse.ProduitEnStockResult..Valeur)
Examinons ce code :
• Deux variables sont définies : une variable correspondant aux données à passer au Webser-
vice (MaRequete), une variable correspondant aux données renvoyées par le Webservice
(MaReponse).
• La variable correspondant aux données à envoyer est initialisée avec la référence du pro-
duit.
• La fonction du Webservice ProduitEnStock est appelée et la variable MaReponse est mise à
jour.
• La réponse est mise en forme et affichée.
6. Fermez l’éditeur de code et enregistrez la fenêtre ( ou CTRL S).
Nous allons maintenant tester le fonctionnement du Webservice :

2. Cliquez si nécessaire sur l’onglet "Liste des produits".
3. Sélectionnez un produit au hasard dans le champ Table et cliquez sur le bouton "En stock ?".
4. Validez la fenêtre d’information et fermez l’application.
Leçon 3.13. Surveillez l’évolution de
vos applications
• Qu’est-ce que le tableau de bord ?

• Tests automatiques
Présentation
Le tableau de bord du projet est un élément indispensable à la gestion de projets WinDev. Le ta-
bleau de bord permet d’avoir une vision globale et synthétique de l’état d’avancement d’un projet.
Le tableau de bord est constitué de différents éléments (Widgets) permettant de voir d’un seul
coup d’œil l’état d’un projet.
Dans cette partie, nous nous limiterons à la manipulation des différents éléments du tableau de
bord et à la gestion des tests automatiques et à l’optimisation des requêtes.
Corrigé

Pour afficher le tableau de bord du projet (si ce n’est pas déjà fait), sous le volet "Projet",
dans le groupe "Projet", cliquez sur l’icône .
Le tableau de bord
Le tableau de bord du projet est composé de différents Widgets. Chaque Widget affiche une ou
plusieurs informations concernant le projet.
Par exemple, le Widget "Performances" permet de lancer directement l’analyseur de performances
ou d’ouvrir le dernier rapport de performances effectué.
Le Widget "Audit statique et Compilation" permet de voir rapidement si le projet contient des er-
reurs de compilation.
A tout moment, il est possible d’activer ou non un Widget, d’en ajouter ou d’en supprimer.
Détaillons quelques Widgets présents dans le tableau de bord.
Widget "Projet"
Ce Widget permet de voir rapidement les caractéristiques du projet :
• Projet présent ou non dans le GDS (Gestionnaire de sources). Nous verrons sa manipulation
dans une prochaine leçon.
• Nombre de configurations présentes pour ce projet. En déroulant le bouton fléché, vous pouvez
sélectionner une configuration ou en créer une nouvelle.
Un lien permet d’ouvrir le répertoire du projet.
L’option "Code" permet d’accéder au code du projet.
L’option "Graphe" permet d’afficher le graphe du projet.
Il est possible de revenir à tout moment au tableau de bord en utilisant (présent sous le volet
"Projet", dans le groupe "Projet").
Widget "GDS"
Ce Widget permet d’avoir l’état du projet présent dans le GDS.
Widget "Audit statique et Compilation"

Ce Widget permet de voir le nombre d’erreurs de compilation présentes dans le projet et de lancer
l’audit statique du projet.
L’audit statique permet d’avoir un état de votre projet. Il permet entre autre de :
• détecter le code mort, c’est-à-dire lister les procédures inutilisées dans votre site.
• détecter les éléments orphelins, c’est-à-dire lister les éléments de votre projet qui ne sont pas
utilisés (par exemple, page utilisée uniquement pour test lors du développement du site).
• détecter si une optimisation de requêtes est nécessaire : l’audit statique vous informe si votre
projet utilise des requêtes qui peuvent être optimisées par une simple modification de l’analyse
(ajout d’une clé composée par exemple).
Widget "Audit dynamique"

Ce Widget permet de lancer un audit dynamique du projet. L’audit dynamique permet de réaliser
un audit lors du test ou de l’exécution de l’application. Il est possible de connaître :
• l’occupation mémoire des différents éléments utilisés par l’application.
• les images non trouvées.
• ...
Widget "Performances"
Ce Widget permet de lancer l’analyseur de performances (nous l’étudierons dans une prochaine
leçon). L’analyseur de performances est un outil permettant de vérifier et d’optimiser le temps
d’exécution de votre application.
Widget "Sélection rapide"
Ce Widget permet de rechercher facilement un élément du projet. Il suffit de saisir quelques
lettres composant le nom de l’élément recherché. La sélection est automatiquement réalisée.
Vous voulez rechercher un élément sans être dans le tableau de bord ? Utilisez
Notes
la combinaison de touches [CTRL] + [E] ... et vous retrouverez les mêmes possi-
bilités.
Les Widgets en relation avec les Centres de Contrôle

WinDev est livré avec plusieurs Centres de Contrôle. Les Centres de Contrôle, comme leur nom
l’indique, permettent de contrôler un ensemble de fonctionnalités.
WinDev propose notamment le Centre de Suivi de Projets. Ce centre permet de gérer des projets
(informatiques ou non) de leur conception à leur livraison et même leur maintenance.
Ainsi, il est possible d’intégrer dans le tableau de bord un Widget permettant de connaître :
• le nombre de tâches actuellement en cours sur le projet. Ces tâches sont référencées dans le
Centre de Suivi de Projets. Ces tâches correspondent par exemple à :
• des fonctionnalités à ajouter au projet
• des développements futurs, ...
• le nombre de demandes actuellement présentes sur le projet. Ces demandes sont référencées
dans le Centre de Contrôle Qualité.
Tests automatiques
Une des fonctionnalités intéressantes du tableau de bord est de renseigner sur les tests qui ont
été réalisés sur l’application.
Nous avons déjà fait de nombreux tests d’utilisation, au fur et à mesure de la conception de notre
application.
Dans le tableau de bord, dans le Widget "Tests", déroulez la flèche et sélectionnez "Afficher les
résultats". La fenêtre de taux de validation de l’application apparaît.
Cette fenêtre recense tous les tests qui ont été effectués sur l’application :
• Tests manuels (c’est les tests que nous avons déjà effectués)
• Tests automatiques.
Les tests automatiques sont une catégorie de tests spécifiques. Les tests automatiques per-
mettent d’automatiser certaines manipulations de vos fenêtres. Ces tests sont enregistrés sous
forme de scénarios WLangage, facilement modifiables sous l’éditeur de code. Une fois enregistré,
le test automatique peut être réexécuté autant de fois que vous voulez, pour tester par exemple
l’impact d’une modification sur une fenêtre, une procédure, ...
Faisons immédiatement un essai ! Nous allons créer un test automatique sur la fenêtre de saisie
que nous avons créée au début de cette leçon.
Les tests automatiques peuvent être réalisés sur des fenêtres, des procédures,
Note
des classes.
Pour créer un test automatique sur une fenêtre, il suffit de tester la fenêtre :
1. Ouvrez la fenêtre "FEN_Menu" sous l’éditeur.
2. Sous le volet "Tests automatiques", dans le groupe "Tests", déroulez "Nouveau" et sélection-
nez "Enregistrer un nouveau test".
3. Dans la fenêtre qui s’affiche, cliquez sur "Commencer l’enregistrement".
4. Le test de la fenêtre se lance.
5. Cliquez sur l’onglet "Recherche de commandes".
6. Choisissez le mode de règlement "Carte bancaire".
7. Cliquez sur le bouton "Rechercher".
8. Fermez la fenêtre par le menu "Menu .. Quitter" et confirmez la fin de l’application. Si vous
n’avez pas suivi le cours en entier, cette option peut ne pas exister. Dans ce cas, fermez la
fenêtre par la croix.
9. Le test est terminé.
10. L’éditeur de tests propose d’enregistrer une description pour le test. Le test s’appelle "Test
de recherche de commandes". Validez.
11. Le code du test en WLangage apparaît sous l’éditeur de code. Fermez cette fenêtre de
code.
Les fonctions WLangage permettant de réaliser des tests automatiques sont les
Note
fonctions PiloteXXX.
12. L’éditeur de tests apparaît :
Le test est actuellement en cours de construction.

13. Nous allons rendre le test disponible (cliquez sur le lien "Terminer la construction du test
et le rendre disponible"). Maintenant, le test pourra être lancé à tout moment. L’éditeur de
tests nous indique que le test n’est jamais passé. Cliquez sur le lien "Lancer le test".
14. Le test s’exécute automatiquement et l’éditeur de tests affiche le résultat (le test est
passé avec succès dans notre cas).
15. Fermez l’éditeur de tests et enregistrez le test si nécessaire.
Nous allons maintenant faire une modification dans notre fenêtre, puis repasser le test. La
modification porte sur le bouton "Rechercher". Nous allons le rendre grisé.
1. Affichez si nécessaire la fenêtre "FEN_Menu".
2. Sous l’éditeur, cliquez sur l’onglet "Recherche de commandes" et sélectionnez le bouton
"Rechercher".
3. Affichez la description du bouton "Rechercher" (option "Description" du menu contextuel).
4. Dans l’onglet "IHM", sélectionnez l’option "Grisé".
7. Passez le test associé à la fenêtre : sous le volet "Tests automatiques", déroulez "Exécuter"
et sélectionnez l’option "Lancer les tests".
8. Le test est désormais en erreur.
9. Affichez la description du bouton "Rechercher" (option "Description" du menu contextuel).
10. Dans l’onglet "IHM", sélectionnez l’option "Actif".
12. Relancez le test. Le test passe maintenant correctement.
Une autre possibilité de l’éditeur de tests est la possibilité de modifier ou d’ajouter du code WLan-
gage dans les scénarios de test. Nous allons par exemple ajouter quelques lignes de code afin de
vérifier que le champ Table contient au moins un enregistrement.
1. Affichez l’éditeur de tests (par exemple double-cliquez sur "TEST_Menu" dans l’explorateur
de projet).
2. Affichez le code du test (option "Code" du menu contextuel du "Test de recherche de com-
mandes").
3. Ajoutez le code suivant avant la ligne "PiloteMenu("_Menu","OPT_Quitter")" (ou le code de
fermeture par la croix) :
// Si le champ Table ne contient aucun enregistrement
SI FEN_Menu.TABLE_REQ_RechercheCommandes..Occurrence = 0 ALORS
// Il faut remonter une erreur
TestEcritRésultat(terErreur, ...
"Le champ Table est vide après recherche")
FIN
4. Enregistrez le test et fermez l’éditeur de code.

5. Cliquez sur le lien "Terminer la maintenance du test et le rendre disponible".
6. Cliquez sur le lien "Lancer le test". Le test passe avec succès.
L’éditeur de tests propose de nombreuses fonctionnalités que nous ne pourrons pas aborder
dans ce cours :
• la possibilité d’utiliser un jeu de valeurs de test.
• la définition de paramètres d’entrée et de sortie du test.
• la possibilité de créer une bibliothèque de tests pour tester un exécutable par exemple sur
une machine différente du poste de développement.
Pour plus de détails sur les tests automatiques, nous vous conseillons de consulter l’aide en ligne
(mot-clé : "Test automatique").
Fermez l’éditeur de tests automatiques.
Leçon 3.14. Déployer l’application
• Création de l’exécutable
• Aide des nouveautés
• Création de l’installation
Présentation
Nous avons créé une application complète en découvrant de nombreuses fonctionnalités de Win-
Dev. Maintenant, il faut générer l’exécutable et installer l’application chez les utilisateurs. C’est
ce que nous allons faire pour conclure cette partie. Nous aurons ainsi vu la majorité des points
importants lors du développement d’une application WinDev.
Si vous n’avez pas réalisé les manipulations des leçons précédentes, vous pou-
Corrigé
vez suivre cette leçon en ouvrant un projet corrigé : sous le volet "Accueil", dans
"Application complète (Corrigé)".
Création de l’exécutable
La création de l’exécutable est une opération très simple : une option de menu et quelques clics
suffisent.
Nous vous proposons ici de détailler toutes les étapes de la création de l’exécutable afin de
connaître toutes les possibilités de WinDev. À tout moment, vous pouvez cliquer sur le bouton vert
pour valider la totalité des écrans de l’assistant.
Pour créer l’exécutable :

1. Dans la zone des boutons d’accès rapide du ruban, déroulez la roue et sélectionnez l’option
"Générer l’exécutable Windows 32 bits (.exe)".
WinDev permet également de créer des exécutables 64 bits, des exécutables

Note
Linux, des services, des applications Java, ...
2. L’assistant de création d’exécutable se lance. Un premier écran présentant l’état des tests
automatiques est affiché. Dans notre cas, tous les tests automatiques ont été passés avec
succès. Passez à l’écran suivant.
3. L’écran suivant permet de décrire les options générales de l’exécutable :
• le nom de l’exécutable : nous conservons le nom par défaut.
• le nom de l’icône associée à l’exécutable : vous pouvez sélectionner une icône dans le cata-
logue d’images.
• l’image d’introduction. WinDev propose plusieurs types de splash screen. Par défaut, un
splash screen avec texte animé est sélectionné. Le bouton "Options" permet de le configu-
rer.
Choisissez "Pas de splash screen" et passez à l’écran suivant.

4. Pour le fonctionnement de l’exécutable, nous garderons les options par défaut. Passez à
l’écran suivant.
5. L’écran suivant permet de personnaliser le message d’erreur de l’application. Nous garde-
rons le message proposé par défaut. Passez à l’écran suivant.
6. L’écran suivant permet de définir l’utilisation du MCU dans notre application.
Le MCU (Macro Code Utilisateur) donne la possibilité à l’utilisateur final de

créer ses propres procédures en WLangage pour modifier le fonctionnement
d’un champ, d’une fenêtre, ... Si le MCU est intégré dans l’application, l’uti-
Note
lisateur disposera d’un bouton supplémentaire dans la barre de titre pour

saisir les codes supplémentaires.
Pour plus d’informations, consultez l’aide en ligne (mot-clé "MCU").
Nous garderons les options par défaut. Passez à l’écran suivant.
7. Cet écran permet d’indiquer si l’exécutable prendra en compte les patchs.
Lors d’une modification de l’application, pour éviter de livrer la totalité de

l’exécutable, il est possible de livrer des ressources complémentaires (fe-
nêtres, états, ...) sous forme de patchs. Ces patchs sont en fait des biblio-
thèques additives.
Note
Si l’exécutable a été créé avec l’option "Oui, l’exécutable prendra en compte

ces mises à jour par patch", lors du lancement de l’application, les éléments
présents dans le patch se substitueront aux éléments présents dans la bi-
bliothèque de l’application.
Pour plus d’informations, consultez l’aide en ligne.
Nous garderons les options par défaut. Passez à l’écran suivant.

8. Cet écran permet de gérer les langues de l’exécutable. Nous aborderons le sujet du mul-
tilingue dans une prochaine leçon. Nous garderons les options par défaut. Passez à l’écran
suivant.
9. Cet écran récapitule tous les fichiers qui seront intégrés dans la bibliothèque de l’exécu-
table. Ce sont tous les éléments de votre projet qui peuvent être manipulés par l’utilisateur
final. Nous garderons les options par défaut. Passez à l’écran suivant.
10. L’écran suivant concerne le répertoire des fichiers de données. Si votre application doit
être déployée sur Windows Vista, il est conseillé de choisir l’option "Répertoire des données
de l’application".
Sous Windows Vista et supérieur, le système de l’UAC implique l’utilisation

Note
des normes de programmation Windows.

Pour plus d’informations, consultez l’aide en ligne.
Sélectionnez l’option correspondant au système utilisé par vos utilisateurs. Passez à l’écran
suivant.
11. Nous allons maintenant saisir les informations de l’exécutable. Ces informations sont af-
fichées sous l’explorateur Windows en sélectionnant les propriétés du fichier.
Entrez par exemple les informations suivantes :
Cet écran permet également de signer si nécessaire l’exécutable.

12. L’écran suivant concerne le numéro de version de l’exécutable. Il est possible d’utiliser :
• un format compatible avec les précédentes versions de WinDev,
• un format standard Windows. Sélectionnez cette option.
13. L’écran suivant concerne le framework WinDev.
Le framework correspond aux différentes librairies nécessaires au fonction-

Note
nement de l’exécutable.
L’option "Utiliser uniquement le framework propre à l’application" permet d’utiliser unique-

ment les librairies nécessaires.
L’option "Utiliser le framework WinDev commun" permet d’utiliser le framework commun à
toutes les applications WinDev installées sur le poste. Avec cette option, le framework est ins-
tallé une seule fois sur le poste (il est possible de le télécharger par Internet) et il est utilisé
par toutes les applications WinDev. Cochez cette option.
14. Un écran concernant Windows Vista (et supérieur) apparaît. Cet écran permet d’intégrer
un manifeste pour une utilisation sous Windows Vista (et supérieur).
Passez à l’écran suivant. WinDev propose de réaliser une sauvegarde du projet. Cette sau-
vegarde permet de garder une version du projet à chaque création d’exécutable. Dans notre
cas, sélectionnez l’option "Non : ne pas faire de sauvegarde du projet" et validez l’assistant.
15. L’exécutable est créé. Il est possible de le lancer immédiatement, pour vérifier son fonc-
tionnement. Pour cela, cliquez sur le bouton "Lancer l’exécutable".
Voilà, la création de l’exécutable est terminée. Beaucoup d’étapes, mais après une première
configuration de vos choix, vous pouvez valider dès le début toutes les étapes.
Il est également possible de cliquer directement sur les étapes indiquées dans
Note
l’assistant pour parvenir directement à un écran de l’assistant. Les options par

défaut des autres écrans seront automatiquement validées.
Création de l’installation
La création de l’installation est une opération très simple : un assistant vous permet de définir les
choix principaux. Si les options proposées par l’assistant ne suffisent pas, il est possible d’utiliser
l’éditeur d’installation. Nous ne détaillerons pas son utilisation dans cette leçon. Pour plus de
détails, consultez l’aide en ligne.
Nous vous proposons ici de détailler toutes les étapes de la création du programme d’installation
afin de connaître toutes les possibilités de WinDev. À tout moment, vous pouvez cliquer sur le bou-
ton vert pour valider la totalité des écrans de l’assistant.
Pour créer le programme d’installation :

1. Sous le volet "Projet", dans le groupe "Génération", déroulez "Procédure d’installation" et sé-
lectionnez l’option "Créer la procédure d’installation". L’assistant de création d’exécutable et
d’installation se lance.
Nous avons déjà créé l’exécutable : les options choisies sont mémorisées.
Note
Cliquez directement dans l’assistant sur l’intitulé "Compléments" de la partie

"Exécutable".
2. Un écran s’affiche proposant de réaliser une sauvegarde du projet. Sélectionnez l’option

"Non : Ne pas faire de sauvegarde du projet" et passez à l’écran suivant.
3. Nous passons maintenant dans la partie "Installation" de l’assistant. Dans ce premier
écran, choisissez le mode d’installation :
• Installation individuelle pour une application indépendante, installée et lancée sur chaque
poste. Nous choisissons cette option.
• Installation avec mise à jour automatique, pour une installation sur un poste serveur. Les
applications seront installées à partir du serveur. En cas de mise à jour, seule une mise à
jour du serveur est nécessaire. Les applications installées se mettront à jour automatique-
ment.
4. Choisissez une installation standard. Passez à l’écran suivant.
5. Nous ne changeons pas le répertoire d’installation par défaut. Passez à l’écran suivant.
6. Dans la liste des fichiers installés, conservez les fichiers proposés. Par défaut, WinDev pro-
pose le fichier Exécutable et le fichier d’aide (créé par l’aide des nouveautés). Nous allons
ajouter les fichiers de données :
• Cliquez sur le bouton "Ajouter". L’explorateur Windows affiche le contenu du répertoire de
génération de l’application.
• Sélectionnez les fichiers de données Client, Commande, LigneCommande, ModeRègle-
ment et Produit (fichiers d’extension ".fic", ".ndx" et ".mmo").
• Validez.

8. Dans les paramètres de la base de données, décochez toutes les options. Passez à
l’écran suivant.
9. Dans les modules complémentaires, conservez les options suivantes :
Nous allons choisir les outils optionnels à installer et inclure le désinstallateur. Grâce au
désinstallateur, les utilisateurs pourront désinstaller l’application depuis le gestionnaire de
programmes de Windows. Passez à l’écran suivant.
10. Nous allons sélectionner WDOptimiseur. Cet outil permet d’optimiser régulièrement les
fichiers de données de l’application.
11. Cliquez sur l’option "Support" à gauche de l’assistant. Nous allons générer l’installation
dans un répertoire unique. Par défaut, le programme d’installation est créé dans le sous-ré-
pertoire "Install" du projet. Il est possible de :
• Spécifier un mot de passe pour l’installation. Seul l’utilisateur connaissant le mot de passe
pourra lancer l’installation de l’application.
• Signer l’installation avec un certificat. Cette option permet de garantir l’intégrité du pack
d’installation.
12. Validez. Le programme d’installation est automatiquement créé.
13. Un écran apparaît permettant de tester l’installation ou d’ouvrir le répertoire de généra-
tion.
Installation d’une application
Dans la fenêtre de fin de création de l’installation, cliquez sur le bouton "Tester". Si vous avez
fermé cette fenêtre, lancez directement le programme "Install.exe" présent dans le répertoire du
programme d’installation. L’installation de l’application se lance.
Nous allons suivre les différentes étapes du programme d’installation de l’application "WD
1. Si vous utilisez un système d’exploitation correspondant à Windows Vista ou supérieur, une
fenêtre s’affiche demandant l’autorisation d’exécuter le programme. Validez cette fenêtre.
2. Choisissez la langue du programme d’installation et cliquez sur "OK".
3. L’assistant d’installation se lance.
4. Validez le répertoire d’installation de l’application.

5. Passez à l’écran suivant et terminez l’installation de l’application.
6. L’installation de l’application se lance.
Les différents types de déploiement
Nous venons de réaliser le déploiement d’une application simple. Dans l’assistant de création de
l’installation, WinDev propose également des installations avec mise à jour automatique.
Présentation
WinDev propose par défaut plusieurs modes d’installation pour une application WinDev :
• Installation autonome :
Ce type d’installation permet de créer un programme d’installation unique. Ce programme
d’installation sera exécuté par l’utilisateur final, directement sur son poste.
Pour mettre à jour l’application, il suffira de recréer une installation de l’application. L’utilisa-
teur final devra installer ce nouveau programme.
C’est le type d’installation que nous venons de réaliser.
• Installation avec mise à jour automatique :
Ce type d’installation permet de détecter automatiquement les mises à jour lors du lancement
de l’application. Si une mise à jour est disponible, l’utilisateur peut immédiatement se mettre à
jour.
Ce type d’installation est disponible aussi bien via réseau ou via le Web.
Détaillons un peu plus le fonctionnement d’une installation avec mise à jour.
Installation avec mise à jour réseau

La création du programme d’installation est réalisée grâce à l’assistant de création de programme
d’installation (option "Procédure d’installation" sous le volet "Projet").
Le programme d’installation obtenu à la fin de l’assistant est en fait composé de deux installa-
tions :
• l’installation de l’application de référence. L’application de référence doit être installée sur le
réseau (par exemple dans un répertoire partagé ou sur un serveur), accessible par tous les utili-
sateurs finaux de l’application.
• l’installation de l’application elle-même. Cette installation est englobée dans l’application de
référence. Elle n’est accessible qu’une fois l’application de référence installée.
Le schéma suivant présente le mode d’installation d’une application utilisant une base HFSQL
Classic en local, avec une mise à jour réseau.
A chaque lancement de l’application par l’utilisateur final, la vérification de la version de l’appli-

cation de référence est automatiquement réalisée. Si cette version a été modifiée (par exemple si
une mise à jour de la version de référence a été effectuée), une mise à jour de l’application finale
est automatiquement proposée.
Installation avec mise à jour Internet
L’installation avec mise à jour par Internet utilise le même principe.
La création du programme d’installation est réalisée grâce à l’assistant de création de programme
d’installation (option "Procédure d’installation" sous le volet "Projet").
Le programme d’installation obtenu à la fin de l’assistant est en fait composé de :
• l’installation de l’application de référence et la page Web permettant de télécharger l’installa-
tion cliente. Ces éléments doivent être installés sur un serveur HTTP.
• l’installation de l’application elle-même. Cette installation est englobée dans l’application de
référence. Elle n’est accessible qu’une fois l’application de référence installée, par la page Web
de téléchargement.
Le schéma suivant présente le mode d’installation d’une application utilisant une base HFSQL
Client/Serveur, avec une mise à jour par Internet.
Leçon 3.15. Diffusez "Etats & Re-
quêtes" avec vos applications
• A quoi sert le logiciel "Etats & Requêtes".

• Comment diffuser le logiciel "Etats & Requêtes".
• Comment utiliser le logiciel "Etats & Requêtes".
WinDev 19 version "Express" :

Le logiciel "Etats et Requêtes" n’est pas disponible dans cette version d’évaluation
Présentation du logiciel "Etats & Requêtes"
Le logiciel "Etats & Requêtes" permet aux utilisateurs de modifier et de créer à leur convenance
les états et les requêtes de vos applications.
Un utilisateur trouve qu’il manque une information sur l’état fourni en standard ? Avec le logi-
ciel "Etat & Requêtes", il peut ajouter l’information directement depuis l’aperçu avant impression.
Cette modification peut être intéressante pour d’autres utilisateurs ? L’état peut être mis à dispo-
sition de tous les utilisateurs utilisant l’application en réseau. De même pour les requêtes.
Le logiciel "Etats & Requêtes" est gratuit et librement redistribuable avec vos ap-
Notes
plications créées avec WinDev. Consultez la licence pour plus de détails sur les
conditions de redistribution.
Lancement du logiciel "Etats & Requêtes"

Pour que les utilisateurs finaux personnalisent les états de votre application ou créent leurs
propres états et leurs propres requêtes, il suffit de lancer le logiciel "Etats & Requêtes".
Pour permettre à vos utilisateurs finaux de lancer le logiciel "Etats & Requêtes" :
• soit affichez vos états sous la fenêtre d’aperçu avant impression. Les utilisateurs finaux
pourront lancer le logiciel "Etats & Requêtes" en cliquant l’icône .
• soit ajoutez le menu d’aide automatique ‘?’ dans la fenêtre principale de votre application :
sous le volet "Fenêtre", dans le groupe "Barres et menus", déroulez "Menu principal" et
sélectionnez l’option "Ajouter le menu ‘?’".
Dans l’assistant de création de ce menu, cochez les options "Créer, modifier un état" et
"Créer, modifier une requête".
• soit utilisez la fonction LanceEtatsEtRequêtes dans votre application.
Diffuser le logiciel "Etats & Requêtes" avec votre application

Pour diffuser le logiciel "Etats & Requêtes" avec votre propre application WinDev, il est nécessaire
de :
• indiquer au niveau du projet que l’application autorise le lancement du logiciel "Etats & Re-
quêtes".
• définir si nécessaire au niveau de l’analyse les fichiers et rubriques qui seront utilisables
avec le logiciel "Etats & Requêtes".
• définir les états et les requêtes modifiables sous le logiciel "Etats & Requêtes".
• créer l’exécutable et le programme d’installation intégrant le logiciel "Etats & Requêtes".
Nous allons détailler ces différentes étapes en manipulant le projet "WD Application Complète".
Corrigé
"Application complète (Corrigé)"
Paramétrage du projet
Pour utiliser le logiciel "Etats & Requêtes" à partir de votre application, il est nécessaire de
configurer le projet associé à votre application.
1. Si nécessaire, ouvrez le projet exemple "WD Application Complète" : sous le volet "Accueil",
dans le groupe "Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez l’option "WD
Application Complète (Exercice)". Le projet se charge.
Si vous n’avez pas réalisé les états dans le projet "WD Application Complète",
Notes
ouvrez le projet corrigé de l’application : sous le volet "Accueil", dans le groupe

"Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez l’option "WD
Application Complète (Corrigé)".
2. Affichez la description du projet.

Rappel : Pour afficher la description du projet, sous le volet "Projet", dans le groupe "Projet",
cliquez sur "Description".
3. Dans l’onglet "Avancé", cochez l’option "Autoriser le lancement de "Etats et Requêtes"".
4. Validez.
Paramétrage de l’analyse
Nous allons maintenant ouvrir l’analyse pour paramétrer les fichiers et rubriques utilisables sous
le logiciel "Etats & Requêtes".
Ouvrez l’analyse de votre projet : cliquez sur parmi les boutons d’accès rapide du menu
de WinDev.
Par défaut, tous les fichiers de données et toutes leurs rubriques sont visibles et manipu-
lables avec le logiciel "Etats & Requêtes". Si votre application contient des informations
sensibles (mots de passe, ...) vous pouvez rendre ces fichiers de données ou ces rubriques
invisibles sous le logiciel "Etats & Requêtes".
A partir du logiciel "Etats & Requêtes", l’utilisateur ne peut pas ajouter, modifier
ou supprimer des enregistrements (les fonctions HAjoute, HModifie et HSup-
Notes
prime sont interdites). Il n’est également pas possible de créer ou de re-créer
des fichiers de données (les fonctions HCréation et HCréationSiInexistant sont
interdites).
Pour définir un fichier invisible sous le logiciel "Etats & Requêtes" :

1. Sous l’éditeur d’analyses, sélectionnez le fichier de données voulu.
2. Affichez la fenêtre de description du fichier (option "Description du fichier de données" du
menu contextuel).
3. Dans l’onglet "Etats et Requêtes", décochez l’option "Visible par l’utilisateur final, dans le
logiciel "Etats et Requêtes"".
4. Validez.
Pour définir une rubrique invisible sous le logiciel "Etats & Requêtes" :
1. Sous l’éditeur d’analyses, sélectionnez le fichier de données voulu.
2. Affichez la fenêtre de description du fichier (option "Description des rubriques" du menu
contextuel).
3. Sélectionnez dans la table, la rubrique voulue.
4. Dans l’onglet "Etats et Requêtes", décochez l’option "Visible par l’utilisateur final, dans le
logiciel "Etats et Requêtes"".
5. Validez.
Pour prendre en compte les modifications effectuées dans l’analyse, il est nécessaire de
régénérer l’analyse (option "Génération" dans le volet "Analyse"). Une modification automa-
tique des fichiers de données est proposée pour prendre en compte les modifications
effectuées.
Paramétrage des états

Lors de la création d’un état, il est possible de spécifier si cet état est modifiable sous le logiciel
"Etats & Requêtes".
Pour rendre l’état "ETAT_Table_REQ_RechercheCommandes" présent dans le projet "WD
Application Complète" modifiable sous le logiciel "Etats & Requêtes" :
1. Ouvrez l’état "ETAT_Table_REQ_RechercheCommandes" sous l’éditeur d’états.
2. Affichez la description de l’état (option "Description de l’état" du menu contextuel).
3. Dans l’onglet "Options", cochez "Etat modifiable sous Etats et Requêtes".
4. Cochez :
• l’option "Interface modifiable uniquement" pour que l’interface de l’état uniquement soit
modifiable sous Etats & Requêtes.
• l’option "Tout modifiable (interface et code)" pour que l’état soit entièrement modifiable
sous Etats & Requêtes.
5. Validez et enregistrez l’état.
Paramétrage des requêtes

Par défaut, une requête est modifiable sous le logiciel "Etats & Requêtes".
Pour rendre une requête de votre application modifiable sous le logiciel "Etats & Requêtes" :
1. Ouvrez la requête sous l’éditeur de requêtes.
2. Affichez la description de la requête (option "Description de la requête" du menu contextuel
du graphe de la requête).
3. Cliquez sur le bouton "Avancé".
4. Dans l’onglet "Etats et Requêtes", cochez "Visible sous Etats et Requêtes".
5. Validez et enregistrez la requête.
Création de l’exécutable et diffusion de l’application

La création et la diffusion d’une application utilisant le logiciel "Etats & Requêtes" se fait de la
même façon que pour une application classique. C’est lors de la création de la procédure d’instal-
lation, que vous pourrez indiquer les paramètres spécifiques au logiciel "Etats & Requêtes".
Pour créer le programme d’installation de votre application "WD Application Complète" :
1. Sous le volet "Projet", dans le groupe "Génération", cliquez sur "Procédure d’installation".
L’assistant de création d’installation se lance. Cliquez sur le lien "Installation" à gauche de l’as-
sistant.
2. Sélectionnez "Créer l’exécutable maintenant". La création de l’exécutable est réalisée.
3. L’assistant de création d’installation se lance.
4. Choisissez une "Installation individuelle". Passez à l’écran suivant.
5. Choisissez une "Installation standard". Passez à l’écran suivant.
6. Validez le répertoire d’installation proposé et passez à l’écran suivant.
7. Dans l’écran "Fichiers installés", sélectionnez si nécessaire les fichiers de données (.fic,
.mmo et .ndx) présents dans le répertoire de l’exécutable. Pour cela, cliquez sur "Ajouter" et
sélectionnez ces fichiers. Passez à l’écran suivant.
8. Dans l’écran "Modules complémentaires" (accessible en cliquant à gauche sur le lien
"Compléments"), vérifiez que l’option "Intégrer l’installation de Etats et Requêtes" est cochée.
9. Dans l’écran intitulé "Etats et Requêtes" :
• Spécifiez si vous voulez incorporer l’installation de "Etats & Requêtes" dans votre pro-
gramme d’installation.
Dans ce cas, le package d’installation du logiciel "Etats & Requêtes" est recherché. Par dé-
faut, ce pack d’installation est présent dans le sous-répertoire "Etats et Requêtes" du réper-
toire d’installation de WinDev.
Attention : Incorporer le logiciel "Etats & Requêtes" augmente la taille de votre installation
de façon non négligeable (environ 215 Mo).
• Spécifiez si nécessaire les répertoires correspondant aux états et requêtes modifiés ou

créés par l’utilisateur final.
Le répertoire des états et requêtes personnels correspond au répertoire des états et re-
quêtes visibles uniquement par l’utilisateur qui les a créés.
Le répertoire des états et requêtes partagés correspond au répertoire des états et requêtes
visibles par tous les utilisateurs de l’application.
Ces répertoires peuvent être modifiés lors de l’installation de l’application : il suffit de co-
cher l’option "Autoriser la modification de ces répertoires lors de l’installation".
10. Cliquez sur l’option "Support" à gauche de l’assistant.
11. Validez l’assistant. Le programme d’installation est généré. Ne fermez pas la fenêtre indi-
quant la fin de la création de l’installation.
Installer et utiliser le logiciel "Etats & Requêtes"
Installation de l’application
Pour tester l’installation et l’utilisation du logiciel "Etats & Requêtes", nous allons installer l’appli-
cation "WD Application Complète".
En suivant les étapes du paragraphe précédent, vous avez généré le programme d’installation de
cette application. Le programme d’installation a été créé dans le sous-répertoire "Install" du projet
en cours.
Dans la fenêtre de fin de création de l’installation, cliquez sur le bouton "Tester". Si vous avez
fermé cette fenêtre, lancez directement le programme "Install.exe" présent dans le répertoire
du programme d’installation. L’installation de l’application se lance.
Nous allons suivre les différentes étapes du programme d’installation de l’application "WD
1. Si vous utilisez un système d’exploitation correspondant à Windows Vista ou supérieur, une
fenêtre s’affiche demandant l’autorisation d’exécuter le programme. Validez cette fenêtre.
2. Choisissez la langue du programme d’installation et cliquez sur "OK".
3. L’assistant d’installation se lance.
4. Validez le répertoire d’installation de l’application.
5. L’écran "Etats et Requêtes" permet d’installer le logiciel "Etats & Requêtes" (uniquement si
ce programme n’est pas déjà installé sur le poste en cours).

7. L’écran suivant permet de définir les répertoires utilisés pour l’enregistrement des états et
des requêtes.
8. Passez à l’écran suivant et terminez l’installation de l’application.
9. L’installation de l’application, puis l’installation du logiciel "Etats & Requêtes" se lance.
Nous allons maintenant nous placer dans la peau de l’utilisateur final de votre application (ce
n’est pas évident, mais pourquoi pas).
Pour tester l’application :
1. Lancez l’application "WD Application Complète".
2. Sélectionnez l’option "Etats .. Liste des clients". L’état apparaît en mode "Aperçu avant im-
pression".
3. Dans cet écran, deux nouvelles icônes font leur apparition :
Permet de modifier l’état en cours dans l’aperçu avant impression.
Permet de créer un nouvel état.
Nous allons modifier cet état :

1. Cliquez sur l’icône .
2. L’état apparaît en édition sous le logiciel "Etats & Requêtes".
3. L’utilisateur peut alors faire les modifications qu’il souhaite :

• sur le style des informations affichées (par exemple changer la couleur d’un champ).
• sur le contenu de l’état (par exemple ajouter un champ, ...). Si l’état est lié à une requête,
l’utilisateur peut modifier cette requête.
Si l’état est lié à une requête intégrée, la modification est effectuée directement dans l’état.
Si l’état est lié à une requête indépendante, la requête est également modifiée. La
modification sera prise en compte uniquement dans le cadre de l’exécution de l’état (si une
fenêtre utilise également cette requête, la modification ne sera pas prise en compte par la
fenêtre).
Dans cet exemple, nous allons mettre la date en rouge. Pour cela :
1. Sélectionnez le champ date dans le début de document.
2. Sous le volet "Modification", dans le groupe "Edition rapide", cliquez sur l’icône "Couleur"
( ) et sélectionnez la couleur rouge.
3. Enregistrez votre état. Par défaut, le répertoire proposé est le répertoire d’installation de
votre application.
4. Fermez le logiciel "Etats & Requêtes".
5. Sélectionnez l’option "Etats .. Liste des clients" dans l’application. L’état apparaît en mode
"Aperçu avant impression" et la modification réalisée est effective.
Dans cet exemple, l’état que vous avez modifié est disponible pour vous seul. Dans le cas d’une
application réseau, l’utilisateur a la possibilité de mettre à disposition de tous les utilisateurs un
état modifié.
Nous avons fini notre découverte du logiciel "Etats & Requêtes". Pour plus de détails, consultez
l’aide en ligne (mot-clé : Etats et Requêtes).
Conclusion
Toute la phase de développement de notre application est terminée. Les deux prochaines leçons
vont vous permettre de découvrir :
• comment transformer votre application en une application multilingue,
• comment intégrer votre application dans le Gestionnaire de sources (GDS).
Leçon 3.16. Gérer le multilingue
• Qu’est-ce qu’une application multilingue ?

• Etape par étape, création d’une application multilingue.
Qu’est-ce qu’une application multilingue ?
Une application multilingue est une application qui peut s’exécuter en anglais, en français, en
allemand ou dans une autre langue.
Une seule et même application peut donc être utilisée dans plusieurs langues. Mais comment
est-ce possible ?
C’est ce que nous allons voir dans cette leçon.
Nous allons manipuler un projet qui pourra s’exécuter en français ou en anglais, selon le choix de
l’utilisateur.
Les principales étapes d’une application multilingue sont :
• Le choix des langues du projet.
• L’internationalisation de l’analyse.
• L’internationalisation des éléments du projet (fenêtres, états, champs, aide, ...).
• L’internationalisation des messages présents dans le code.
• La programmation du changement de langue dans l’application.
Nous allons appliquer ces différentes étapes au projet "WD Application Complète". Ce projet, dis-
ponible en Français, va être traduit en Anglais.
Corrigé
Choix des langues du projet
La première opération consiste à choisir les langues du projet.

"Description".
2. Cliquez sur l’onglet "Langues". Notre application va gérer le Français et l’Anglais.
3. Cliquez sur le bouton "Ajouter". La fenêtre de sélection des langues apparaît.
4. Cliquez sur "Anglais". Une coche apparaît à droite de la langue.
5. Validez. La langue "Anglais" apparaît dans la liste des langues du projet.
L’onglet "Langues" permet également de paramétrer les options linguistiques concernant les
nombres, les monétaires, les dates, ... pour la langue sélectionnée. Voyons un exemple :
1. Cliquez sur la langue "Anglais".
2. Sélectionnez l’onglet "Date".
3. Par défaut, les options linguistiques de Windows sont utilisées. Si vous sélectionnez l’op-
tion "Utiliser les paramètres suivants", il est possible de définir le format de date utilisé ainsi
que la traduction des jours et des mois.
4. Conservez l’option "Utiliser les paramètres définis dans les options linguistiques du sys-
tème d’exploitation".
Dans les options linguistiques, il est possible de choisir le sens d’écriture de la
Notes
langue (onglet "Divers", option "Sens d’écriture"). Il est ainsi possible de créer des
interfaces avec une langue s’écrivant de droite à gauche.
Validez. Un message propose de synchroniser les différents éléments du projet. Répondez

"Oui". Tous les éléments du projet ouverts sous l’éditeur (fenêtres, états, ...) sont fermés et la
ou les langues supplémentaires sont ajoutées à ces éléments.
Internationalisation de l’analyse
Par défaut, une analyse est créée dans une langue et ne peut pas être traduite.
Cependant, certaines informations peuvent être saisies dans plusieurs langues (notes du dossier,
informations partagées, ...).
Si votre application utilise le module Etats et Requêtes, il est également possible de traduire les
noms de fichiers et les noms de rubriques. Cette traduction peut être réalisée dans l’onglet "Etats
et Requêtes" (de la description de fichiers ou de rubriques).
Les champs créés à partir des rubriques de l’analyse ont par défaut le libellé de la rubrique spé-
cifié dans l’analyse. Si un libellé a été spécifié dans les informations partagées de la rubrique, ce
libellé sera utilisé lors de la création du champ.
Lors du changement de la langue du projet lié à l’analyse, ce changement n’est pas automati-
quement reporté dans l’analyse. En effet, une analyse peut être partagée entre plusieurs projets.
Pour gérer plusieurs langues dans une analyse :
1. Affichez l’éditeur d’analyses : cliquez sur parmi les boutons d’accès rapide du menu de
WinDev.
2. Dans la description de l’analyse (option "Description de l’analyse" du menu contextuel),
sélectionnez l’onglet "International".
3. La liste des différentes langues gérées par l’analyse s’affiche. L’anglais n’étant pas géré :
• Cliquez sur le bouton "Ajouter".
• Sélectionnez "Anglais".
• Validez la fenêtre d’ajout des langues.
4. Validez la fenêtre de description de l’analyse.
Pour prendre en compte toutes les langues du projet lié à l’analyse en cours, il
Note
est également possible de cliquer sur le bouton "Synchroniser avec le projet".
Pour saisir les informations partagées dans plusieurs langues, examinons un cas simple : la
saisie de libellé du champ lié à la rubrique "Adresse" du fichier "Client" :
1. Sélectionnez le fichier Client.
2. Affichez la description des rubriques d’un fichier de données (option "Description des ru-
briques" du menu contextuel du fichier).
3. Sélectionnez la rubrique "Adresse" et affichez les paramètres du champ relié à la rubrique
sélectionnée (informations partagées). Pour cela, cliquez sur la double flèche en bas de
l’écran .
4. Dans la zone "Libellé’, saisissez le libellé pour la langue anglaise "Address".
5. Validez.
La traduction des informations partagées de l’analyse peut être faite :

• en même temps que la création de l’analyse.
Note
• à tout moment via l’éditeur.

• à tout moment grâce aux outils WDMSG et WDTRAD, deux outils permettant
d’extraire, de traduire et de réintégrer les éléments à traduire.
Pour prendre en compte les modifications réalisées dans l’analyse, il est nécessaire de
générer l’analyse : sous le volet "Analyse", dans le groupe "Analyse", cliquez sur "Génération".
Internationalisation des éléments du projet
Tous les éléments du projet peuvent devenir multilingues : fenêtres, états, aide, ...
Nous allons modifier quelques éléments de la fenêtre FEN_Menu pour voir les différentes mé-
thodes à utiliser.
Nous allons ainsi modifier :
• l’image du bandeau utilisée dans la fenêtre FEN_Menu.
• les libellés des champs de la fenêtre FEN_Menu.
• les options du menu.
• le message affiché par le code WLangage lors de la fermeture de l’application.
Ouvrez la fenêtre "FEN_Menu" sous l’éditeur (double-cliquez sur son nom dans le volet
"Explorateur de projet" par exemple).
Vérifions tout d’abord que la fenêtre FEN_Menu est bien associée aux différentes langues
définies dans le projet :
1. Affichez la description de la fenêtre (option "Description" du menu contextuel de la fenêtre).
2. Sélectionnez l’onglet "Langue" : les deux langues sélectionnées dans le projet apparaissent.
3. Sélectionnez l’onglet "Général" : il faut traduire le titre de la fenêtre.
4. Saisissez "Menu" dans la zone anglaise.

5. Validez la fenêtre.
Internationalisation d’une image
Pour changer l’image du bandeau utilisé dans la fenêtre FEN_Menu selon la langue d’exécu-
tion :
1. Ouvrez la fenêtre "FEN_Menu.WDW".
2. L’image du bandeau est contenue dans le modèle associé à la fenêtre. Il est donc néces-
saire d’ouvrir le modèle de fenêtres associé :
• Cliquez sur le champ "WD ApplicationComplète" et affichez le menu contextuel.
• Sélectionnez l’option "Ouvrir le modèle".
• Le modèle de fenêtres apparaît, entouré d’un cadre orange.

3. Affichez la fenêtre de description du bandeau :
• Sélectionnez le champ "WD ApplicationComplète" et affichez le menu contextuel.
• Sélectionnez l’option "Description".
4. Dans la zone "Image", cliquez sur le bouton .
5. La fenêtre de gestion des images multilingues s’affiche. Il est possible d’utiliser une image
différente pour chaque langue. Cette fonctionnalité est très utile si vous utilisez des images
contenant du texte.
6. Pour notre exemple, dans la zone "Anglais", sélectionnez le fichier "header-us.png".

7. Validez. Le libellé "<Valeurs multi-langues>" apparaît désormais dans la zone "Image" de la
fenêtre de description.
9. Enregistrez le modèle de fenêtres ( ou CTRL S).
10. Mettez à jour les fenêtres utilisant le modèle de fenêtres en cliquant sur l’icône dans
le bandeau orange. Validez la fenêtre de mise à jour.
11. Fermez le modèle de fenêtres affiché sous l’éditeur.
Internationalisation des champs
Un champ peut afficher de nombreuses informations à l’utilisateur :
• un libellé,
• un message d’aide,
• une image, ...
Toutes ces informations doivent être traduites. Ces informations sont accessibles dans les diffé-
rents onglets de la fenêtre de description du champ.
Pour notre exemple, nous allons traduire le premier volet du champ Onglet.
1. Affichez la description du champ Onglet.
2. Sélectionnez le premier onglet "Liste des produits".
3. Dans la zone basse de l’écran, il est possible de saisir la traduction : "List of products".
4. Cliquez sur "Détails (volet)". Dans cette zone, il est possible de définir une image spécifique
pour le volet d’onglet par langue (comme nous l’avons fait précédemment).
5. Cliquez sur "Aide (volet)". Dans cette zone, il est possible de définir une bulle d’aide par
langue.
6. Fermez la fenêtre de description du champ.
Internationalisation d’un message de programmation

Tous les messages de votre programme peuvent également être saisis dans plusieurs langues.
Dans notre exemple, la sélection du menu "Quitter" affiche le message "Quitter l’application".
Nous allons traduire ce message.
Pour traduire le message de l’option de menu :
1. Affichez le code de l’option de menu :
• Sous l’éditeur, déroulez le menu.
• Sélectionnez l’option "Quitter".
2. Pour traduire ce type de message, positionnez le curseur dans la chaîne "Quitter l’applica-
tion ?" et utilisez la combinaison de touche [CTRL T]. Il est également possible, sous le volet
"Code", dans le groupe "Langues", de dérouler "Traduire les chaînes" et sélectionner "Traduc-
tion des messages".
3. La fenêtre suivante apparaît :
4. Cette fenêtre permet de saisir tous les messages de votre programme dans toutes les lan-
gues du projet.
5. Dans la zone "Anglais", saisissez "Exit from the application?" et validez.
6. L’icône ainsi qu’un chiffre apparaît sous l’éditeur de code.
Ces icônes indiquent que le message multilingue existe en 2 langues.

Internationalisation des menus

La traduction des options d’un menu peut être réalisée comme pour les autres champs via la
fenêtre de description de l’option, ou directement à partir de l’éditeur de fenêtres.
Pour traduire le menu de la fenêtre "FEN_Menu" :
1. Sous le volet "Affichage", dans le groupe "Options", déroulez "Langue affichée" et sélection-
nez la langue à visualiser sous l’éditeur (anglais dans notre cas).
2. Les options de menu s’affichent dans la langue sélectionnée. Si aucune traduction ne cor-
respond à la langue sélectionnée, les options de menu s’affichent en français.
3. Déroulez l’option "Menu".
4. Sélectionnez l’option "Envoyer un email".
5. Tapez sur la touche [espace] du clavier : le libellé passe en édition.
6. Saisissez le libellé en anglais : "Send an email".
Les outils de traduction
Nous venons de traduire manuellement quelques éléments de notre application.
Pour traduire ces informations, WinDev met plusieurs moyens à votre disposition :
• une traduction directe des messages dans les différents éditeurs. Cette traduction peut être
réalisée via un outil de traduction, Google Traduction (sous réserve de posséder une licence), ...
• une traduction réalisée grâce à un outil externe (WDMSG et WDTRAD).
Saisie directe des traductions

Les traductions sont directement saisies dans l’interface du produit. Par exemple, le libellé du
bouton "Nouveau" devient "New" en anglais. Il suffit d’ouvrir la fenêtre de description du champ et
de saisir dans la langue voulue la traduction correspondante.
Si vous disposez d’un logiciel de traduction ou d’un site de traduction, vous pouvez configurer
WinDev pour utiliser ce logiciel :
1. Sous le volet "Accueil", dans le groupe "Environnement", déroulez "Options" et sélectionnez
"Options générales de WinDev".
2. Affichez l’onglet "Traduction".
3. Spécifiez :
• Si les paramètres régionaux doivent être automatiquement activés selon la langue en cours
de saisie. Dans ce cas, si la langue nécessite un alphabet spécifique, cet alphabet sera au-
tomatiquement sélectionné.
• Le logiciel ou le site à utiliser pour la traduction. Il est possible d’utiliser WDDixio, diction-
naire de traduction livré avec WDMSG (voir page suivante), un logiciel ou un site de traduc-
tion spécifique, ou Google Traduction (pour plus de détails, consultez l’aide en ligne).
• Les langues gérées.
4. Lorsque les paramètres de traductions sont définis, il est possible d’utiliser le bouton
présent dans les différentes fenêtres de description des éléments du projet : ce bouton
permettra d’utiliser le logiciel défini pour la traduction.
Traduction avec WDMSG et WDTRAD
Il existe également un outil nommé WDMSG (non fourni en standard avec WinDev) qui permet :
• d’extraire tous les messages d’un projet (libellé des champs, message de code, titre des fe-
nêtres, ...) pour les traduire,
• de réintégrer les messages traduits.
Les messages à traduire sont extraits :
• dans un format texte pouvant être configuré pour être utilisé avec la majorité des logiciels de
traduction.
• au format HFSQL.
WDMSG est également fourni avec un outil d’aide à la traduction, WDTRAD. WDTRAD permet de
saisir simplement toutes les traductions des informations multilingues d’un projet.
Pour obtenir plus d’informations sur WDMSG et WDTRAD, contactez le Service Commercial de
PC SOFT.
Autres éléments à traduire : les messages du framework

De nombreuses informations et messages sont présents dans le framework WinDev. Par exemple,
les noms des jours et des mois utilisés par les fonctions de gestion des dates proviennent du
framework WinDev. Pour traduire une ou plusieurs librairies de ce framework, il est nécessaire
d’utiliser WDINT (non fourni en standard avec WinDev).
Ce logiciel permet d’obtenir un fichier d’extension WDM. Pour utiliser ce fichier dans votre appli-
cation :
• vous pouvez utiliser la fonction ChargeErreur.
• vous pouvez intégrer le fichier à la description du projet dans l’onglet "Langues". Il suffit de
sélectionner la langue voulue et de sélectionner l’onglet "Divers".
Pour obtenir plus d’informations sur WDINT, contactez le Service Commercial de PC SOFT.
Programmation du changement de langue
Par défaut, le projet s’exécute dans la langue d’exécution définie pour le projet, dans l’onglet "Lan-
gues" de la description du projet (option "Description" sous le volet "Projet").
Dans une application, le choix de la langue peut s’effectuer via une option de menu. La fonction
Nation utilisée dans le traitement associé à l’option de menu permet de changer la langue de
l’application en cours d’exécution.
Ajout d’une option de menu
Pour ajouter une option de menu :

1. Ouvrez si nécessaire la fenêtre "FEN_Menu" sous l’éditeur (double-cliquez sur son nom dans
l’explorateur de projet).
2. Cliquez sur l’option "Menu" de la fenêtre. Le menu se déroule.
3. Sélectionnez l’option "Envoyer un email".
4. Affichez le menu contextuel (clic droit). Sélectionnez l’option "Ajouter après". Saisissez le
libellé "Langues" et validez.
5. Sélectionnez l’option "Langues" que vous venez de créer.
6. Affichez le menu contextuel (clic droit) et sélectionnez l’option "Transformer pour dérouler
un sous-menu".
7. Saisissez le libellé de la première sous-option "Français".
8. Appuyez sur la touche [Entrée] deux fois et saisissez le libellé de la seconde sous-option
"Anglais".
Nous allons maintenant saisir le code WLangage nécessaire au changement de langue.
Programmation
Pour saisir le code de gestion des langues :

1. Sélectionnez l’option "Menu .. Langues .. Francais" sous l’éditeur.
2. Affichez le menu contextuel (clic droit). Sélectionnez l’option "Code".
Nation(nationFrançais)
4. Sélectionnez l’option "Menu .. Langues .. Anglais" sous l’éditeur.

5. Affichez le menu contextuel (clic droit). Sélectionnez l’option "Code".
Nation(nationAnglais)
La fonction Nation permet de changer la langue d’exécution de l’application. Les constantes pas-
sées en paramètre permettent de spécifier la langue à utiliser.
Le changement de langue effectué par la fonction Nation est immédiatement effectif.
Test du projet
Nous avons traduit quelques éléments de l’application, nous allons maintenant tester le change-
ment de langue.
Pour tester l’application :
1. Lancez le test du projet ( parmi les boutons d’accès rapide). La fenêtre apparaît en mode
test en français.
2. Sélectionnez l’option "Menu .. Langues .. Anglais".
3. Les différents éléments que nous avons traduits apparaissent en anglais :
4. Terminez le test et revenez sous l’éditeur.
Leçon 3.17. GDS
• Présentation
• Le gestionnaire de sources
• Utilisation du gestionnaire de sources
WinDev 19 version "Express" :

Cette fonctionnalité n’est pas disponible dans cette version d’évaluation
Introduction
Un développement informatique important nécessite la participation de plusieurs développeurs.
Ces développeurs doivent travailler sur un projet WinDev unique, en partageant les différentes
ressources (fenêtres, classes, ...) manipulées.
WinDev gère en standard un gestionnaire de sources nommé "GDS" permettant de partager les
sources de différents projets entre développeurs et de connaître l’historique complet des modifi-
cations réalisées (dans le code, l’interface, ...).
GDS (Gestionnaire de Sources)
Principe du GDS
Le gestionnaire de sources permet de stocker et de partager des projets et tous leurs éléments.
Le principe est le suivant :
• Une version de référence de chacun de vos projets est présente sur un serveur. L’ensemble
de ces versions est appelé "Base de sources".
• Chaque développeur a sur son poste une copie locale des différents projets sur laquelle il
travaille.
• Lorsqu’un développeur veut modifier un élément d’un projet (une fenêtre, un état, une re-
quête, ...), il indique au GDS qu’il s’approprie temporairement cet élément. Pour cela, le dé-
veloppeur va extraire cet élément de la base de sources.
• Ce développeur obtient alors les droits exclusifs sur cet élément : il peut faire toutes les
modifications voulues sur cet élément.
• Les autres développeurs continuent de travailler avec la copie de la version de référence de
cet élément (présente sur la base de sources).
• Dès que le développeur a terminé ses modifications, il réintègre l’élément extrait dans la
base de sources.
• Les autres développeurs sont automatiquement avertis de cette réintégration. Ils peuvent
alors mettre à jour leur copie locale.
Le GDS gère donc le travail collaboratif et permet de connaître l’historique de toutes les modifica-
tions réalisées.
Le GDS permet également d’administrer et de réglementer les éléments partagés entre plusieurs
projets.
Création de la base de sources

Pour partager un projet grâce au gestionnaire de sources, il est nécessaire de créer une base de
sources. Cette base de sources doit être créée une seule fois sur un poste serveur.
Cette base de sources peut être créée à différents moments :
• lors de l’installation de WinDev.
• lors de la création d’un projet utilisant le GDS.
• lors de l’importation d’un projet dans le GDS.
• directement dans l’administrateur du GDS.
Nous allons créer notre base de sources lors de l’importation d’un projet dans le GDS, à la
prochaine étape.
Il est conseillé de faire régulièrement des sauvegardes de la base de sources

Notes
du GDS. Pour cela, il suffit de se connecter en tant qu’administrateur à l’outil

d’administration du GDS et de sélectionner l’option "Outils .. Administration ..
Sauvegarde complète de la base".
Intégration d’un projet dans le GDS
Ajouter le projet dans le GDS

Pour utiliser un projet existant avec le gestionnaire de sources, il suffit d’intégrer ce projet dans la
base de sources du GDS.
Corrigé
Nous allons intégrer le projet "WD Application Complète.WDP" dans la base de sources du
GDS :
1. Sous le volet "GDS", dans le groupe "Projet", cliquez sur "Ajouter le projet". L’assistant d’ajout
de projet dans le GDS se lance :
Nous n’avons pas précédemment créé de base de sources. Nous allons donc en créer une.
Remarque : Nous allons créer une base de sources "locale" (sur le poste de développement). Le
fonctionnement serait similaire pour une base de sources réseau.
2. Cliquez sur le bouton "Créer une base".
3. L’écran permettant de créer la base s’affiche.
La base de sources peut être au format HFSQL Classic (local ou réseau) ou au format HFSQL
Client/Serveur. Nous allons créer une base de sources au format HFSQL Classic.
Notes
L’utilisation d’une base de sources au format HFSQL Client/Serveur permet

d’utiliser cette base de sources à distance.
4. Conservez l’option "Création d’une base en mode partage réseau" sélectionnée et indiquez
le répertoire de cette base de sources ("C:\Mes Projets\GDS Base de sources locale" par
exemple).
5. Validez la création de la base de sources (bouton "Créer la base").
6. La base de sources est à présent créée. Nous allons pouvoir intégrer notre projet dans
cette base de sources.
8. L’assistant nous propose de placer le projet dans le sous-répertoire "Projets WinDev" de la
base de sources.
Nous allons accepter cet emplacement. Passez à l’écran suivant.

9. L’assistant nous demande de sélectionner les différents éléments du projet à ajouter dans
la base de sources.
Nous voulons que tous les éléments du projet soient ajoutés. Passez à l’écran suivant.
10. L’assistant nous demande de sélectionner les différentes dépendances du projet à ajou-
ter dans la base de sources. Ces dépendances correspondent à tous les éléments externes
nécessaires au projet (images, feuilles de styles, ...).
Nous voulons que toutes les dépendances du projet soient ajoutées. Passez à l’écran suivant.
11. Validez l’intégration du projet dans le GDS. Notre projet et tous ses éléments sont désor-
mais ajoutés dans notre base de sources.
Une fenêtre d’aide sur la barre d’outils d’utilisation du GDS s’affiche. Lisez et validez cette
fenêtre.
Partage d’éléments du projet

Lors de l’intégration dans le GDS de projets partageant les mêmes ressources
Notes
(la même analyse, les mêmes fenêtres, ...), les éléments concernés peuvent être
partagés entre les différents projets. Ainsi, le même élément n’est intégré qu’une
seule fois dans le GDS.
Ouverture du projet depuis le GDS

Dans notre exemple, le projet est intégré au GDS et vous pouvez le manipuler directement.
Dans un cas réel, pour que d’autres développeurs travaillent sur un projet présent dans le ges-
tionnaire de sources, ils doivent récupérer, en local, une copie de ce projet.
Pour cela, les manipulations à faire sont les suivantes :
1. Ouvrir le projet depuis le gestionnaire de sources : sous le volet "Accueil", dans le groupe "Gé-
néral", dérouler "Ouvrir" et sélectionner "Ouvrir un projet depuis le GDS".
2. Indiquer le répertoire de localisation de la base et valider (cette étape est nécessaire uni-
quement si le projet en cours sous l’éditeur n’appartient pas au GDS) :
3. Dans l’écran qui s’affiche, indiquer si nécessaire la connexion et le répertoire local :
Remarque : Si vous avez déjà ouvert le projet depuis le GDS, le GDS vous propose d’ouvrir le pro-
jet normalement ou d’écraser le contenu (pour récupérer le projet complet).
Cette opération doit être effectuée une seule fois par chaque développeur utilisant le projet.
Le développeur qui a ajouté le projet dans le gestionnaire de sources (dans ce cas, c’est vous !)
n’a aucune manipulation à effectuer.
Les prochaines ouvertures d’un projet géré par le GDS sont identiques aux ouver-
Notes
tures d’un projet non géré par le GDS : il suffit d’ouvrir le projet (fichier ".WDP")
correspondant à la copie locale.
Configuration du GDS
Avant de commencer à travailler sur les éléments du projet présent dans le GDS, il est important
de configurer le GDS.
Les points importants de cette configuration concernent :
• le mode d’extraction des éléments du projet.
• le mode d’extraction du projet (fichier WDP).
Mode d’extraction des éléments du projet
Lors du travail sur des éléments d’un projet présent dans le GDS, il est nécessaire d’extraire l’élé-
ment de la base de source avant de commencer à le modifier, puis de le réintégrer une fois les
modifications effectuées. L’élément modifié est ainsi disponible pour tous les utilisateurs du GDS.
WinDev propose deux modes d’extraction des éléments du projet :
• le mode classique : si vous affichez un élément du GDS non extrait, un panneau indique que
cet élément doit être extrait pour être modifié. Vous pouvez extraire immédiatement l’élément
(bouton d’extraction présent dans le panneau).
• le mode automatique : si vous tentez de modifier un élément du GDS non extrait, le GDS pro-
pose automatiquement d’extraire cet élément. Après la validation de l’extraction, l’élément peut
être modifié.
Remarque : ce mode est déconseillé lors d’une utilisation du GDS avec une connexion Internet
lente.
Dans ce cours, nous allons utiliser l’extraction automatique.
Pour vérifier que l’extraction automatique est bien activée, sous le volet "Accueil", dans le
groupe "Environnement", déroulez "Options" et sélectionnez l’option "Options générales de
WinDev". Dans l’onglet "Général", vérifiez que l’option "Extraction des éléments à la première
modification" est sélectionnée. Si ce n’est pas le cas, activez cette option.
Mode d’extraction du projet
Le fichier Projet (fichier WDP) contient les différentes options pour le paramétrage du projet (code
d’initialisation du projet, liste des éléments reliés, nom de la première fenêtre du projet, ...).
WinDev propose deux modes de gestion du projet :
• Mode Maître/Invité : Seul le maître peut modifier le projet et reporter ces modifications dans
la base de sources du GDS. Le maître peut également réintégrer tous les éléments pour créer
l’exécutable et le programme d’installation. Les modifications réalisées par les invités sur le pro-
jet ne seront pas prises en compte dans la base de source du GDS.
Notes
Le mode Maître/Invité est conseillé pour une utilisation du GDS par un seul déve-
loppeur.
• Mode automatique : Le fichier projet est extrait uniquement si l’action réalisée le nécessite
(quel que soit l’utilisateur). Lorsque l’action sur le projet a été effectuée, le fichier projet est
automatiquement réintégré.
Notes
Le mode "Automatique" devient vite nécessaire pour des projets importants par-
tagés par plusieurs développeurs.
Dans ce cours, nous allons utiliser l’extraction automatique.

Pour vérifier que l’extraction automatique du projet est bien activée, sous le volet "GDS", dans
le groupe "Projet", déroulez "Maître / Invité" et vérifiez que l’option "Gérer automatiquement
l’extraction du projet" est bien cochée.
Manipulation du projet via le GDS
Nous allons maintenant commencer à travailler avec le GDS en conditions réelles en réalisant les
manipulations suivantes :
• Modifier un paramètre du projet.
• Modifier une fenêtre du projet.
Modification d’un paramètre du projet
Nous allons modifier le projet en demandant à afficher le gabarit sur les fenêtres système :
"Description".
2. Cliquez sur l’onglet "Style".
3. Cochez l’option "Appliquer le thème de gabarit sur les fenêtres système".
4. Validez la fenêtre de description du projet.
Plusieurs fenêtres du GDS apparaissent :
1. Tout d’abord, la fenêtre d’extraction automatique du projet s’affiche. En effet, nous modifions
une caractéristique du projet, il est nécessaire d’extraire le projet.
2. Validez cette fenêtre.
3. Une nouvelle fenêtre apparaît. Cette fenêtre permet d’ajouter des éléments et leurs dépen-
dances dans le projet présent dans la base du GDS. En effet, l’option que nous avons sélec-
tionnée ajoute plusieurs fenêtres dans le projet :

5. Une nouvelle fenêtre d’ajout de fenêtre apparaît : validez à nouveau.
6. Une fenêtre de réintégration du projet apparaît. En effet, les modifications du projet ayant
été effectuées, le projet est réintégré :
Modification d’une fenêtre du projet

Nous allons maintenant modifier la fenêtre "FEN_Fiche_du_produit" : le clic sur l’image doit per-
mettre de modifier l’image (comme le bouton "Modifier").
Pour modifier un élément du projet, il est nécessaire de l’extraire.
Pour modifier la fenêtre "FEN_Fiche_du_produit" :
1. Sélectionnez la fenêtre "FEN_Fiche_du_produit" dans l’explorateur du projet et double-cli-
quez sur l’élément pour l’ouvrir sous l’éditeur de fenêtres.
Si l’option "Extraction des éléments à la première modification" n’est pas sélec-

tionnée dans les options de WinDev, un bandeau orange apparaît indiquant que
l’élément n’est pas extrait du GDS.
Notes
2. La fenêtre d’extraction apparaît :
3. Le GDS propose trois modes d’extraction :

• Exclusif (mode conseillé) : personne ne pourra extraire cet élément jusqu’à sa réintégration.
L’élément pourra uniquement être extrait pour test.
• Pour test : l’élément pourra être modifié mais les modifications ne pourront pas être réinté-
grées.
• Multiple : l’élément pourra également être extrait par d’autres utilisateurs. Dans ce cas, lors
de la réintégration, il sera possible de visualiser les différences entre les différentes ver-
sions de l’élément. Ce mode est réservé à des cas d’utilisations spécifiques et à des déve-
loppeurs avancés.
4. Nous allons extraire la fenêtre en mode exclusif. Conservez l’option "Exclusif" cochée.
5. Saisissez un commentaire ("Modification de l’image" par exemple). Ce commentaire sera
utile pour les autres développeurs.
6. Validez l’extraction.
La fenêtre est extraite.
Modification de l’élément extrait

La modification d’un élément extrait (IHM, code, ...) s’effectue comme sur un projet non géré par
le GDS.
Cependant, toutes les modifications effectuées sur un élément extrait ne sont pas visibles par les
autres développeurs.
Si un autre développeur exécute l’élément extrait, l’élément qui est actuellement dans la base de
sources sera utilisé.
Il est ainsi possible de faire évoluer une application tout en gardant une version stable dans la
base de sources.
Modifiez la fenêtre extraite :
1. Affichez la fenêtre de description du champ Image (option "Description" du menu contextuel).
2. Dans l’onglet "IHM", modifiez le curseur utilisé : sélectionnez le curseur "Main système".
4. Affichez le code du champ Image : sélectionnez le champ Image et utilisez par exemple la
touche [F2].
5. Saisissez le code suivant dans le traitement "Clic sur ..." :
// Exécute le code de clic du bouton qui modifie l’image

ExécuteTraitement(BTN_Modifier, trtClic)

7. Enregistrez votre fenêtre (CTRL + S).
Testez vos modifications.
2. Sélectionnez un produit et cliquez sur "Modifier".
3. Dans la fiche qui apparaît, cliquez sur l’image du produit : le sélecteur de fichier s’ouvre
pour modifier l’image du produit. C’est bien le fonctionnement attendu.
Réintégration de l’élément extrait

Maintenant que les modifications sont terminées et testées, nous allons réintégrer la fenêtre dans
la base de sources. Vos modifications seront alors accessibles aux autres développeurs.
Sous le volet "GDS", dans le groupe "Elément en cours", cliquez sur le bouton "Réintégrer".
L’écran suivant s’affiche :
Cet écran permet de :
• connaître les modifications effectuées en comparant l’élément de la base de sources avec
l’élément extrait (bouton "Mes Modifs").
Fusion de code
Notes
Vous pouvez comparer un élément avec une de ses versions précé-
dentes. Il est alors possible de comparer le code pour récupérer un code
"perdu" ou supprimé par erreur par un autre développeur par exemple.
• accéder à l’historique de l’élément dans la base de sources (bouton "Propriétés").

• saisir un commentaire sur les modifications réalisées. Par défaut, WinDev propose le com-
mentaire saisi lors de l’extraction.
• envoyer un message aux autres développeurs.
• réintégrer les modifications effectuées dans l’élément, tout en conservant l’élément extrait
(option "Garder l’élément extrait").
Si vous utilisez les Centres de Contrôle, il est également possible de terminer

Notes
la tâche en cours lors de la réintégration de l’élément dans le Gestionnaire

de sources. Cette fonctionnalité est utile notamment pour assurer le suivi des
tâches, des corrections de bugs, ...
5. Validez la réintégration.
6. La fenêtre apparaît alors sous l’éditeur, avec le bandeau orange indiquant que l’élément
n’est pas extrait.
Synchronisation du projet
Plusieurs options permettent de configurer un projet manipulé avec le GDS. Ces options sont re-
groupées dans l’onglet "GDS" de la description du projet (affichée par un clic sur "Description"
sous le volet "Projet").
Ces options sont les suivantes :
• Proposer la récupération de la dernière version des éléments à l’ouverture du projet.
Cette option permet lors de l’ouverture d’un projet présent dans le GDS, de proposer la
récupération de la dernière version des différents éléments du projet.
Par défaut, la dernière version des éléments est automatiquement récupérée.
• Proposer la réintégration des éléments à la fermeture du projet.
Cette option permet d’afficher lors de la fermeture du projet la liste de tous les éléments
actuellement extraits, afin de réintégrer certains ou tous ces éléments.
Par défaut, à la fermeture du projet, les éléments extraits ne sont pas réintégrés.
• Extraire/Réintégrer automatiquement le projet.
Cette option permet d’extraire ou de réintégrer automatiquement le projet lors de la
manipulation d’un élément.
Par défaut, cette option est sélectionnée.
Mode déconnecté (ou nomade)

Le GDS permet très simplement de travailler en mode déconnecté ou nomade.
Ce mode permet par exemple à un développeur utilisant un portable de continuer à travailler sur
un projet présent dans la base de sources tout en étant déconnecté.
Le principe est simple :
• avant la déconnexion, sous le volet "GDS", dans le groupe "Autres actions", déroulez "Travail
à distance" et sélectionnez l’option "Se déconnecter pour une utilisation nomade".
• à la reconnexion, sous le volet "GDS", dans le groupe "Autres actions", déroulez "Travail à
distance" et sélectionnez l’option "Se reconnecter et synchroniser". Il suffit alors de réinté-
grer les éléments modifiés.
En mode nomade, deux solutions s’offrent à vous concernant l’extraction d’éléments :
• Vous ne faites aucune extraction d’élément du GDS. Ainsi, pendant toute votre période no-
made, d’autres développeurs pourront travailler sur le ou les mêmes éléments que vous. À
votre retour et à votre reconnexion au GDS, il sera nécessaire de faire des fusions entre vos
propres modifications sur l’élément et celles effectuées par d’autres développeurs.
• Vous faites une extraction exclusive sur le ou les éléments que vous allez modifier. Vous
vous réservez ainsi l’élément pendant toute votre période nomade.
Administrateur du GDS
L’administrateur du GDS permet de manipuler directement les différents projets inclus dans le
gestionnaire de sources.
Il permet par exemple de :
• gérer les bases de sources (création, connexion à une base de sources).
• gérer les fichiers et les répertoires présents dans un projet de la base de sources (ajouter,
supprimer, renommer, … des fichiers et des répertoires).
• gérer les différents fichiers de la base de sources (extraction, réintégration, partage, …).
• lancer certains outils (options, maintenances, …).
• visualiser l’historique d’un élément.
• visualiser l’état des éléments.
• réaliser des sauvegardes.
• donner des droits aux différents utilisateurs du GDS.
• lister les projets auxquels on participe afin de pouvoir s’en dissocier (si besoin).
Lancez l’administrateur du GDS : sous le volet "GDS", dans le groupe "Base GDS", cliquez sur
le bouton "Gérer". Tous les éléments du projet sont listés dans l’administrateur.
Pour plus de renseignements sur le GDS, consultez l’aide en ligne de WinDev (mot-clé : "GDS").
Déconnexion du GDS
Dans la suite de ce cours, nous allons à nouveau manipuler l’application "WD Application Com-
plète". Pour simplifier les manipulations, nous vous conseillons de vous déconnecter du GDS :
1. Affichez la fenêtre de description du projet : sous le volet "Projet", dans le groupe "Projet", cli-
quez sur "Description".
2. Dans l’onglet "GDS", sélectionnez l’option "Pas de groupware développeur ni de GDS".
3. Validez la fenêtre de description du projet.
Conclusion
Nous avons vu toutes les principales phases du développement d’une application.
WinDev propose également différents outils pour optimiser vos applications. Pour plus de détails,
consultez la leçon "Audits du projet", page 381.
PARTIE 4
Administrer une
base HFSQL
Client/Serveur
358 Partie 4 : Administrer une base HFSQL Client/Serveur (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite
Leçon 4.1. Introduction
• Principe du Client/Serveur
• Pourquoi passer une application en HFSQL Client/Serveur ?
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Partie 4 : Administrer une base HFSQL Client/Serveur 359
Présentation
WinDev permet de créer des applications accédant à des bases de données HFSQL Client/Ser-
veur.
Une application HFSQL Client/Serveur consiste à exécuter l’application sur différents postes utili-
sateur (appelés machines clientes) et à déporter la ou les bases de données et les traitements
sur un poste serveur. Ce mode de fonctionnement permet des temps de réponses plus rapides et
plus fiables, ainsi qu’une maintenance de la base de données facilitée.
WinDev permet de :
• créer entièrement une application HFSQL Client/Serveur.
• modifier une application WinDev existante en une application HFSQL Client/Serveur.
Pourquoi passer une application en mode HFSQL Client/
Serveur ?
Les principaux avantages d’une application en mode HFSQL Client/Serveur par rapport à une
application en mode HFSQL Classic sont les suivants :
• L’utilisation de HFSQL Client/Serveur est plus sécurisée (utilisation d’un login, d’un mot de
passe et définitions de droits associés aux utilisateurs).
• Pas de gestion de répertoires : tous les fichiers de la base de données sont regroupés au même
endroit.
• Les clients finaux ne voient pas les fichiers de données dans leur explorateur et ne peuvent pas
y accéder directement.
• Les bases de données en mode Client/Serveur peuvent être utilisées par une connexion Inter-
net.
Leçon 4.2. Mise en place d’une
application Client/Serveur
• Installation d’un serveur HFSQL local

• Création d’une application en mode Client/Serveur
• Adaptation d’une application pour gérer le mode Client/Serveur
• Fonctionnalités disponibles en mode Client/Serveur
Présentation
Dans cette leçon, nous allons effectuer toutes les opérations nécessaires au développement et
au déploiement d’une application HFSQL Client/Serveur.
Installation d’un serveur HFSQL local

La première opération à faire avant de commencer à développer une application HFSQL Client/
Serveur consiste à installer un serveur HFSQL.
Sur le poste de développement, ce serveur peut être installé en local (c’est ce que nous allons
faire). En déploiement, ce serveur peut être installé sur un poste spécifique.
Le programme d’installation du serveur HFSQL est disponible sur le CD de WinDev. Si vous ne
possédez pas ce CD, l’installation du serveur HFSQL est également disponible sur le site de PC
SOFT (www.pcsoft.fr).
Pour installer le serveur HFSQL en local :
1. Lancez le programme d’installation de WinDev.
2. Choisissez l’option "Installation du Serveur HFSQL C/S".
3. Sélectionnez ensuite l’option "Installer un serveur HFSQL Client/Serveur".
4. Acceptez la licence.
5. Choisissez la plate-forme (option "Pour Windows sur cette machine").
6. Choisissez l’option "Installer un nouveau serveur".
7. Sélectionnez le répertoire d’installation et indiquez le nom du serveur et le port. Par défaut,
le port utilisé est 4900. Vous pouvez installer le Centre de Contrôle HFSQL si celui-ci n’est pas
présent ou accessible depuis votre poste.
Attention !
Le Centre de Contrôle HFSQL est nécessaire à la gestion de la base HFSQL

Client/Serveur.
8. L’installation est effectuée. Par défaut, pour se connecter au serveur en mode administra-
teur, il faut utiliser l’utilisateur "admin" sans mot de passe.
Création d’une application en mode HFSQL Client/Serveur

La création d’une application WinDev HFSQL Client/Serveur se fait de la même manière que pour
toute application WinDev.
Il est nécessaire de :
1. Créer le projet en demandant à créer une nouvelle base de données.
2. Créer l’analyse en spécifiant que les bases de données utilisées par le projet seront de type
"HFSQL Client/Serveur".
3. Indiquer les caractéristiques de la connexion au serveur HFSQL Client/Serveur à utiliser.
4. Lors de la création d’un fichier sous l’analyse, indiquer que ce fichier est en mode Client/
Serveur et préciser la connexion utilisée.
Adaptation d’une application HFSQL Classic pour gérer le
mode Client/Serveur
Présentation
La migration d’une application HFSQL Classic en mode Client/Serveur est l’opération la plus cou-
rante.
WinDev propose plusieurs solutions pour réaliser cette migration sur le poste de développement :
• réaliser la migration depuis l’éditeur d’analyses.
• réaliser la migration depuis le Centre de Contrôle HFSQL.
Pour mieux se rendre compte des différentes étapes, nous allons migrer l’application que nous
avons réalisée dans la partie 3 de ce livre, en utilisant la première méthode.
Migration de l’exemple
Corrigé
Pour migrer le projet :

2. Chargez l’analyse de votre projet sous l’éditeur d’analyses : cliquez sur parmi les bou-
tons d’accès rapide du menu de WinDev. L’éditeur d’analyses s’affiche.
3. Sous le volet "Analyse", dans le groupe "Connexion", cliquez sur "Nouvelle connexion". Un
assistant s’ouvre, permettant de créer une connexion.
4. Sélectionnez le type de connexion à créer : "HFSQL Client/Serveur". Passez à l’écran sui-
vant.
5. Indiquez le nom de la connexion (conservez le nom proposé). Passez à l’écran suivant.
6. Indiquez dans les plans suivants :
• le nom du serveur (nom de votre machine par exemple) et le numéro de port,

• le nom de l’utilisateur et son mot de passe (laissez ces informations vides pour utiliser l’ad-
ministrateur),
• le nom de la base de données ("WD Application Complète" dans notre exemple).
7. Passez à l’écran suivant et validez. La connexion à la base est automatiquement créée.
L’assistant propose d’associer les différents fichiers de données présents dans l’analyse à la
connexion qui vient d’être créée.
8. Cliquez sur "Oui".
9. Dans l’écran suivant, sélectionnez tous les fichiers proposés :

10. L’assistant propose ensuite de copier les fichiers de données sur le serveur. Validez (op-
tion "Copier maintenant").
11. Sélectionnez les fichiers de données de l’analyse à copier sur le serveur : dans notre cas,
ce sont tous les fichiers de données du répertoire EXE. Passez à l’écran suivant et validez.
12. Les fichiers de données de l’analyse sont automatiquement transformés en fichiers de
données HFSQL Client/Serveur et associés à la connexion choisie.
13. Générez l’analyse : sous le volet "Analyse", dans le groupe "Analyse", cliquez sur "Généra-
tion". Une modification automatique des fichiers de données est automatiquement effectuée.
Si tous les fichiers de données sont à jour, vous pouvez annuler la modification automatique
des fichiers de données.
Passage en mode Client/Serveur : quelques conseils
• Vérifiez le code de votre projet : en mode HFSQL Client/Serveur, les instruc-
tions HSubstRep, HChangeRep, ... sont inutiles
• Selon les paramètres indiqués lors de la création de la connexion, il est pos-
Notes
sible de modifier la connexion définie dans l’analyse grâce aux fonctions

HOuvreConnexion et HChangeConnexion.
• La fonction HOuvreConnexion permet toujours de repasser en mode HFSQL
Classic : il suffit de lui préciser le chemin du répertoire contenant les fichiers
de données HFSQL Classic.
14. Vous avez migré le projet de développement. Il peut être également nécessaire de migrer
l’application déployée (par exemple si l’application déployée utilise des fichiers HFSQL Clas-
sic). Cette opération se paramètre lors de la création du programme d’installation de l’appli-
cation.
Fonctionnalités disponibles en mode HFSQL Client/Serveur

HFSQL Client/Serveur propose de nombreuses fonctionnalités :
• Transactions,
• Journaux,
• Procédures stockées,
• Triggers,
• Modification automatique des données à chaud,
• Réindexation à chaud,
• Sauvegardes planifiées,
• Sauvegardes incrémentielles,
• Réplication multi-sites.
Nous ne détaillerons pas ici ces fonctionnalités (certaines ont été abordées dans ce cours en
mode HFSQL Classic). Nous vous conseillons de consulter l’aide en ligne pour plus de détails sur
ces sujets.
Leçon 4.3. Administrer une base de
données Client/Serveur
• Le Centre de Contrôle HFSQL

• Créer un utilisateur dans le Centre de Contrôle HFSQL
• Sauvegarder la base de données
Présentation
Maintenant que nous savons créer/migrer une application en mode HFSQL Client/Serveur, nous
allons voir comment administrer la base de données associée.
En effet, une base de données Client/Serveur nécessite :
• une configuration spécifique des postes (installation d’un serveur HFSQL, ...)
• une administration réalisée grâce au Centre de Contrôle HFSQL.
Configuration des postes

Pour utiliser une base HFSQL Client/Serveur, il est nécessaire d’installer un serveur HFSQL sur le
poste serveur. Il est possible d’utiliser plusieurs serveurs HFSQL sur le même poste, utilisant des
ports différents. Sur chaque serveur, une ou plusieurs bases de données peuvent être installées.
Par exemple, il est possible d’installer sur le même poste un serveur HFSQL de tests, avec une
base de données de tests et un serveur HFSQL de production, utilisant un port différent.
Le Centre de Contrôle HFSQL

Le Centre de Contrôle HFSQL permet de réaliser toutes les opérations d’administration des ser-
veurs et des bases de données HFSQL Client/Serveur.
Nous allons voir les fonctionnalités les plus importantes.
Pour lancer le Centre de Contrôle HFSQL et accéder aux données :
1. Dans le menu de WinDev, sous le volet "Outils", dans le groupe "Base de données", cliquez
sur "HFSQL". Le Centre de Contrôle HFSQL apparaît.
2. La fenêtre de bienvenue dans le Centre de Contrôle HFSQL s’affiche. L’analyse du projet en
cours est automatiquement sélectionnée.
3. Validez l’écran. Le Centre de Contrôle HFSQL apparaît.
4. Cliquez sur l’option "Fichier HFSQL Client/Serveur". La liste des fichiers de données au for-
mat HFSQL Client/Serveur s’affiche.
Le Centre de Contrôle liste ici les fichiers de données trouvés dans l’analyse liée au projet en
cours. Aucune connexion n’est réalisée.
5. Pour visualiser les données des fichiers, double-cliquez sur un des fichiers de données
dans la liste à gauche. Le Centre de Contrôle HFSQL affiche alors une fenêtre de connexion
permettant de réaliser la connexion effective au serveur HFSQL Client/Serveur utilisé.
Indiquez si nécessaire le mot de passe et validez.

6. Les différentes informations sur les différents fichiers de données utilisant cette connexion
sont affichées.
• L’onglet "Contenu" affiche les enregistrements contenus dans les fichiers de données.
• L’onglet "Description" présente les informations sur les fichiers de données (rubriques du fi-
chier, ...).
Depuis le Centre de Contrôle HFSQL, il est possible d’administrer toute la base de données
HFSQL Client/Serveur.
Créer un compte utilisateur dans le Centre de Contrôle
HFSQL
Nous avons vu que lors de l’installation d’un serveur HFSQL et lors de la création d’une base de
données, un seul compte utilisateur est créé : le compte de l’administrateur (login "Admin" sans
mot de passe).
L’utilisation de compte utilisateur permet de sécuriser l’accès aux données. En effet, tous les
utilisateurs de l’application ne sont pas des administrateurs. A chaque utilisateur (ou groupe d’uti-
lisateurs), il est possible d’associer des droits.
Les droits des utilisateurs spécifiés dans le Centre de Contrôle HFSQL sont des
Attention !
droits de base de données et pas des droits d’application.

Il ne faut pas confondre la gestion des droits des bases de données Client/Ser-
veur avec le groupware utilisateur.
Certains utilisateurs peuvent par exemple ne pas avoir le droit d’écrire dans certains fichiers.
Pour faire un test simple, nous allons créer un utilisateur et lui permettre de consulter les enregis-
trements du fichier Client.
1. Dans le Centre de Contrôle HFSQL, cliquez sur l’icône et validez si nécessaire la fer-
meture des connexions.
2. La fenêtre de bienvenue dans le Centre de Contrôle HFSQL s’affiche.
3. L’option "Se connecter à un serveur HFSQL" est sélectionnée par défaut. Indiquez les carac-
téristiques du serveur installé dans la leçon précédente.
4. Les caractéristiques du serveur HFSQL sont affichées :
• dans le panneau de gauche, le poste, le nom du serveur HFSQL ainsi que la liste des bases
présentes sur ce serveur.
• dans la partie droite de l’écran, les différents onglets permettant de gérer le serveur HFSQL.
5. Dans la partie droite de l’écran, sélectionnez l’onglet "Utilisateurs et Groupes". Cet onglet
permet de gérer les utilisateurs du serveur.
6. Seul pour le moment l’utilisateur "Admin" est présent.
7. Pour créer un nouvel utilisateur, cliquez sur le bouton "Nouveau" (sous la liste des utilisa-
teurs). L’écran permettant de définir les caractéristiques de l’utilisateur apparaît.
8. Saisissez par exemple les informations suivantes :
(utilisez par exemple "Test" également comme mot de passe).
Plusieurs caractéristiques peuvent être notées :

• Super Utilisateur : Les utilisateurs désignés comme "Super utilisateur" sont
autorisés à effectuer toutes les actions sur le serveur, les bases de données et
sur tous les fichiers.
Notes
• Compte actif : Si cette option n’est pas cochée, l’utilisateur existe mais n’est
pas actif (cas des utilisateurs en congés par exemple).
• Expiration du mot de passe : Il est possible d’avoir un mot de passe valide pour
quelques jours.
9. Validez la création de l’utilisateur. Par défaut, cet utilisateur n’a aucun droit.
Nous allons maintenant attribuer des droits à l’utilisateur : l’utilisateur "Test" peut se connecter à
la base de données et consulter le fichier Client.
Pour donner le droit de connexion à la base de données :
1. Dans le Centre de Contrôle HFSQL, sélectionnez la base de données "WD Application Com-
plète".
2. Cliquez sur l’onglet "Droits".
3. Sélectionnez l’utilisateur "Test" dans la liste des utilisateurs.
4. Dans la liste des droits, sélectionnez "Droit de se connecter au serveur" (connexion cryptée
et non cryptée). Sélectionnez la coche verte dans la colonne "Droit défini".
5. Cliquez sur le bouton "Appliquer" présent à droite de la liste des droits. Le droit devient ef-
fectif.
Pour donner le droit de lire le fichier Client :
1. Dans le Centre de Contrôle HFSQL, sélectionnez la base de données "WD Application Com-
plète", puis sélectionnez le fichier Client.
2. Cliquez sur l’onglet "Droits".
3. Sélectionnez l’utilisateur "Test" dans la liste des utilisateurs.
4. Dans la liste des droits, sélectionnez "Droit de lire les enregistrements d’un fichier" et sélec-
tionnez la coche verte dans la colonne "Droit défini".
5. Cliquez sur le bouton "Appliquer" présent à droite de la liste des droits. Le droit devient ef-
fectif.
De cette façon, il est possible de définir des droits :
• sur le serveur HFSQL
• sur la base de données
• sur les fichiers de la base de données.
Dans notre exemple, l’utilisateur "Test" pourra uniquement parcourir les enregistrements du fi-
chier Client. Si cet utilisateur tente une autre action, un message s’affichera : "L’utilisateur Test
n’a pas les droits suffisants pour XXXX" (où XXXX correspond à l’action effectuée).
Une fois le compte créé, il peut être utilisé lors de la connexion de l’application au serveur (quand
la fonction HOuvreConnexion est utilisée).
La gestion des utilisateurs et de leurs droits peut également être effectuée par
Notes
programmation grâce aux fonctions WLangage. Pour plus de détails, consultez

l’aide en ligne.
Sauvegarder la base de données

La sauvegarde de la base de données peut être réalisée directement grâce à l’onglet "Sauve-
gardes". Cet onglet est disponible lors de la sélection de la base de données dans le volet gauche
du Centre de Contrôle HFSQL.
Conclusion
Le Centre de Contrôle HFSQL est un outil complet d’administration de base de données, permet-
tant entre autres :
• d’arrêter ou de redémarrer un serveur en cas de problème,
• de gérer les utilisateurs et leurs droits,
• de réindexer les fichiers de données si nécessaire,
• de faire des sauvegardes de la base.
Le Centre de Contrôle HFSQL est un outil redistribuable qui peut être installé chez les clients
possédant des bases de données HFSQL Client/Serveur. Le Centre de Contrôle HFSQL doit être
utilisé par la personne administrant la base de données.
Leçon 4.4. Installation en clientèle
• Comment installer une application Client/Serveur en clientèle ?
Présentation
L’installation d’une application Client/Serveur nécessite plusieurs options spécifiques. Ces op-
tions sont prises en charge par l’assistant de création d’installation de WinDev.
Nous allons créer la procédure d’installation de notre application "WD Application Complète".
Lancement de l’assistant de création d’installation

Pour lancer la procédure d’installation d’une application HFSQL Client/Serveur :
1. Sous le volet "Projet", dans le groupe "Génération", cliquez sur "Procédure d’installation".
2. Créez l’exécutable et validez la création de l’aide.
3. Allez jusqu’à l’écran "Paramètres des bases de données". Dans ce plan, il est possible de :
• Intégrer l’installation d’un serveur HFSQL,
• Paramétrer les connexions HFSQL Client/Serveur,
• Déployer les fichiers HFSQL Client/Serveur.
Si ces options sont cochées, les écrans suivants permettent de paramétrer les différents
éléments à prendre en compte pour l’installation en clientèle.
Pour plus de détails, consultez l’aide en ligne.
PARTIE 5
Optimiser et
déboguer un
projet
382 Partie 5 : Optimiser et déboguer un projet (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite
• Pourquoi optimiser une application

• Projet exemple
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Partie 5 : Optimiser et déboguer un projet 383
Présentation
Votre application est terminée. Elle fonctionne, vous avez créé différents tests automatiques pour
éviter les régressions. Vous voulez la déployer chez vos clients.
Avez-vous pensé à utiliser les outils de WinDev pour optimiser votre application ? WinDev propose
une série d’outils et de fonctionnalités permettant d’optimiser rapidement votre application et
d’éviter simplement des "bugs" grossiers.
Cette partie présente en détail ces outils et leur utilisation.
Pour mieux manipuler ces fonctionnalités, nous avons préparé un projet à optimiser !
Ouverture du projet
Lancez WinDev 19 (si ce n’est déjà fait). Si nécessaire, fermez le projet en cours pour faire
apparaître la fenêtre de bienvenue.
Ouvrez le projet "WD Optimisation".
"Optimiser un projet".
"Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez l’option "Optimiser un
projet".
Leçon 5.2. Audits du projet
• Qu’est-ce qu’un audit et à quoi ça sert ?

• Lancer et analyser l’audit statique
• Lancer et analyser l’audit dynamique
Qu’est-ce qu’un audit ?
Les audits apportent une série de fonctionnalités permettant d’améliorer automatiquement la
qualité et les performances d’un projet et de suivre plus précisément ses conditions de mise en
exploitation.
Les principaux audits sont les suivants :

• L’audit statique. L’audit statique consiste en une analyse détaillée d’un projet et de ses élé-
ments. Cet audit est effectué directement depuis l’éditeur de projet.
• L’audit dynamique. L’audit dynamique est une analyse du comportement d’un projet pendant
son exécution. Cet audit peut être réalisé en mode test ou directement dans l’environnement de
production.
Nous allons tout de suite tester ces audits sur le projet "WD Optimisation".
Audit statique
L’audit statique est une fonctionnalité de l’environnement permettant d’analyser les éléments
d’un projet pour détecter différents problèmes et proposer des améliorations.
L’audit statique se compose de :
• L’audit statique du projet
• L’audit du contenu de la bibliothèque de l’application
• L’audit du contenu de l’installation
Pour lancer l’audit statique sur le projet "WD Optimisation" :
1. Sous le volet "Projet", dans le groupe "Audit et performances", déroulez "Audit d’édition" et
sélectionnez "Déclencher l’audit d’édition".
L’audit statique du projet peut également être lancé depuis le Tableau de bord
du projet, via le Widget "Audit statique et Compilation".
Il suffit de cliquer sur le bouton fléché.
Notes
3. L’assistant se lance pour définir la cible de l’audit statique.
4. Sélectionnez l’option "Lancer l’audit statique sur le projet complet" et validez l’assistant.
5. Le rapport d’audit est affiché :
Examinons avec attention les points présentés par ce rapport.
Procédure non exécutée
Dans notre projet, une procédure n’est jamais exécutée.
Il arrive fréquemment dans des projets importants, de créer une ou plusieurs procédures pour
réaliser un traitement, puis suite à une réorganisation du code, la procédure n’est plus utilisée
mais reste dans le projet.
La présence de procédures non utilisées alourdit inutilement les ressources distribuées aux utili-
sateurs finaux.
Pour traiter ce problème :
1. Cliquez sur le bouton [...] pour obtenir plus de renseignements. La fenêtre listant les codes
morts apparaît.
2. La procédure "ProcédureObsolète" n’est jamais appelée. Cette fenêtre permet de :

• spécifier que la procédure est tout de même utilisée (bouton "Marquer comme utilisé").
Dans ce cas, la procédure ne sera plus prise en compte lors de l’audit.
• voir la procédure (bouton "Voir").
• supprimer la procédure si elle est réellement inutilisée.
3. Dans notre cas, cette procédure est réellement inutilisée, cliquez sur "Supprimer".
4. Une fenêtre s’affiche demandant la confirmation de la suppression. Confirmez la suppres-
sion en cliquant sur le bouton "Supprimer".
5. Fermez la fenêtre du code mort (utilisez la croix en haut à droite).
Dans la fenêtre de l’audit statique, cliquez sur le bouton "Rafraîchir" pour mettre à jour le
rapport d’audit.
Elément orphelin
Notre projet contient un élément orphelin.
Comme pour les procédures exécutées, il arrive fréquemment de créer des fenêtres, des états
afin d’effectuer un test rapide, de les enregistrer et de les oublier ... La présence d’éléments
orphelins dans l’exécutable alourdit inutilement les ressources distribuées aux utilisateurs finaux.
1. Cliquez sur le bouton [...] pour obtenir plus de renseignements. La fenêtre listant les élé-
ments orphelins apparaît.
2. La fenêtre "FEN_FenêtreInutilisée" n’est jamais appelée. La fenêtre listant les éléments or-
phelins permet de :
• spécifier que l’élément est tout de même utilisé (bouton "Marquer comme utilisé"). Dans ce
cas, la fenêtre de notre exemple ne sera plus prise en compte lors de l’audit. Cette option
peut être intéressante par exemple dans le cas d’une fenêtre de test spécifique au dévelop-
pement.
• voir l’élément (bouton "Voir").
• supprimer l’élément s’il est réellement inutilisé.
3. Dans notre cas, cette fenêtre "FEN_FenêtreInutilisée" est réellement inutilisée, cliquez sur
"Supprimer".
4. Fermez la fenêtre des éléments orphelins (utilisez la croix en haut à droite).
Dans la fenêtre de l’audit statique, cliquez sur le bouton "Rafraîchir" pour mettre à jour le
rapport d’audit.
Requête à optimiser
Notre projet contient une requête à optimiser. Cette optimisation permet d’améliorer la vitesse
d’exécution de la requête. L’optimisation d’une requête repose sur le principe suivant : un assis-
tant détermine les clés composées à modifier et/ou à ajouter dans l’analyse associée au projet.
1. Cliquez sur le bouton [...] pour obtenir plus de renseignements. La fenêtre listant les modifica-
tions à réaliser dans l’analyse apparaît.
2. L’assistant propose de modifier une rubrique de l’analyse en la transformant en une clé

avec doublons.
3. Nous allons appliquer le changement proposé : cliquez sur le bouton "Appliquer ces modifi-
cations dans l’analyse".
4. Une fenêtre s’affiche demandant la confirmation de la modification de l’analyse. Validez
cette fenêtre.
5. L’éditeur d’analyses est ouvert et la modification est effectuée. Un message indique que la
génération de l’analyse est nécessaire. Confirmez la génération de l’analyse en cliquant sur
"Oui".
6. L’application utilisant des données, une modification automatique des fichiers de données
est nécessaire. Validez les différents écrans de l’assistant de modification des données (en
conservant les options par défaut).
7. La fenêtre de l’audit statique est automatiquement rafraîchie.
Nettoyage du projet
Notre projet contient plusieurs fichiers inutilisés. Il est possible de nettoyer le projet pour ne
conserver que les éléments nécessaires.
1. Cliquez sur le bouton [...] pour obtenir plus de renseignements.
2. L’assistant de nettoyage de projet se lance. Cet assistant indique les fichiers inutilisés qui
peuvent être supprimés.
4. Indiquez le type de nettoyage à réaliser. Il est possible de :
• créer un fichier zip avec les fichiers inutiles.
• déplacer les fichiers inutiles dans un répertoire spécifique.
5. Validez l’option proposée par défaut et passez à l’écran suivant.
6. Terminez l’assistant.
Nous avons optimisé notre projet en suivant tous les conseils de l’audit statique. Maintenant,
voyons ce qui se passe en exécution en lançant l’audit dynamique.
Audit dynamique
L’audit dynamique d’une application permet d’analyser ses performances lors de l’exécution. Un
audit dynamique peut être effectué dans un environnement de test ou sur une application en pro-
duction. L’audit permettra de déceler des problèmes tels que :
• Consommation excessive de mémoire
• Lenteurs des algorithmes utilisés
• Erreurs "masquées" lors de l’exécution
• ...
Le projet "WD Optimisation" contient une fenêtre spécifique provoquant des erreurs pouvant être
détectées par l’audit dynamique.
Nous allons lancer l’audit dynamique en même temps que le test du projet.
Pour lancer l’audit dynamique sur le projet "WD Optimisation" :
1. Sous le volet "Projet", dans le groupe "Mode test", déroulez "Mode test" et sélectionnez "Débo-
guer le projet avec l’audit activé". Le test du projet se lance.
L’audit dynamique du projet peut également être lancé depuis le Tableau de
bord du projet, via le Widget "Exécution". Il suffit de dérouler le bouton fléché et
de sélectionner "Go minutieux du projet".
Notes
Remarque : A chaque lancement de l’application par un GO du projet, l’audit dy-

namique est automatiquement exécuté. Un compte-rendu est automatiquement
affiché dans le Tableau de bord :
3. Cliquez sur le bouton "Fenêtre de test de l’audit dynamique".

4. Cliquez sur les différents boutons présents dans la fenêtre. A la fin de chaque traitement,
un message sous forme de toast est affiché pour indiquer que le traitement est terminé.
5. Arrêtez le test de l’application.
6. La fenêtre de compte-rendu de l’audit dynamique s’affiche.
Examinons cette fenêtre :
• La partie haute de cette fenêtre permet de choisir le mode d’affichage des données. Il est
possible de :
• choisir un affichage chronologique (respectant l’ordre d’arrivée des événements) ou un affi-
chage synthétique, permettant de regrouper les différents types de problèmes. Dans ce cas,
la frise chronologique permet de voir la position et l’importance des problèmes.
• choisir le type de problème à afficher (erreur, assertion, ...). Il est ainsi par exemple possible
de se concentrer uniquement sur les erreurs graves, ...
• La partie basse de cette fenêtre affiche les différents événements survenus pouvant poser
problèmes dans l’application.
Dans cet exemple, l’audit dynamique détecte plusieurs problèmes :
• Un libellé trop long affecté par programmation,
• Une boucle de type SELON dont aucun CAS n’est exécuté,
• Une assertion déclenchée au lieu d’une exception,
• L’ouverture d’un fichier qui n’existe pas,
• l’affectation d’un fichier image qui n’existe pas à un champ Image.
Pour chaque problème, un bouton "..." permet d’accéder au détail de l’événement enregistré.
Si l’événement est relié à une ligne de code particulière, le bouton "Code" permet d’ouvrir
directement l’éditeur de code à l’emplacement correspondant afin de corriger le problème.
Fermez la fenêtre de l’audit dynamique.
L’audit dynamique d’un projet peut également être effectué lorsqu’une applica-
tion est déployée sur les postes clients.
Il est possible :
• soit de modifier l’application et d’utiliser la fonction dbgActiveAudit pour lancer
l’audit.
Notes
• soit d’utiliser un fichier texte dans le répertoire de l’application. Cette solution

permet de ne pas modifier l’exécutable. Il suffit de créer dans le même réper-
toire que l’exécutable un fichier portant le même nom que l’exécutable et d’ex-
tension ".WX".
L’audit génère un fichier ".wdaudit", ce fichier doit être chargé dans l’environne-
ment de développement pour analyser le résultat.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Audit dynamique").
Leçon 5.3. Analyseur de performances
• Présentation
• Lancer l’analyseur de performances
• Analyser le résultat
Présentation
L’analyseur de performances (appelé également Profiler) est un outil permettant de vérifier et
d’optimiser le temps d’exécution de votre application.
Son principe est simple :

• Vous testez votre application.
• Pendant ce test, l’analyseur de performances répertorie toutes les actions effectuées et les trai-
tements correspondants exécutés.
A la fin du test, l’analyseur de performances vous présente :
• les 10 manipulations qui ont pris le plus de temps
• toutes les actions effectuées dans l’application testée, triées par durée (de l’action la plus
longue à l’action la moins longue).
Il est possible de sélectionner un traitement afin d’analyser les causes de son temps de traite-
ment pour l’optimiser.
Le projet "WD Optimisation" contient une fenêtre spécifique permettant de visualiser des résultats
intéressants avec l’analyseur de performances.
Lancer l’analyseur de performances

L’analyseur de performances peut être lancé :
• directement depuis l’éditeur de WinDev :
Dans ce cas, le projet est alors automatiquement exécuté en mode test. Vous pouvez manipu-
ler votre application et lancer les traitements de votre choix.
Pour revenir sous l’éditeur WinDev, il suffit de quitter votre application.
L’analyseur de performances affiche alors le résultat de l’analyse. Ce résultat est enregistré
sous forme d’un fichier WPF.
• depuis un de vos traitements en WLangage, grâce aux fonctions suivantes :
AnalyseurDébut Lance la "collecte d’informations" pour l’analyseur de performances.
AnalyseurFin Arrête la "collecte d’informations" pour l’analyseur de performances.

Dans ce cas, seul le code présent entre les fonctions AnalyseurDébut et AnalyseurFin est ana-
lysé. Le résultat est enregistré sous forme d’un fichier WPF.
Dans notre exemple, nous allons utiliser la première méthode. Pour lancer l’analyseur de
performances sur le projet "WD Optimisation" :
1. Sous le volet "Projet", dans le groupe "Audit et performances", déroulez "Analyser les perfor-
mances" et sélectionnez "Analyser les performances".
L’analyseur de performances peut également être lancé depuis le Tableau de

bord du projet, via le Widget "Performances". Il suffit de dérouler le bouton fléché
et de sélectionner "Go minutieux du projet".
Notes
2. Le test du projet se lance.

3. Cliquez sur le bouton "Fenêtre de test de l’analyseur de performances".
4. Cliquez sur le bouton "Traitement à analyser".
5. Validez la fenêtre d’information et arrêtez le test du projet. La fenêtre du compte-rendu de
l’analyseur de performances apparaît.
Analyse du résultat
Examinons la fenêtre du compte-rendu de l’analyseur de performances. Les résultats sont

affichés dans plusieurs onglets :
• l’onglet "Synthèse" présente les dix traitements qui ont pris le plus de temps.
• l’onglet "Cartographie" présente une vision graphique des traitements les plus importants.
• l’onglet "Détail" présente tous les traitements lancés lors du test de l’application (classés du
plus long au plus rapide).
• l’onglet "Appels" permet de visualiser le détail des opérations réalisées dans un traitement.
Détaillons ces différents onglets dans le cas de notre exemple.
• L’onglet "Synthèse" présente les dix traitements les plus consommateurs de temps. Dans
notre exemple, nous pouvons voir que la procédure locale "MetAJourStockProduit" prend
plus de 3 secondes à s’exécuter.
• L’onglet "Cartographie" permet d’identifier de manière visuelle ce qui a pris le plus de
temps. Dans notre cas, c’est un appel à la fonction Ping :
• L’onglet "Détail" présente tous les traitements appelés du plus long au plus rapide.
Pour chaque traitement, les informations suivantes sont affichées :

• Fonction : Fonction, traitement ou procédure exécutée.
• Temps Total : Temps d’exécution de la fonction.
• Temps interne : Temps d’exécution dû au moteur.
• Nb appels : Nombre d’appels effectués à la fonction (procédure ou traitement)
• Temps 1 appel : Temps d’exécution d’un appel à la fonction (procédure ou traitement)
• % Code : Pourcentage du temps passé dans le traitement de la fonction ou de la procédure
(code du développeur pouvant être optimisé)
• Parent : Elément qui contient le traitement.
Dans notre cas, l’onglet "Détail" permet de retrouver l’appel à la fonction "Ping" dans les
éléments prenant le plus de temps.
Sélectionnez cette ligne. Nous allons voir dans le code si un problème peut expliquer ce
ralentissement.
• En cliquant sur le bouton "Appels", le détail des appels de la procédure MetAjourStockPro-

duit apparaît. En sélectionnant la ligne "Ping" et en cliquant sur le bouton "Code", la ligne de
code correspondante est affichée sous l’éditeur de code.
• Fermez l’analyseur de performances.
• La ligne de code exécutée est la suivante :
// Vérifie l’accessibilité du serveur fournisseur
Ping("adr-fournisseur")
Le ralentissement vient du fait que l’adresse spécifiée pour la fonction Ping est inaccessible.
Testons rapidement le fonctionnement de l’application en optimisant ce code :
1. Remplacez la ligne de code contenant la fonction Ping par la ligne de code suivante :
// Vérifie l’accessibilité du serveur fournisseur
Ping("http://pcsoft.fr")
2. Enregistrez le code (CTRL + S).
Nous allons maintenant relancer l’analyseur de performances :
1. Sous le volet "Projet", dans le groupe "Audit et performances", déroulez "Analyser les perfor-
mances" et sélectionnez "Analyser les performances".
2. Le test du projet se lance.
3. Cliquez sur le bouton "Fenêtre de test de l’analyseur de performances".
4. Cliquez sur le bouton "Traitement à analyser".
5. Validez la fenêtre d’information et arrêtez le test du projet. La fenêtre du compte-rendu de
l’analyseur de performances apparaît.
6. Sous l’onglet "Cartographie", la fonction Ping n’apparaît plus avec la même importance.
Fermez la fenêtre de rapport de l’analyseur de performances.
Leçon 5.4. Débogage d’un projet
• Présentation
• Utiliser le débogueur
Présentation
Arrêtons-nous un instant sur le débogueur livré en standard avec WinDev.
Qu’est-ce que le débogueur ?
Le débogueur est un outil puissant permettant de suivre pas à pas le déroulement d’un code ou
d’une application. Mettre au point un traitement ou même une application devient un jeu d’en-
fant.
Nous allons utiliser le débogueur sur le traitement long présent dans la fenêtre FEN_Analyseur-
Performances.
Utiliser le débogueur
Pour déboguer la fenêtre FEN_AnalyseurPerformances :

1. Ouvrez la fenêtre "FEN_AnalyseurPerformances" sous l’éditeur de fenêtres (double-cliquez
sur son nom dans l’explorateur de projet).
2. Lancez le test de la fenêtre "FEN_AnalyseurPerformances" ( parmi les boutons d’accès
rapide).
3. Lancez le débogueur en utilisant une des méthodes suivantes :
• Utilisez la combinaison de touches CTRL + Pause : le débogueur sera automatiquement
lancé lors de la prochaine action utilisateur dans la fenêtre testée.
• Retournez sous l’éditeur de WinDev et placez un point d’arrêt dans le code du bouton "Trai-
tement à analyser" (cliquez devant la première ligne de code du traitement de clic, un point
rouge apparaît). Lorsque la ligne de code précédée du point d’arrêt sera exécutée, le débo-
gueur se lancera.
De nombreuses méthodes permettent de lancer le débogueur. Pour plus de dé-

Note
tails, consultez l’aide en ligne (mot-clé : "Débogueur, Lancer un test").
4. Cliquez sur le bouton "Traitement à analyser". Le débogueur se lance. La ligne en cours est
précédée d’une petite flèche.
Dans la partie basse de l’écran, le volet "Débogueur" apparaît. Ce volet affiche deux zones dis-
tinctes :
• la pile des appels : cette zone permet de connaître la hiérarchie des traitements affichés dans le
débogueur. Dans notre exemple, pour le moment, nous sommes en train de déboguer le traite-
ment de clic sur le bouton BTN_TraitementLong.
• la liste des expressions à évaluer. Par défaut, les principales variables utilisées dans le code
sont affichées dans cette zone. Il est possible d’ajouter des variables pour suivre leur évolution
(nous verrons cette fonctionnalité plus tard).
Nous allons effectuer quelques manipulations sous le débogueur afin de découvrir ses possibili-
tés.
Tout d’abord, nous allons exécuter pas à pas les différentes instructions et voir le contenu
des variables :
1. Appuyez sur la touche F8 (ou sur le bouton "Pas à pas" présent dans le ruban). La ligne sui-
vant la ligne en cours est automatiquement exécutée. Si nécessaire, les valeurs des variables
sont modifiées dans le volet "Débogueur" (affiché par défaut en bas de l’écran).
2. Lorsque le curseur en forme de flèche arrive sur la ligne "JAUGE_Progression..BorneMax =
...", survolez avec la souris "JAUGE_Progression". Une bulle d’aide s’affiche avec la valeur de
l’expression :
3. La valeur de "JAUGE_Progression..BorneMax" est affichée dans une bulle d’aide. Cette va-
leur correspond à 100 car la ligne de code n’a pas été exécutée.
4. Utilisez la touche F8 pour exécuter la ligne.
5. Survolez à nouveau "JAUGE_Progression..BorneMax". La valeur de "JAUGE_Progression..
BorneMax" affichée dans la bulle d’aide correspond désormais au résultat de la fonction
HNbEnr(Produit).
Continuons nos manipulations sous le débogueur. Nous allons maintenant exécuter pas à
pas la procédure MetAJourStockProduits sous le débogueur.
1. Pour exécuter cette procédure pas à pas, utilisez la touche F7 (ou cliquez sur le bouton "Pas à
pas détaillé" dans le ruban).
2. Le code de la procédure s’affiche sous le débogueur.
Nous allons maintenant ajouter une expression pour surveiller l’évolution de sa valeur dans
le volet "Débogueur". Cette expression peut être de tout type : variable, fonction, opération
sur variables, ... Le résultat de l’expression est calculé et affiché.
Cette expression permet d’effectuer un débogage personnalisé. Par exemple, il est possible
de connaître le contenu d’une variable au fur et à mesure de son utilisation dans l’applica-
tion.
1. Utilisez la touche F7 pour exécuter les différentes lignes de la procédure MetAJourStockPro-
duits jusqu’à la ligne :
JAUGE_Progression++
2. Survolez "JAUGE_Progression". La valeur affichée dans la bulle est 0.
3. Sélectionnez "JAUGE_Progession" dans l’éditeur de code sous le débogueur et affichez le
menu contextuel (clic droit). Sélectionnez l’option "Ajouter l’expression dans le débogueur".
4. L’expression est automatiquement ajoutée dans le volet du débogueur en bas de l’écran.
Le débogueur permet également d’exécuter un ensemble de lignes de code :

1. Avancez avec la touche F8 jusqu’à la ligne :
HModifie(Produit)
L’utilisation de la touche F8 permet d’exécuter le code de la procédure InterrogeBaseFournis-

seur sans le dérouler pas à pas sous le débogueur.
2. Cliquez avec la souris sur la ligne suivante :
SI HExécuteRequête(REQ_QuantitéCommandée) ALORS
3. Utilisez la touche F6 (ou le bouton "Exécuter jusqu’au curseur" présent dans le ruban).
4. La flèche indiquant la ligne en cours d’exécution se déplace jusqu’à la ligne où le curseur
de la souris est positionné. Les lignes de code sont automatiquement exécutées.
Nous allons maintenant mettre un point d’arrêt et exécuter le code jusqu’au prochain
passage sur le point d’arrêt :
1. Cliquez avec la souris dans la zone hachurée, devant la fonction HModifie. Un point d’arrêt
(puce rouge) apparaît.
2. Utilisez la touche F5 (ou cliquez sur le bouton "Continuer" présent dans le ruban). Le code
est exécuté jusqu’au point d’arrêt. La flèche permettant d’identifier la ligne en cours se dé-
place jusqu’au point d’arrêt.
3. Enlevez le point d’arrêt en cliquant directement sur le point d’arrêt.
Pour finir ce test, nous allons utiliser une expression "Autostop". Une expression "Autostop"
permet de lancer le débogueur dès qu’une condition est vérifiée ou dès que la valeur d’une
variable est modifiée. Dans notre exemple, nous allons lancer le débogueur dès que la valeur
de la jauge est à 50% :
1. Dans le volet du "Débogueur", sélectionnez l’expression "Jauge_Progression" que nous avons
ajoutée précédemment.
2. Cliquez sur le rond vert.
3. Appuyez sur la touche F5 pour continuer le test.
4. Un message s’affiche indiquant que la valeur de l’expression "JAUGE_Progression" a
changé.
5. Validez.
6. Dans le volet du "Débogueur", sélectionnez l’expression "Jauge_Progression". Dans le menu
contextuel, sélectionnez l’option "Editer l’expression" et dans la zone expression saisissez :
"JAUGE_Expression = 50".
7. Appuyez sur la touche F5. L’exécution du programme continue. Le débogueur est à nouveau
lancé lorsque la jauge a pour valeur 50.
Voila, nous avons terminé notre tour d’horizon du débogueur. Pour arrêter le test sous le
débogueur, cliquez sur "Terminer le test" présent dans le ruban.
PARTIE 6
Programmation
avancée
• Présentation
• Comment ouvrir un exemple didactique
• Comment ouvrir un exemple unitaire
(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Partie 6 : Programmation avancée 411
Présentation
Cette partie présente plusieurs fonctionnalités avancées. Sa lecture n’est pas indispensable à la
connaissance de WinDev, mais elle vous permet de découvrir quelques-unes des possibilités de
WinDev.
Les différentes leçons de cette partie s’appuient sur des exemples livrés en standard avec Win-
Dev.
WinDev propose différents exemples :

• exemples complets : ces exemples correspondent à une application complète utilisant une ou
plusieurs fonctionnalités.
• exemples didactiques : ces exemples correspondent à une petite application permettant de
découvrir une fonctionnalité.
• exemples unitaires : ces exemples correspondent à une fenêtre permettant de tester rapide-
ment l’utilisation d’une fonction.
Exemple pratique
Pour simplifier la présentation des différentes fonctionnalités, vous allez manipuler des exemples
unitaires ou des exemples didactiques, livrés en standard avec WinDev.
Pour ouvrir un exemple complet ou didactique depuis la fenêtre de bienvenue :
1. Fermez si nécessaire le projet en cours. La fenêtre de bienvenue apparaît.
2. Dans la fenêtre de bienvenue, cliquez sur "Ouvrir un exemple". La liste des exemples com-
plets et des exemples didactiques fournis avec WinDev apparaît.
3. Dans la zone de recherche, vous pouvez saisir un mot clé (par exemple saisissez "Erreur").
Seuls les exemples contenant ce mot sont alors listés.
4. Pour ouvrir un projet, il suffit de cliquer sur le lien présent dans la fenêtre.
412 Partie 6 : Programmation avancée (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite
Pour ouvrir un exemple didactique depuis le volet "Assistant, Exemples et composants" :
1. Affichez si nécessaire le volet "Assistants, Exemples et composants" : sous le volet "Accueil",
dans le groupe "Environnement", déroulez "Volets" et sélectionnez "Assistants, Exemples et
composants".
2. Dans le volet, cliquez sur "Exemples". La liste des exemples apparaît. Les exemples sont
affichés par catégorie.
3. Dans la catégorie "Exemples didactiques", sélectionnez l’exemple voulu (par exemple
l’exemple didactique "Fichiers Texte") et double-cliquez sur son nom : le projet correspondant
s’ouvre automatiquement sous l’éditeur.
Pour ouvrir un exemple unitaire :

1. Affichez si nécessaire le volet "Assistants, Exemples et composants" : sous le volet "Accueil",
dans le groupe "Environnement", déroulez "Volets" et sélectionnez "Assistants, Exemples et
composants".
3. Dans la catégorie "Exemples unitaires", sélectionnez l’exemple voulu (par exemple l’exemple
unitaire "Manipulation de fichiers texte") et double-cliquez sur son nom : la fenêtre correspon-
dante s’ouvre automatiquement sous l’éditeur.
Leçon 6.2. Gestion automatique
des erreurs
• Qu’est-ce que la gestion automatique des erreurs ?

• Utilisation de la gestion automatique des erreurs.
Présentation
WinDev peut gérer automatiquement les erreurs. Cette fonctionnalité permet à la fois de réduire
sensiblement le code d’un projet tout en uniformisant et en centralisant la gestion des erreurs.
L’utilisation de cette fonctionnalité rend également le code plus lisible.
Fonctionnement
Lorsqu’une fonction du WLangage rencontre une erreur, deux opérations sont réalisées :
• une valeur de retour d’erreur est renvoyée par la fonction (par exemple, la fonction fOuvre
renvoie la valeur "-1" si le fichier spécifié n’a pu être ouvert).
• l’erreur est détectée par le WLangage (la variable ErreurDétectée correspond à Vrai) et il est
possible de récupérer des informations sur cette erreur grâce à la fonction ErreurInfo.
C’est cette seconde opération qui peut être gérée en automatique grâce à la gestion des erreurs
de WinDev.
Mise en place
Le paramétrage de la gestion automatique des erreurs peut s’effectuer :
• soit directement dans l’éditeur de code : il suffit de cliquer sur le lien "Si erreur : Par pro-
gramme" dans l’éditeur de code :
• soit par programmation, avec la fonction ErreurChangeParamètre.
Types d’erreurs concernées
Le WLangage peut rencontrer deux types d’erreurs :
• les erreurs "non fatales" (appelées également erreurs d’exécution) : ces erreurs sont géné-
ralement gérées dans le code et ne provoquent pas l’arrêt de l’application. Par exemple,
ouverture d’un fichier inaccessible ou d’une archive inexistante.
• les erreurs "fatales" (appelées également erreurs de programmation) : ces erreurs sont gé-
néralement liées à un problème matériel (plus d’espace disque, perte de connexion ré-
seau...) ou à des problèmes graves de conception (accès à un fichier non déclaré, utilisation
de champs inexistants...). Une erreur "fatale" peut également survenir suite à une erreur
"non fatale" mal gérée. Dans ce cas, l’application va s’arrêter.
Le mécanisme de gestion des erreurs permet de gérer de façon bien distincte ces deux types
d’erreurs afin de pouvoir spécifier des comportements adaptés aux erreurs rencontrées.
Gestion automatique des erreurs : un exemple didactique
Pour comprendre les différents cas d’erreurs et leur gestion, nous vous proposons de
manipuler un exemple didactique livré en standard avec WinDev.
1. Fermez si nécessaire le projet en cours. La fenêtre de bienvenue apparaît.
2. Dans la fenêtre de bienvenue, cliquez sur "Ouvrir un exemple". La liste des exemples com-
plets et des exemples didactiques fournis avec WinDev apparaît.
3. Dans la zone de recherche, saisissez "Erreur". Seuls les exemples contenant ce mot sont
alors listés.
4. Sélectionnez le projet "WD Gestion Auto Erreurs". Le projet se charge.
Ce projet présente la gestion :
• d’une erreur non fatale (ouverture d’une archive inexistante).
• d’une erreur fatale (division d’un entier par 0).
• d’une erreur sur plusieurs niveaux.
Testez le projet en cliquant sur (parmi les boutons d’accès rapide).
1. Cliquez sur le choix "Gestion d’une erreur non fatale".
2. La fenêtre suivante s’affiche.
3. Cliquez sur le bouton "Tester cette gestion d’erreur".

4. Lors de l’exécution de la ligne de code générant l’erreur, un message d’erreur s’affiche et
propose à l’utilisateur de réessayer l’opération, d’annuler l’opération ou d’arrêter l’application.
L’option "Déboguer" est à utiliser :
• en mode test, pour déboguer directement l’application.
• en mode exécutable, pour réaliser le déboguage d’un exécutable directement depuis Win-
Dev.
5. Cliquez sur l’option "Annuler l’opération" et fermez la fenêtre.
Cliquez sur le choix "Gestion d’une erreur fatale".
1. La fenêtre suivante s’affiche. Cette fenêtre permet de tester l’erreur dans le cas de la division
d’un entier par 0.

3. Lors de l’exécution de la ligne de code générant l’erreur, une procédure est automatique-
ment appelée. Cette procédure permet d’afficher le message d’erreur et d’arrêter le traite-
ment en cours.
4. Cliquez sur "OK" et fermez la fenêtre.
Cliquez sur le choix "Gestion d’une erreur sur plusieurs niveaux".
1. La fenêtre suivante s’affiche. Cette fenêtre permet de tester une erreur sur plusieurs niveaux
(traitement appelant une procédure qui ouvre une archive inexistante).

3. Lors de l’exécution de la ligne de code générant l’erreur :
- la procédure retourne "Faux" au traitement appelant.
- le traitement appelant affiche un message d’erreur et arrête le traitement.
4. Cliquez sur le bouton "Annuler l’opération".
Arrêtez le test de l’application.
WinDev propose également une gestion automatique des erreurs HFSQL. Pour
Exemple
plus de détails, consultez l’exemple "Detection erreurs" (exemple didactique),

livré en standard avec WinDev. Cet exemple est accessible depuis le volet "Assis-
tants, Exemples et Composants" de WinDev.
Leçon 6.3. Manipuler des fichiers
externes
• Manipuler des fichiers texte (CSV , ...)

• Manipuler des répertoires
• Manipuler des fichiers XML
• Manipuler des fichiers XLS
Présentation
WinDev permet de manipuler simplement les formats les plus courants de données :
• fichiers texte (fichiers INI, CSV, ...),
• fichiers XML,
• fichiers XLS, ...
De nombreuses familles de fonctions WLangage permettent aussi bien de lire ces fichiers que de
créer ces fichiers. Vous pouvez ainsi lire facilement dans vos applications WinDev des données
générées par d’autres logiciels ou encore créer des fichiers nécessitant un formatage particulier.
De plus, le WLangage propose également une famille de fonctions permettant de manipuler les
répertoires où sont présents les fichiers.
Dans ce chapitre, nous nous consacrerons plus particulièrement :
• aux fichiers Texte (fichiers texte, fichiers INI et fichiers CSV)
• aux fichiers XML
• aux fichiers XLS
• à la gestion des répertoires.
Manipulation des fichiers texte ou CSV
Présentation
Les fichiers externes sont souvent appelés fichiers texte ou encore fichiers à accès direct. Ce
type de fichier contient généralement du texte, mais il peut également contenir des informations
binaires telles que des images, des sons, ...
Dans cette leçon comme dans toute la documentation de WinDev, nous parlerons de fichiers
externes.
WinDev permet de manipuler en programmation les fichiers externes. Les fonctions du WLangage
permettent de créer, lire ... des fichiers externes. Toutes les fonctions peuvent être très facilement
identifiées : elles commencent toutes par la lettre "f".
Dans un fichier externe, il n’y a pas nécessairement de notion "d’enregistrement". Pour pouvoir
manipuler un fichier externe, il faut en connaître la structure, c’est-à-dire connaître l’agencement
des données qui se trouvent à l’intérieur du fichier.
Les fichiers CSV sont simplement des fichiers texte utilisant une structure spécifique. Ils sont
donc manipulables comme les fichiers textes.
Les fichiers .INI sont également des fichiers texte utilisant une structure spécifique. Pour les mani-
puler, WinDev dispose de deux fonctions spécifiques : INILit et INIEcrit.
Exemple pratique
Ouvrez l’exemple didactique "Fichiers Texte" et testez le projet correspondant.

Ce projet regroupe de nombreuses manipulations possibles sur les fichiers externes avec
WinDev.
Les différents onglets de la fenêtre principale proposent :
• La création d’un fichier texte.
• La lecture et écriture dans un fichier texte.
• Des manipulations de fichiers existants (copie, suppression, lecture d’informations, ...).
• La copie d’un fichier texte.
Pour plus de détails sur les fonctions de gestion des fichiers externes, consultez l’aide en ligne
(mot-clé : "Fichier externe").
Manipulation des répertoires

Pour manipuler les répertoires et leurs fichiers, le WLangage propose de nombreuses fonctions.
Exemple pratique
Ouvrez si nécessaire l’exemple didactique "Fichiers Texte" et testez le projet correspondant.

Cliquez sur l’onglet "Gestion des répertoires".
Ce projet regroupe les manipulations possibles sur les disques et les répertoires :
• créer un répertoire
• connaître le répertoire en cours
• tester l’existence d’un répertoire
• lister des répertoires
• copier un répertoire
• supprimer un répertoire
• ...
Pour plus de détails sur les fonctions de gestion des répertoires, consultez l’aide en ligne (mot-
clé : "Fichier externe").
Manipulation des fichiers XML
Présentation
XML (Extensible Markup Language, ou Langage Extensible de Balisage) est le langage destiné à
succéder à HTML sur le World Wide Web. Comme HTML (Hypertext Markup Language), le XML est
un langage de balisage, c’est-à-dire un langage qui présente de l’information encadrée par des
balises. Mais contrairement à HTML, qui présente un jeu limité de balises, XML est un métalan-
gage, qui permet d’inventer de nouvelles balises pour isoler toutes les informations élémentaires
que peut contenir une page Web.
XML permet de structurer un document contenant des données. Un fichier de données HFSQL
contenant plusieurs rubriques et enregistrements peut, par exemple, être exporté dans un fichier
XML (fonctions XML*).
Exemple
Pour plus de détails sur l’utilisation du XML, consultez l’exemple "WD XML"
(exemple didactique), livré en standard avec WinDev. Cet exemple est accessible
depuis le volet "Assistants, Exemples et Composants" de WinDev.
WinDev gère en standard :

• les fichiers au format XML grâce à un accès natif fourni avec WinDev. Pour plus de détails,
consultez l’aide en ligne.
• les exportations vers le XML (fonctions TableVersXML, TexteVersXML, HExporteXML)
• l’import de données XML (fonction HImporteXML)
• la manipulation d’un document XML grâce au type avancé XMLDocument et aux fonctions
WLangage commençant par XML.
Il est également possible de manipuler directement le fichier XML dans l’éditeur de code. Il suffit
de :
1. "Dropper" le fichier XML depuis l’explorateur de fichier vers l’explorateur de projet, dossier
"Descriptions XML et XSD".
2. "Dropper" le fichier XML de l’explorateur de projet vers l’éditeur de code. La variable de type
xmlDocument est alors automatiquement créée de la manière suivante :
<Nom de la variable> est un xmlDocument , description = <Nom du
document>
3. Vous pouvez maintenant accéder directement aux noeuds de la variable par leurs noms.
Ces noms sont proposés automatiquement par le mécanisme de complétion automatique de
l’éditeur de code.
Exemple pratique
Ouvrez l’exemple unitaire "Lecture et écriture au format XML" et testez la fenêtre correspon-
dante. Cette fenêtre permet de :
• créer un fichier XML. Ce fichier est créé grâce aux fonctions XML.
• lire un fichier XML.
Consultez le code associé à chaque bouton.
Notes
Nous ne détaillerons pas ici toutes les fonctionnalités proposées par les fonc-
tions XML. Pour plus de détails, consultez l’aide en ligne.
Manipulation des fichiers XLS

Pour manipuler les fichiers Excel, WinDev met à votre disposition :
• les fonctions xlsXXX. Ces fonctions permettent de lire les données présentes sur les différentes
feuilles d’un fichier Excel.
• les variables avancées de type xlsDocument, xlsLigne, xlsColonne, xlsCellule.
Exemples pratiques
Un test rapide des possibilités de ces fonctions ?
Pour tester l’utilisation des fonctions xlsXXX, ouvrez l’exemple unitaire "Fonctions Excel" et
testez la fenêtre correspondante. Cette fenêtre permet :
• d’importer des données provenant d’une feuille Excel.
• d’exporter les données d’un champ Table vers Excel.
Retournez sous l’éditeur pour consulter le code des différents boutons.
Pour tester l’utilisation des variables avancées, ouvrez l’exemple didactique "Classe XLS" :
1. Affichez le volet "Assistants, Exemples et composants" : sous le volet "Accueil", dans le groupe
"Environnement", déroulez "Volets" et sélectionnez "Assistants, Exemples et composants".
3. Dans la catégorie "Exemples didactiques", sélectionnez l’exemple "Classes XLS" et double-
cliquez sur son nom : le projet correspondant est automatiquement ouvert sous l’éditeur.
4. Testez le projet.
5. Retournez sous l’éditeur pour consulter le code des différents boutons.

Notes
Nous ne détaillerons pas ici toutes les fonctionnalités proposées par les fonc-
tions XLS et les types avancés. Pour plus de détails, consultez l’aide en ligne.
Leçon 6.4. Compilation dynamique
• Présentation
• Tracer une courbe en compilation dynamique
Présentation
La compilation dynamique permet de compiler un code à n’importe quel moment de l’applica-
tion. Un exemple d’utilisation courant ? Votre application contient une formule paramétrable. Pour
changer les paramètres, il n’est pas nécessaire de re-livrer l’exécutable : la modification d’un fi-
chier texte suffit.
Exemple
Nous avons choisi de vous présenter la compilation dynamique grâce à l’exemple didactique "WD
Compilation dynamique".
Le projet "WD Compilation dynamique" montre comment compiler dynamiquement du code
WLangage (stocké sous forme de chaîne), exécuter la procédure générée dynamiquement et
traiter les éventuelles erreurs d’exécution.
1. Ouvrez l’exemple didactique "Compilation dynamique".
2. Lancez le test de l’exemple.
3. Cliquez sur les différents boutons "Exécuter" pour voir les différents cas proposés.
4. Arrêtez le test.
Retournons sous l’éditeur de code pour étudier le code du premier bouton "Exécuter".
1. Affichez le code du bouton "Exécuter" (clic droit sur le bouton, option "Code"). Ce code appelle
la procédure CompileCodeDynamique.
2. Positionnez le curseur de la souris sur le nom de la procédure et utilisez la touche [F2]. Le
code de la procédure apparaît automatiquement sous l’éditeur de code.
Le code de cette procédure peut être décomposé en plusieurs parties :
1. Initialisation des variables.
2. Compilation du code.
sRésultatCompilation = Compile(PROCEDURE_DYNAMIQUE, ...

SAI_CODE_COMPIL)
Ce code contient plusieurs points à remarquer :

• La compilation de la fonction est effectuée avec la fonction WLangage Compile. Dès que
cette fonction est utilisée (et si aucune erreur n’est renvoyée), la fonction compilée dynami-
quement devient utilisable.
• Cette fonction admet deux paramètres : le nom de la procédure compilée (ici "PROCEDURE_
DYNAMIQUE") et le code à compiler. Ici, le code à compiler est contenu dans le champ de
saisie SAI_CODE_COMPIL.
• Le résultat de la compilation est affecté à une chaîne sRésultatCompilation.
3. Vérification du résultat de la compilation.
// Vérifie le résultat de la compilation

SELON sRésultatCompilation
// Aucune erreur
CAS ""
bRésultatCompilation = Vrai
LIB_ERREUR_CODE_COMPILE = ""

// Erreur fatale de compilation
CAS "ERR"
bRésultatCompilation = Faux
LIB_ERREUR_CODE_COMPILE = ErreurInfo

// Code incorrect
AUTRE CAS
bRésultatCompilation = Faux
LIB_ERREUR_CODE_COMPILE = sRésultatCompilation
FIN
4. Utilisez la combinaison de touches CTRL + F2. Le code de clic du bouton "Exécuter" réappa-
raît sous l’éditeur de code. Dans la suite de ce code, vous pouvez voir que la fonction compilée
dynamiquement est exécutée grâce à la fonction Exécute.
Leçon 6.5. Evénement Windows
• Programmation des événements Windows.
Introduction
Toute action effectuée par Windows correspond à un événement Windows. Différents types d’évé-
nements peuvent être rencontrés, par exemple :
• Le survol d’une fenêtre par la souris,
• L’arrêt du système,
• L’affichage d’une boîte de dialogue,
• Une erreur logicielle,
• Etc.
Lorsque ces événements se produisent, il est possible de les intercepter afin de préparer ou
d’exécuter un traitement spécifique.
Par défaut, WinDev propose la gestion automatique des événements les plus utilisés. Par exemple,
les événements suivants sont proposés pour un champ de saisie :
• Initialisation du champ,
• Entrée dans le champ,
• Modification du champ,
• Sortie du champ.
Pour gérer des événements supplémentaires, il est possible :
• soit d’utiliser les traitements optionnels proposés par WinDev.
• soit d’utiliser les événements Windows.
Exemple pratique
Nous avons choisi de vous présenter la gestion des événements grâce à l’exemple unitaire "Fonc-
tion Evénement".
Ouvrez l’exemple unitaire "Fonction Evénement".
Traitements optionnels proposés par WinDev
Pour chaque élément (fenêtre, champ, ...), WinDev propose de nombreux traitements optionnels.
Pour ajouter un traitement optionnel :
1. Affichez les traitements liés au champ Liste présent dans la fenêtre de l’exemple unitaire :
• Sélectionnez le champ Liste.
• Appuyez sur la touche F2.
• L’éditeur de code est affiché.
2. Une barre d’outils est disponible en bas de la fenêtre de code :
Cette barre d’outils présente les principaux traitements optionnels disponibles. Pour identifier
les traitements, survolez les différentes icônes.
3. Pour ajouter un traitement, cliquez sur l’icône correspondante. Le traitement correspondant
est automatiquement affiché sous l’éditeur de code.
4. Pour afficher la liste complète des traitements optionnels disponibles, il suffit de cliquer sur
"...".
5. Pour ajouter un traitement, il suffit de cocher la case correspondante et de valider cette fe-
nêtre. Par exemple, ajoutez l’événement "Touche Enfoncée".
Evénements de Windows
Pour la gestion d’événements plus "spécifiques", il existe la fonction WLangage Evénement. La
fonction Evénement permet d’associer une procédure WLangage à un événement Windows.
Notes
Pour utiliser la fonction Evénement, il faut maîtriser la programmation Windows

et notamment les événements Windows.
Pour connaître la liste (non exhaustive) des événements Windows, consultez l’aide en ligne de
WinDev (mot-clé : "Valeur des constantes de l’API Windows").
Exemple : Détecter le clic sur une liste
Lancez le test de la fenêtre "FEN_Fonction_Evénement". Cette fenêtre détecte si la liste est

manipulée avec la souris ou avec le clavier.
1. Cliquez sur le champ Liste avec la souris.
2. Utilisez la souris ou le clavier pour déplacer le bandeau de sélection.
3. Un message s’affiche indiquant si la souris ou le clavier a été utilisé.
4. Arrêtez le test et revenez sous l’éditeur.

Regardons le code utilisé :
1. Cliquez dans la fenêtre.
2. Affichez les traitements de la fenêtre (appuyez sur la touche F2).
3. Examinons le code de déclaration des globales de la fenêtre FEN_Fonction_Evénement.
• Tout d’abord la ligne de code :
EXTERN "WINCONST.WL"
Cette ligne de code permet d’intégrer le contenu du fichier WINCONST.WL dans le code de
l’application grâce au mot-clé EXTERNE. Ce fichier contient la déclaration et les valeurs des
constantes Windows. A la compilation, tout le code contenu dans le fichier Winconst.WL
sera automatiquement intégré au code de l’application.
• Ensuite, les différents événements gérés sont déclarés :
// Evénements sur le champ LISTE_Mois
// Pression d’une touche du clavier
Evénement("SourisOuClavier",LISTE_Mois..NomComplet,WM_KEYDOWN)
// Clic gauche de souris
Evénement("SourisOuClavier",LISTE_Mois..NomComplet,...
WM_LBUTTONDOWN)
La procédure SourisOuClavier est appelée dès qu’une utilisation du clavier sur la liste est
effectuée (événement Windows correspondant : WM_KEYDOWN) ou dès que le clic gauche
de la souris est utilisé (événement Windows correspondant : WM_LBUTTONDOWN).
4. Affichez le code de la procédure :
• Placez le curseur de la souris sur "SourisOuClavier".
• Utilisez la touche F2
5. Le code de la procédure est très simple :
• Si le clavier est utilisé, le libellé affiché sous le champ Liste contient "Sélection avec le cla-
vier".
• Si la souris est utilisée, le libellé affiché sous le champ Liste contient "Sélection avec la sou-
ris".
PROCEDURE SourisOuClavier()
// La variable _EVE.wMessage contient le numéro du message

SELON _EVE.wMessage
// C’est le clavier
CAS WM_KEYDOWN
// Message indiquant l’utilisation du clavier
LIB_TypeSélection = "Sélection avec le clavier"
LIB_TypeSélection..Couleur = RougeClair
// C’est la souris
CAS WM_LBUTTONDOWN
// Message indiquant l’utilisation de la souris
LIB_TypeSélection = "Sélection avec la souris"
LIB_TypeSélection..Couleur = BleuClair
FIN
Leçon 6.6. Les threads
• Qu’est-ce que les threads ?
Définition
Les threads permettent d’exécuter du code (ou des traitements) en parallèle de l’application prin-
cipale. Il est ainsi possible d’exécuter plusieurs traitements différents qui peuvent être très longs
en tâche de fond, sans bloquer l’application principale (appelée également "Thread principal").
Les threads remplacent certains types de timer.
Généralement, un thread secondaire est utilisé pour détecter un événement, par exemple, une
action de l’utilisateur, la réception d’un email, la réception d’un appel téléphonique, ...
Quelques exemples d’utilisation des threads :

• Récupération d’emails en tâche de fond, pendant la saisie d’un nouvel email par exemple.
• Application de communication : gestion des appels téléphoniques, communication par soc-
ket, ...
Avec WinDev, vous avez la possibilité de :
• gérer simplement des threads (fonctions Thread*).
• utiliser des "signaux" afin de synchroniser plusieurs threads (fonctions Signal*).
• utiliser les threads avec des "sémaphores" afin de gérer l’accès à des ressources partagées
par différents threads (fonctions Sémaphore*).
Exemple
Exemple
WinDev est livré en standard avec un exemple permettant de comprendre l’inté-

rêt et l’utilisation des threads, "Pool de Threads" (exemple didactique, accessible
depuis le volet "Assistants, Exemples et Composants" de WinDev).
Pour plus de détails sur la gestion des threads avec WinDev, consultez l’aide en ligne (mot-clé :
"Thread").
Leçon 6.7. Les sockets
• Présentation
• Application Serveur
• Application Cliente
Présentation
WinDev met à votre disposition des fonctions qui permettent de réaliser une gestion avancée des
sockets.
Une socket est une ressource de communication utilisée par les applications pour communiquer
d’une machine à une autre sans se soucier du type de réseau.
Ce mode communication est utilisé pour faire communiquer deux applications, situées sur des
postes différents (reliés par Internet ou sur un même réseau local) ou sur un même poste.
Une application WinDev peut gérer les sockets selon différents modes :
• Application WinDev Cliente : l’application se connecte à un serveur quelconque et échange
des données par une socket.
• Application WinDev, WebDev ou WinDev Mobile "Serveur" : l’application WinDev (ou WebDev
ou WinDev Mobile) est un serveur, échangeant des informations par sockets avec plusieurs
postes client quelconques. Pour gérer plusieurs connexions simultanées, il est nécessaire
d’utiliser des threads.
Exemple
WinDev est livré en standard avec un exemple permettant de comprendre l’uti-

lisation des sockets : "Utilisation des sockets" (exemple didactique, accessible
depuis le volet "Assistants, Exemples et Composants" de WinDev).
Application Serveur : cas d’un serveur simplifié

WinDev offre la possibilité de créer un serveur de socket simplifié. Ce serveur permet de commu-
niquer avec un seul poste client simultanément. Ce type d’application est très utile lorsque deux
applications distantes ont besoin de communiquer.
Les étapes pour créer un serveur simplifié sont les suivantes :
1. Création de la socket.
2. Echange de données.
3. Fermeture de la socket.
Création de la socket
Pour créer la socket, le poste serveur utilise la fonction SocketCrée. Une socket est associée à
un port spécifique. Pour simplifier la manipulation de la socket par programmation sur le poste
serveur, précisez le nom de la socket.
Le poste client va venir se connecter sur cette socket pour échanger des données. La connexion
entre les deux postes sera effectivement réalisée au premier échange de données entre les deux
postes (c’est-à-dire à la première lecture d’informations par le poste serveur).
La connexion est établie au premier succès de la fonction SocketLit sur le serveur.
Echange de données
Lorsque deux postes utilisent la même socket, un flux de communication s’établit entre ces deux
postes. Il est alors possible pour ces deux postes de lire et d’écrire des chaînes de caractères sur
la socket.
Remarque : Pour ne pas bloquer les applications, la gestion de la réception des messages est
souvent gérée par un thread spécifique.
Pour lire et écrire sur la socket, l’application serveur WinDev doit utiliser les fonctions SocketLit et
SocketEcrit.
Attention : Pour réaliser une lecture, une écriture doit avoir été réalisée. Par exemple :
1. Le poste client écrit sur la socket : il envoie une requête au poste serveur.
2. Le poste serveur effectue une lecture sur la socket dans un thread. Dès qu’un message est
reçu, le message est traité par le poste serveur.
3. Si une réponse au message est nécessaire, le poste serveur identifie le poste client (fonc-
tion SocketClientInfo) et lui envoie une réponse.
Fermeture de la socket
Pour terminer la communication, le serveur peut fermer la socket avec la fonction SocketFerme.
Remarque : la socket peut aussi être fermée par le poste client.
Application Cliente
Une application cliente d’un serveur de sockets se connecte à un serveur quelconque pour échan-
ger des informations par l’intermédiaire d’une socket.
Exemple : Une application WinDev cliente peut se connecter à un serveur de news standard sur
Internet.
Les étapes pour créer une application cliente sont les suivantes :
1. Connexion au serveur
2. Échange de données
3. Fin de communication
Connexion au serveur
Pour se connecter à une socket du serveur, il suffit d’utiliser la fonction SocketConnecte. Cette
fonction permet d’effectuer une demande de connexion au serveur.
La socket est identifiée par son port et par son adresse.
Echange de données
Lorsque deux postes utilisent la même socket, un flux de communication s’établit entre ces deux
postes. Il est alors possible pour ces deux postes de lire et d’écrire des chaînes de caractères sur
la socket.
Remarque : Pour ne pas bloquer les applications, la gestion de la réception des messages est
souvent gérée par un thread spécifique.
Pour lire et écrire sur la socket, l’application cliente WinDev doit utiliser les fonctions SocketLit et
SocketEcrit.
Fin de communication
Pour terminer la communication, il suffit de fermer la socket depuis le poste client avec la fonction
SocketFerme.
Remarque : il est également possible de terminer la communication depuis le poste serveur.
Exemple pratique
Nous avons choisi de vous présenter un cas réel de la programmation des sockets grâce à
l’exemple unitaire "Utilisation des sockets".
Test de l’exemple
Ouvrez l’exemple unitaire "Utilisation des sockets".

Lancez le test de la fenêtre "FEN_Socket". Nous allons envoyer un message du poste B au
poste A. Le poste A est l’application Serveur et le poste B est l’application Cliente.
1. Sur le poste A, créez la socket en cliquant sur le bouton "Créer".
2. Le poste B peut alors se connecter à la socket créée par le poste A. Il suffit de cliquer sur le
bouton "Connecter" (dans la partie Poste B).
3. Le poste B envoie un message au poste A :
• Saisissez le message à envoyer dans la zone "Phrase à envoyer au poste A".
• Cliquez sur le bouton "Envoyer" présent dans la zone "Poste B".
4. Pour récupérer le message sur le poste A, cliquez sur le bouton "Récupérer" dans la zone
"Poste A".
5. Déconnectez les deux postes en cliquant sur les boutons "Déconnecter".
Arrêtez le test de la fenêtre pour revenir sous l’éditeur.
Analyse du code utilisé
Etudions le code des différents boutons que nous avons utilisé.

Nous allons tout d’abord étudier les traitements réalisés par le serveur de socket (le poste A).
1. Affichez le code du bouton "Créer" dans la zone Poste A :
• Sélectionnez le bouton "Créer".
• Affichez les traitements grâce à la touche F2.
2. Dans le traitement "Clic sur", nous retrouvons la fonction SocketCrée qui permet de créer la
socket. Fermez l’éditeur de code.
3. Affichez le code du bouton "Récupérer" dans la zone Poste A :
• Sélectionnez le bouton "Récupérer".
4. Dans le traitement "Clic sur", le code utilisé est le suivant :
SAI_PhraseRecueDuPosteB = SocketLit("PosteA", Faux, 2000)
SI SAI_PhraseRecueDuPosteB <> "" ALORS
Info("Message reçu de l’adresse I.P N° " + ...
SocketClientInfo("PosteA", SocketAdresse))
FIN
Nous retrouvons la fonction SocketLit qui permet de lire la socket précédemment créée. Le
message lu est immédiatement affiché dans le champ "SAI_PhraseRecueDUPosteB". Fermez
l’éditeur de code.
Etudions maintenant les traitements réalisés par le client (le poste B).
1. Affichez le code du bouton "Connecter" dans la zone Poste B :
• Sélectionnez le bouton "Connecter".
2. Dans le traitement "Clic sur", nous retrouvons la fonction SocketConnecte qui permet de se
connecter à la socket créée par le poste A. Fermez l’éditeur de code.
3. Affichez le code du bouton "Envoyer" dans la zone Poste B :
• Sélectionnez le bouton "Envoyer".
4. Dans le traitement "Clic sur", le code utilisé est le suivant :
SI PAS SocketEcrit("PourPosteA", ...
SAI_PhraseAEnvoyerAuPosteA) ALORS
Erreur(ErreurInfo(errMessage))
RETOUR
FIN
Nous retrouvons la fonction SocketEcrit qui permet d’envoyer un message sur la socket à
laquelle le poste B s’est connecté. Fermez l’éditeur de code.
Remarque : Dans cette leçon, nous avons vu une communication "simple" entre un serveur et un
poste client : le client envoie des messages et le serveur traite les messages. Il est bien entendu
possible de réaliser des applications plus élaborées.
Il est possible de réaliser une communication entre deux applications, à la fois cliente et serveur.
Dans ce cas, la gestion des threads devient primordiale pour gérer les envois et les réponses des
applications.
Leçon 6.8. Le FTP
• Présentation des fonctions FTP de WinDev.
Présentation
Le FTP (File Transfert Protocol) est un protocole standard permettant d’effectuer le transfert de
fichiers d’une machine vers une autre machine. Une des deux machines doit être un serveur FTP.
Le WLangage possède les commandes de programmation nécessaires pour effectuer des trans-
ferts de fichiers en utilisant ce protocole avec un serveur. Ces fonctions de programmation com-
mencent toutes par "FTP".
WinDev ne propose que des fonctions "clientes" pour le FTP. Il est nécessaire d’utiliser un serveur
FTP standard.
Nous avons choisi de vous présenter un cas réel de la programmation des sockets grâce à
l’exemple unitaire "Fonctions FTP".
Ouvrez l’exemple unitaire "Fonctions FTP". Cet exemple présente les principales fonctionnali-
tés utilisables sur un serveur FTP.
Se connecter à un serveur FTP

La fonction FTPConnecte permet de se connecter à un serveur FTP. Vous devez au préalable pos-
séder un compte FTP (nom d’utilisateur et mot de passe) pour accéder à un serveur FTP.
Dans la fenêtre "FEN_FTP", affichez le code du bouton "Connexion" :

1. Sélectionnez le bouton "Connexion".
2. Utilisez la touche F2 pour afficher le code associé :
// 1 - Adresse FTP : correspond au site FTP
// où l’application doit se connecter. Ex : 192.108.10.2
sAdresseFTP est une chaîne = "ftp.pcsoft.fr"
// 2 - Nom d’utilisateur : si ce nom n’est pas indiqué,
// une connexion de type "anonyme" sera utilisée
sNomUtilisateur est une chaîne = ""
// 3 - Mot de passe de l’utilisateur :
// utilisé uniquement si la connexion n’est pas anonyme
sMDPUtilisateur est une chaîne = ""
// Connexion au serveur FTP
gnIdConnexion = FTPConnecte(sAdresseFTP,sNomUtilisateur, ...
sMDPUtilisateur)
SI ErreurDétectée ALORS
// Une erreur a été rencontrée lors de la connexion
Erreur("La connexion au serveur FTP : " + ...
sAdresseFTP + " a échoué",ErreurInfo())
RETOUR
FIN
// La connexion est établie
Info("La connexion au serveur FTP est établie",...
"identifiant de connexion : "+gnIdConnexion)
Remarque : Il est également possible de préciser le numéro de port de connexion du serveur FTP
(par défaut "21") ainsi que le mode de connexion ("Vrai" pour une connexion dite "passive", "Faux"
pour une connexion dite "active"). Pour plus de détails, consultez l’aide en ligne (mot-clé : "FTP,
Fonctions").
Envoyer un fichier
Pour envoyer un fichier vers un serveur FTP, il suffit tout simplement d’utiliser la fonction FTPEn-
voie.
Voici un exemple de code pouvant être utilisé :
// Lors de la connexion au serveur avec FTPConnecte, nous avons
// récupéré le numéro de connexion dans la variable gnIdConnexion
// Transfert du fichier "C:\MesDocuments\Fichier.DOC" vers
// le répertoire "Temp" qui se trouve sur le serveur.
bResult est un booléen = FTPEnvoie(gnIdConnexion, ...
"C:\MesDocuments\Fichier.DOC", "/Temp")
Faites très attention à la casse (minuscules, majuscules) du nom des répertoires

sur le serveur. En effet, certains serveurs FTP sont des machines fonctionnant
sous UNIX et sont "case-sensitive", c’est-à-dire qu’ils sont sensibles à la casse du
Attention !
nom des fichiers et des répertoires.

Par exemple, sur le serveur FTP se trouve un répertoire nommé "MonRepertoire".
Si vous tentez d’accéder au répertoire "monrepertoire", le serveur FTP pourra
renvoyer une erreur du type "Chemin inexistant" car la casse utilisée n’est pas
correcte.
Lister les fichiers présents sur un serveur FTP
La fonction FTPListeFichier permet de lister les fichiers présents sur un serveur FTP. Cette fonc-
tion utilise une procédure de type "callback". Pour chaque fichier ou répertoire trouvé, la procé-
dure est exécutée.
Dans la fenêtre "FEN_FTP", affichez le code du bouton "Lister" :

1. Sélectionnez le bouton "Lister".
FTPListeFichier(gnIdConnexion,"*.*",...
"CallBackFTPListeFichier", ftpFichier+ftpRépertoire)
// Vérification de l’exécution de la fonction

Erreur("Erreur lors du parcours des fichiers présents sur le
serveur FTP",ErreurInfo())
RETOUR
FIN
3. Dans l’exemple, la procédure appelée permet d’afficher dans une fenêtre de trace les fi-
chiers trouvés.
PROCEDURE CallBackFTPListeFichier(sNomFichier,nTailleFichier
<utile>,sAttribut,sDateModif <utile>,sHeureModif <utile>)
// Est-ce un fichier ou un répertoire

SI sAttribut = "D" ALORS
// Répertoire ou sous-répertoire
Trace("Répertoire : "+sNomFichier)
SINON
// Fichier
Trace("Fichier : "+sNomFichier)
FIN
// Poursuite du parcours des fichiers

RENVOYER Vrai
Récupérer un fichier
Pour récupérer un fichier depuis un serveur FTP sur votre machine, il suffit d’utiliser la fonction
FTPRécupère.
Voici un exemple de code pouvant être utilisé :
// Lors de la connexion au serveur avec FTPConnecte, nous avons
// récupéré le numéro de connexion dans la variable gnIdConnexion
// Récupération du fichier "/Document/Fichier.DOC" présent
// sur le serveur FTP vers le répertoire "D:\Temp" sur
// le poste en cours
bRes est un booléen = FTPRécupère(gnIdConnexion, ...
"/Document/Fichier.DOC","D:\Temp")
Se déconnecter d’un serveur FTP

Pour se déconnecter d’un serveur FTP, utilisez la fonction FTPDéconnecte.
Dans la fenêtre "FEN_FTP", affichez le code du bouton "Déconnexion" :
1. Sélectionnez le bouton "Déconnexion".
SI OuiNon(Non, ...
"Voulez-vous fermer la connexion au serveur FTP ?")=Oui ALORS
// Déconnexion du serveur FTP
FTPDéconnecte(gnIdConnexion)
// Erreur lors de la fermeture de la connexion
Erreur("Impossible de fermer la connexion FTP",...
ErreurInfo())
RETOUR
FIN
// La connexion est terminée
Info("La connexion avec le serveur FTP est terminée")
FIN
Il existe également d’autres fonctions FTP que nous ne détaillerons pas dans ce cours. Elles per-
mettent notamment de :
• créer, supprimer, modifier des répertoires sur le serveur FTP,
• créer, supprimer, modifier des fichiers sur le serveur FTP,
• récupérer les informations d’un répertoire et/ou d’un fichier,
• ...
Pour plus de détails, consultez l’aide en ligne (mot-clé : "FTP, Fonctions").
Leçon 6.9. La POO
• Concepts de la programmation orientée objet.

• Exemples de déclaration d’objet.
• Modèle UML associé.
Concepts
La Programmation Orientée Objet (P.O.O.) a pour but de permettre une meilleure réutilisabilité du
code. Les programmes développés en POO sont structurés : ils sont décomposés en modules gé-
rant chacun une fonctionnalité du logiciel. Les modules développés peuvent être facilement réuti-
lisés dans d’autres logiciels. Ils vont regrouper un ensemble de procédures (appelées méthodes)
et encapsuler la structure de données sur laquelle les méthodes vont agir.
Pour programmer "en objet", il faut déclarer des classes, les membres et les méthodes associés.
Les classes
Une classe rassemble la description d’une structure de données (les membres) et les procédures
(méthodes) qui manipulent les membres.
Une classe définit donc un type de données et son comportement.
Les objets
Une classe permet de créer des objets. Chaque objet créé possède des membres décrits dans sa
classe et peut être manipulé par l’intermédiaire des méthodes de sa classe. On dit qu’un objet est
une instance de la classe.
Lorsque la classe est déclarée, il suffit d’associer un objet à une classe pour que l’objet puisse
être manipulé par toutes les méthodes de cette classe.
Les membres
Un membre est une donnée (ou paramètre) de l’objet.
Les méthodes
Une méthode permet d’agir sur l’objet, pour modifier ses membres par exemple.
Une méthode est une procédure. Son fonctionnement est identique à celui des procédures clas-
siques du WLangage.
Notion d’héritage
L’héritage permet d’inclure les caractéristiques d’une classe existante (classe de base) dans une
nouvelle classe (classe dérivée). L’héritage permet de créer un nouveau type de données à partir
d’un type connu, dans le but de lui ajouter des fonctionnalités ou d’en modifier le comportement.
La classe de base ne sera donc pas modifiée. Une classe peut hériter d’une classe dont elle
devient une sous-classe.
Une classe dérivée hérite des membres et des méthodes de sa classe mère (qui peut, elle-même,
être une sous-classe d’une autre classe mère), en plus de ses propres membres et méthodes
(et également des membres et méthodes de la première classe mère, s’il s’agit d’un héritage
multiple). Il n’est pas nécessaire de dupliquer les membres et méthodes de la ou des classe(s)
mère(s).
Constructeur et Destructeur
La notion de Constructeur et Destructeur est importante puisqu’elle permet un appel automa-
tique de méthodes d’initialisation lors de la création d’un objet et lors de sa destruction.
La méthode Constructeur associée à une classe est automatiquement appelée lors de la déclara-
tion d’un objet de la classe.
La méthode Destructeur associée à une classe est automatiquement appelée lors de la suppres-
sion de l’objet (sortie de procédure dans laquelle l’objet a été déclaré).
Encapsulation de données
L’encapsulation des données permet de garantir que les données membres de l’objet ne seront
pas modifiées à tort par des fonctions (méthodes) extérieures à l’objet.
Il est ainsi possible d’interdire à l’utilisateur d’un objet l’accès à certains ou à tous ses membres.
Les membres dont l’accès est interdit sont appelés membres privés.
Il n’est possible d’accéder à ces membres privés qu’à partir des méthodes prévues à cet effet
dans la classe.
Exemple
Prenons un exemple simple pour appliquer les concepts que nous venons de voir :
• Considérons la classe PERSONNE.
• Florence est une instance de la classe PERSONNE.
• Le nom, prénom et date de naissance peuvent être des membres de la classe PERSONNE.
• La méthode Age() peut être une méthode de la classe PERSONNE. Elle calculerait l’âge en se
basant sur le membre "date de naissance" et sur la date du jour (renvoyée par la fonction Date-
Sys).
• Héritage : Un contact peut être soit une personne, soit une entreprise.
• PERSONNE pourrait être une classe dérivée de CONTACT.
• ENTREPRISE pourrait être une classe dérivée de CONTACT.
Créer un programme orienté objet

Pour créer un programme en objet en WLangage, il faut :
1. Décrire la classe et les membres de la classe.
2. Donner toutes les méthodes de la classe.
3. Déclarer les objets en leur associant une classe ("instancier une classe").
Exemple simple
Pour illustrer les concepts que nous venons de présenter, nous allons manipuler l’exemple
didactique "POO Simple".
1. Ouvrez l’exemple didactique "POO Simple".
2. Testez cet exemple.
3. Cliquez sur les différents boutons correspondant aux animaux pour ajouter des animaux.
4. Arrêtez le test de l’exemple pour revenir sous l’éditeur.
Remarque : Nous ne détaillons pas ici la syntaxe de la P.O.O., nous présenterons uniquement un
exemple simple de programme orienté objet. Pour avoir plus de détail sur la syntaxe de la P.O.O.,
consultez l’aide en ligne et le manuel de programmation de WinDev (mot-clé : "POO, Classe").
Déclarer une classe
WinDev permet de déclarer les classes très simplement depuis l’explorateur de projet. Pour
créer une classe :
1. Dans l’explorateur de projet, sélectionnez le dossier "Classes".
2. Affichez le menu contextuel de ce dossier (clic droit de la souris) et sélectionnez l’option
"Nouvelle classe".
3. Dans la fenêtre qui s’affiche, indiquez le nom de la classe (par exemple TestGAF) et validez.
4. Le code de la classe s’affiche sous l’éditeur de code.
Consultez le code de la classe cSavane utilisée dans l’exemple.

1. Dans l’explorateur de projet, sélectionnez le dossier "Classes".
2. Ouvrez le dossier "Classes" (en cliquant sur la flèche présente devant le nom du dossier).
3. Double-cliquez sur la classe cSavane.
4. Le code de la classe s’affiche sous l’éditeur de code. Le code de déclaration de la classe
est de la forme :
cSavane est une Classe
PROTÉGÉ
// Nom du champ Image utilisé pour le dessin
m_sNomChampImagePourDessin est une chaîne
// Liste des animaux de la savane
m_tabLesAnimaux est un tableau de cAnimal dynamique
FIN
"cSavane" est le nom de la classe.
"m_sNomChampImgePourDessin" et "m_tabLesAnimaux" sont des membres de la classe.
Le mot-clé "PROTEGE" permet d’indiquer que ces membres seront manipulables uniquement de-
puis un code de la classe ou un code d’une classe dérivée.
Décrire les méthodes
WinDev permet de déclarer les méthodes très simplement depuis l’explorateur de projet.
Pour créer une méthode :
1. Cliquez avec le bouton droit de la souris sur votre classe présente dans l’explorateur de pro-
jet.
2. Choisissez "Nouvelle méthode" dans le menu contextuel.
3. Dans la fenêtre qui s’affiche, indiquez le nom de la méthode et validez.
4. Saisissez le code de la méthode sous l’éditeur de code.
Pour afficher la méthode AjouteAnimal de la classe cSavane :

1. Cliquez avec la souris sur votre classe présente dans l’explorateur de projet.
2. Cliquez sur la petite flèche devant le nom de la classe : les différentes méthodes de la
classe sont affichées.
3. Double-cliquez sur le nom de la méthode :
PROCEDURE AjouteAnimal(pclUnAnimal est un cAnimal dynamique)
// Pas plus de 5 animaux

SI m_tabLesAnimaux..Occurrence = 5 ALORS
Erreur("Pas plus de 5 animaux !")
RENVOYER Faux
FIN
// Ajoute l’animal à la liste

Ajoute(m_tabLesAnimaux, pclUnAnimal)
// Dessine la savane
DessineSavane()
RENVOYER Vrai
Déclarer et manipuler les objets
Dans les traitements de la fenêtre, un objet est déclaré en même temps que les autres variables :
// Déclarations globales de FEN_POO
PROCEDURE FEN_POO()
// Objet savane
gclLaSavane est un cSavane(IMG_Landscape..NomComplet)
Pour faire référence à un membre de l’objet "cSavane", il faut utiliser la syntaxe

<NomObjet>.<nom du membre>
Dans notre exemple, l’objet est manipulé :

• A l’initialisation de la fenêtre, pour construire la savane.
// Dessine la savane
gclLaSavane.DessineSavane()
• Lors de la création d’un animal, pour placer l’animal dans la savane.

// Déclare un nouvel éléphant
clElephant est un cElephant("Éléphant "+DonneIdentifiant(), 13)
// Ajoute l’éléphant dans la savane

// (cette action provoque le rafraîchissement du dessin)
SI gclLaSavane.AjouteAnimal(clElephant) ALORS
// Message de fin
ToastAffiche("Animal ajouté", toastCourt, cvMilieu, chCentre)
FIN
Nous ne nous attarderons pas plus sur la présentation de la POO dans ce cours.
Diagramme UML
L’exemple "POO Simple" est associé à un diagramme UML.
Pour afficher le diagramme UML lié au projet :
1. Double-cliquez sur "ModèleUML" dans l’explorateur de projet :
2. Le diagramme UML (diagramme de classes) lié au projet s’affiche.
3. Dans ce diagramme, nous retrouvons les différentes classes utilisées par le projet "WD POO
Simple".
WinDev permet de créer les 9 types de diagrammes UML.
Pour créer un diagramme UML :
1. Sous le volet "Accueil", dans le groupe "Général", cliquez sur "Nouveau".
2. Dans la roue qui s’affiche, survolez "Architecture" et cliquez sur "UML".
3. L’assistant de création d’un modèle UML se lance, vous permettant de
choisir le modèle à créer :
Notes
Nous ne détaillerons pas plus l’utilisation du langage UML avec WinDev. Consultez l’aide en ligne
pour plus d’informations (mot-clé : "UML").
454 Conclusion
Conclusion
Le cours est maintenant terminé !
Ce cours a abordé un ensemble de sujets, mais pas la totalité des fonctionnalités de WinDev, loin
s’en faut !
Vous êtes maintenant familiarisé avec les principaux concepts.
Explorez également les exemples livrés avec WinDev : certains sont simples et ne traitent que
d’un sujet, d’autres sont très complets. Ces exemples vous montreront les différentes facettes de
WinDev. La lecture du code source sera également instructive en général.
Faute de place, nous n’avons pas pu aborder tous les sujets (il y en a des centaines, voire des
milliers !). WinDev offre de nombreuses possibilités non abordées ou non approfondies dans ce
cours :
• fonctions HTTP, téléphonie
• création de gabarits ...
• états imbriqués, requêtes paramétrées ...
• compilation dynamique, appels de DLL, langages externes ...
Pour plus de détails sur toutes ces possibilités, n’hésitez pas à consulter l’aide en ligne.
Rappel : Pour recevoir directement des mises à jour intermédiaires et des conseils d’utilisation,
abonnez-vous à la LST (revue trimestrielle + DVD), en français.
Nous vous souhaitons de bons développements, avec WinDev 19, AGL n°1 en France !
Conclusion 455

Autoformation Windev Express 19

Transféré par

Droits d'auteur :

Formats disponibles

Autoformation Windev Express 19

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Autoformation Windev Express 19

Transféré par

Droits d'auteur :

Formats disponibles

WinDev 19 Express

Documentation version 19 (1) - 0614

Diffusion interdite sans l’accord écrit de PC SOFT

Adresse e-mail Support Technique Gratuit : [email protected]

Cette documentation n’est pas contractuelle. PC SOFT se réserve le droit de modifier ou de

PARTIE 1 - A la découverte de WinDev

Leçon 1.1. Découvrez WinDev

Leçon 1.2. Ma première fenêtre

Leçon 1.3. Des fenêtres plus évoluées

(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Sommaire 3

Leçon 1.4. Bases de programmation

4 Sommaire (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite

Leçon 1.5. Questions / Réponses

PARTIE 2 - Ma première base de données

Leçon 2.1. Présentation

Leçon 2.2. WinDev et les bases de données

Leçon 2.3. Projet et analyse

(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Sommaire 5

PARTIE 3 - Application complète avec données

Leçon 3.1. Présentation

Leçon 3.2. Fenêtres d’ajout et de modification

Leçon 3.3. Recherche simple et parcours des enregistrements

6 Sommaire (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite

Leçon 3.5. Imprimer le contenu d’un champ Table

Leçon 3.6. Imprimer une commande

Leçon 3.7. Imprimer une liste de clients

Leçon 3.8. Statistiques : champs Graphe et Tableau Croisé Dynamique

Leçon 3.9. Envoyer un email

Leçon 3.10. Identifier l’utilisateur : le groupware utilisateur

Leçon 3.11. Réutilisez du code grâce aux composants externes

Leçon 3.12. Consommer un Webservice

Leçon 3.13. Surveillez l’évolution de vos applications

8 Sommaire (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite

Leçon 3.15. Diffusez "Etats & Requêtes" avec vos applications

Leçon 3.16. Gérer le multilingue

(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Sommaire 9

PARTIE 4 - Administrer une base HFSQL Client/Serveur

Leçon 4.1. Introduction

Leçon 4.2. Mise en place d’une application Client/Serveur

Leçon 4.3. Administrer une base de données Client/Serveur

Leçon 4.4. Installation en clientèle

10 Sommaire (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite

Leçon 5.1. Présentation

Leçon 5.2. Audits du projet

Leçon 5.3. Analyseur de performances

Leçon 5.4. Débogage d’un projet

PARTIE 6 - Programmation avancée

Leçon 6.1. Présentation

Leçon 6.2. Gestion automatique des erreurs

Leçon 6.3. Manipuler des fichiers externes

(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Sommaire 11

Leçon 6.4. Compilation dynamique

Leçon 6.5. Evénement Windows

Leçon 6.6. Les threads

Leçon 6.7. Les sockets

Leçon 6.8. Le FTP

12 Sommaire (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite

(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Sommaire 13

(c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite Licence 15

16 Licence (c) PC SOFT - www.pcsoft.fr - Version Express - Diffusion interdite

L’aide peut être affichée :

Lancez WinDev 19 (si ce n’est déjà fait).

Pour créer la fenêtre :

Saisissez les informations suivantes :

Validez en cliquant sur le bouton vert.

Pour créer le champ de saisie :

Nous allons enregistrer la fenêtre et la tester :

Pour visualiser le résultat en exécution, relancez le test de cette fenêtre.

Pour modifier le masque de saisie :

Créez une nouvelle fenêtre vierge :

Pour créer le champ de saisie correspondant au prix HT :

Pour prendre en compte le montant de la TVA, à chaque modification de la valeur de la TVA

Créez une nouvelle fenêtre vierge :