Autoformation WINDEV PDF

WINDEV 23
Documentation version 23 (2) - 1217
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 2017 : 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
Introduction
Préliminaires.......................................................................................................................................................... 15
Présentation du cours d’auto-formation.............................................................................................................. 15
Légende des symboles utilisés dans ce guide..................................................................................................... 16
Comment accéder à l’aide en ligne ?................................................................................................................... 16
Si vous connaissez WINDEV 22............................................................................................................................. 19
Que fait-on avec WINDEV ?.................................................................................................................................... 19
PARTIE 1 - A la découverte de WINDEV
Leçon 1.1. Découvrez WINDEV

Présentation........................................................................................................................................................... 24
Lancement de WINDEV.......................................................................................................................................... 24
Environnement de développement....................................................................................................................... 25
L’éditeur.................................................................................................................................................... 25
La barre de menu (ruban) en détail......................................................................................................... 26
Les couleurs de l’environnement............................................................................................................ 27
Leçon 1.2. Ma première fenêtre

Présentation........................................................................................................................................................... 29
Ouverture du projet.................................................................................................................................. 29
Ma première fenêtre : saisir et afficher des données.......................................................................................... 30
Présentation............................................................................................................................................. 30
Création de la fenêtre.............................................................................................................................. 30
Saisie et affichage de la valeur saisie..................................................................................................... 31
Améliorations de la fenêtre..................................................................................................................... 36
WINDEV : Concepts de base et terminologie....................................................................................................... 38
Concepts de base..................................................................................................................................... 38
Terminologie............................................................................................................................................. 39
PARTIE 2 - Les bases du WLangage
Leçon 2.1. Les variables

Qu’est ce qu’une variable ?....................................................................................................................................44
Déclarer une variable............................................................................................................................... 45
Affectation et utilisation........................................................................................................................... 45
Les types de variables............................................................................................................................................ 46
La portée des variables.......................................................................................................................................... 46
Portée Globale.......................................................................................................................................... 46
Portée Locale........................................................................................................................................... 47
Schéma récapitulatif de la portée........................................................................................................... 47
Sommaire 3
Opérations simples sur les variables.................................................................................................................... 48
Conseils.................................................................................................................................................... 49
Détail d’un type de variable : les variables de type Chaîne................................................................................. 49
Le type Chaîne.......................................................................................................................................... 49
Exemple pratique..................................................................................................................................... 50
Détail d’un autre type de variable : les tableaux..................................................................................................54
Déclaration............................................................................................................................................... 54
Remplissage d’un tableau et accès aux éléments................................................................................. 54
Des tableaux avancés.............................................................................................................................. 55
Leçon 2.2. Les instructions conditionnelles

Présentation........................................................................................................................................................... 57
Les instructions SI et SELON.................................................................................................................................. 57
L’instruction SI......................................................................................................................................... 57
L’instruction SELON................................................................................................................................. 58
Exemple pratique : Utilisation de l’instruction SI et SELON................................................................................ 59
Projet manipulé........................................................................................................................................ 59
Création des champs de la fenêtre pour l’instruction conditionnelle SI............................................... 60
Instruction conditionnelle SI.................................................................................................................... 61
Création des champs de la fenêtre pour l’instruction conditionnelle SELON....................................... 62
Instruction conditionnelle SELON........................................................................................................... 63
Leçon 2.3. Les boucles

Présentation........................................................................................................................................................... 66
L’instruction POUR................................................................................................................................... 66
L’instruction BOUCLE............................................................................................................................... 66
L’instruction TANTQUE............................................................................................................................. 67
Exemple pratique : Utilisation des boucles.......................................................................................................... 68
Projet manipulé........................................................................................................................................ 68
Création des champs............................................................................................................................... 68
Test de la fenêtre...................................................................................................................................... 71
Leçon 2.4. Les procédures

Présentation........................................................................................................................................................... 73
Types de procédures.............................................................................................................................................. 73
Création et appel d’une procédure....................................................................................................................... 73
Procédure globale.................................................................................................................................... 73
Procédure locale...................................................................................................................................... 73
Procédure interne.....................................................................................................................................74
Appel d’une procédure..............................................................................................................................74
Paramètres d’une procédure................................................................................................................................ 74
Qu’est-ce qu’un paramètre ?....................................................................................................................74
Paramètres obligatoires ou optionnels ?................................................................................................ 76
Résultat d’une procédure...................................................................................................................................... 76
4 Sommaire
Exemple pratique : Utilisation d’une procédure................................................................................................... 77
Projet manipulé........................................................................................................................................ 77
Mise en place........................................................................................................................................... 77
Création et utilisation d’une procédure.................................................................................................. 80
Conclusion............................................................................................................................................................... 81
Leçon 2.5. Questions / Réponses

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

Présentation du projet réalisée dans cette partie............................................................................................... 90
Leçon 3.2. WINDEV et les bases de données

Présentation........................................................................................................................................................... 92
HFSQL...................................................................................................................................................................... 93
Les différents modes d’accès aux bases de données......................................................................................... 93
Connecteur Natif (Accès Natif)................................................................................................................ 93
Accès ODBC direct.................................................................................................................................... 94
Accès OLE DB........................................................................................................................................... 94
Accès ODBC via OLE DB........................................................................................................................... 94
Leçon 3.3. Projet et analyse

Présentation........................................................................................................................................................... 96
Création du projet................................................................................................................................................... 96
Création de l’analyse.............................................................................................................................................. 98
Création de la description des fichiers de données............................................................................................. 99
Création d’un fichier de données : utilisation d’un fichier prédéfini....................................................100
Création d’un fichier de données : création du fichier et des rubriques.............................................. 101
Importation d’un fichier CSV..................................................................................................................106
Importation directe de fichiers de données existants..........................................................................109
Création des liaisons........................................................................................................................................... 109
Génération de l’analyse...................................................................................................................................... 116
Sommaire 5
Leçon 3.4. Le RAD complet
Qu’est-ce que le RAD ? ....................................................................................................................................... 119
Génération du RAD.............................................................................................................................................. 120
Test de l’application............................................................................................................................................ 123
PARTIE 4 - Application complète avec données

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

Présentation........................................................................................................................................................ 132
Création d’une fenêtre listant les produits........................................................................................................ 132
Création de la fenêtre............................................................................................................................132
Création des champs.............................................................................................................................134
Test de la fenêtre....................................................................................................................................136
Création d’une fenêtre "Fiche produit".............................................................................................................. 139
Création de la fenêtre............................................................................................................................139
Création des champs de saisie.............................................................................................................139
Création des boutons.............................................................................................................................142
Améliorations de l’interface de la fenêtre.............................................................................................142
Affichage de la fiche depuis la liste des produits..................................................................................146
Gestion de la modification d’un produit............................................................................................................ 148
Modification de l’image du produit........................................................................................................148
Validation des modifications du produit...............................................................................................149
Test de la modification d’un produit...................................................................................................... 151
Création d’un nouveau produit........................................................................................................................... 152
Ajout d’un bouton...................................................................................................................................152
Ajout dans le fichier de données...........................................................................................................153
Test de l’ajout d’un produit....................................................................................................................154
Visualiser les enregistrements saisis....................................................................................................155
Leçon 4.3. Recherche simple et parcours des enregistrements

Présentation........................................................................................................................................................ 158
Modification de la fenêtre : utilisation d’un champ Onglet.............................................................................. 159
Création du champ Onglet.....................................................................................................................159
Modifications du champ Onglet............................................................................................................. 161
Mise en place de la recherche............................................................................................................................ 163
Zone d’affichage des informations trouvées........................................................................................163
Recherche à l’identique.........................................................................................................................164
Recherche générique.............................................................................................................................169
Parcours des fiches................................................................................................................................ 171
Test de la fenêtre.................................................................................................................................... 174
6 Sommaire
Leçon 4.4. Recherche multicritère
Présentation.........................................................................................................................................................176
Création de la requête pour rechercher les commandes.................................................................................177
Création de la requête............................................................................................................................ 177
Test de la requête...................................................................................................................................180
Utilisation de paramètres dans la requête...........................................................................................181
Test de la requête paramétrée..............................................................................................................184
Création de l’interface pour réaliser une recherche multicritère.................................................................... 184
Modifications du champ Onglet.............................................................................................................184
Création des champs de paramétrage des critères et affichage du résultat......................................186
Leçon 4.5. Imprimer le contenu d’un champ Table

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

Présentation........................................................................................................................................................ 204
Création de l’état "Bon de commande"............................................................................................................. 204
Création de la requête............................................................................................................................205
Création de l’état basé sur une requête................................................................................................208
Modifications de l’état "Bon de commande"........................................................................................215
Affichage de l’état imprimé depuis une option de menu..................................................................................216
Création du menu contextuel................................................................................................................ 216
Association du menu contextuel au champ Table................................................................................218
Test de l’impression...............................................................................................................................218
Leçon 4.7. Imprimer une liste de clients

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

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

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

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

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

Présentation........................................................................................................................................................ 281
Exemple pratique...................................................................................................................................281
Importation d’un Webservice............................................................................................................................. 281
Consommation d’un Webservice....................................................................................................................... 284
Leçon 4.13. Surveillez l’évolution de vos applications

Présentation........................................................................................................................................................ 287
Le tableau de bord............................................................................................................................................... 287
Tests automatiques............................................................................................................................................. 288
Leçon 4.14. Déployer l’application

Présentation........................................................................................................................................................ 293
Création de l’exécutable..................................................................................................................................... 293
Création de l’installation..................................................................................................................................... 298
Installation d’une application............................................................................................................................. 301
8 Sommaire
Les différents types de déploiement................................................................................................................. 302
Présentation...........................................................................................................................................302
Installation avec mise à jour réseau......................................................................................................303
Installation avec mise à jour Internet....................................................................................................305
Installation multisite..............................................................................................................................305
Leçon 4.15. Diffusez "Etats et Requêtes" avec vos applications

Lancement du logiciel "Etats et Requêtes"....................................................................................................... 308
Paramétrage du projet...........................................................................................................................309
Paramétrage de l’analyse......................................................................................................................309
Paramétrage des états.......................................................................................................................... 310
Paramétrage des requêtes.................................................................................................................... 311
Création de l’exécutable et diffusion de l’application.......................................................................... 311
Installer et utiliser le logiciel "Etats et Requêtes"............................................................................................. 313
Installation de l’application................................................................................................................... 313
Test de l’application............................................................................................................................... 315
Conclusion.............................................................................................................................................................317
Leçon 4.16. Gérer le multilingue

Qu’est-ce qu’une application multilingue ?........................................................................................................319
Choix des langues du projet.................................................................................................................................319
Internationalisation de l’analyse........................................................................................................................ 321
Internationalisation des éléments du projet..................................................................................................... 323
Internationalisation d’une image..........................................................................................................324
Internationalisation des champs...........................................................................................................325
Internationalisation d’un message de programmation.......................................................................325
Internationalisation des menus............................................................................................................326
Les outils de traduction....................................................................................................................................... 327
Saisie directe des traductions...............................................................................................................327
Traduction avec WDMSG et WDTRAD...................................................................................................328
Autres éléments à traduire : les messages du framework...................................................................328
Programmation du changement de langue...................................................................................................... 329
Ajout d’une option de menu..................................................................................................................329
Programmation......................................................................................................................................329
Test du projet..........................................................................................................................................330
Leçon 4.17. GDS

Introduction.......................................................................................................................................................... 332
GDS (Gestionnaire de Sources).......................................................................................................................... 332
Principe du GDS.....................................................................................................................................332
Création de la base de sources.............................................................................................................333
Intégration d’un projet dans le GDS................................................................................................................... 334
Ajouter le projet dans le GDS.................................................................................................................334
Ouverture du projet depuis le GDS........................................................................................................337
Configuration du GDS............................................................................................................................338
Sommaire 9
Manipulation du projet via le GDS...................................................................................................................... 339
Modification d’un paramètre du projet.................................................................................................339
Modification d’une fenêtre du projet.....................................................................................................340
Réintégration de l’élément extrait.........................................................................................................342
Synchronisation du projet......................................................................................................................343
Mode déconnecté (ou nomade)............................................................................................................344
Administrateur du GDS..........................................................................................................................344
Déconnexion du GDS.............................................................................................................................345
Conclusion............................................................................................................................................................ 345
PARTIE 5 - Administrer une base HFSQL Client/Serveur
Leçon 5.1. Introduction

Présentation........................................................................................................................................................ 350
Pourquoi passer une application en mode HFSQL Client/Serveur ?............................................................... 351
Leçon 5.2. Mise en place d’une base de données Client/Serveur

Présentation........................................................................................................................................................ 353
Installation d’un serveur HFSQL local................................................................................................................ 353
Création d’une application utilisant une base de données HFSQL Client/Serveur....................................... 354
Adaptation d’une application pour utiliser une base de données HFSQL Client/Serveur............................ 354
Présentation...........................................................................................................................................354
Adaptation de l’exemple........................................................................................................................354
Fonctionnalités disponibles en mode HFSQL Client/Serveur......................................................................... 358
Leçon 5.3. Administrer une base de données Client/Serveur

Présentation........................................................................................................................................................ 360
Configuration des postes.................................................................................................................................... 360
Le Centre de Contrôle HFSQL............................................................................................................................. 360
Créer un compte utilisateur dans le Centre de Contrôle HFSQL...................................................................... 362
Sauvegarder la base de données....................................................................................................................... 367
Conclusion............................................................................................................................................................ 367
Leçon 5.4. Installation en clientèle

Présentation........................................................................................................................................................ 369
Lancement de l’assistant de création d’installation........................................................................................ 369
PARTIE 6 - Optimiser et déboguer un projet

Présentation.........................................................................................................................................................374
Ouverture du projet................................................................................................................................ 374
10 Sommaire
Leçon 6.2. Audits du projet
Qu’est-ce qu’un audit ? ........................................................................................................................................376
Audit statique........................................................................................................................................................376
Procédure non exécutée........................................................................................................................378
Elément orphelin....................................................................................................................................379
Nettoyage du projet................................................................................................................................380
Audit dynamique................................................................................................................................................. 380
Leçon 6.3. Analyseur de performances

Présentation........................................................................................................................................................ 385
Lancer l’analyseur de performances................................................................................................................. 385
Analyse du résultat.............................................................................................................................................. 386
Leçon 6.4. Débogage d’un projet

Présentation....................................................................................................................................................... 392
Utiliser le débogueur........................................................................................................................................... 392
PARTIE 7 - Programmation avancée

Présentation........................................................................................................................................................ 400
Leçon 7.2. Gestion automatique des erreurs

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

Présentation........................................................................................................................................................ 408
Manipulation des fichiers texte ou CSV............................................................................................................. 408
Présentation...........................................................................................................................................408
Manipulation des répertoires............................................................................................................................. 409
Manipulation des fichiers XML............................................................................................................................410
Présentation........................................................................................................................................... 410
Exemple pratique................................................................................................................................... 411
Manipulation des fichiers XLS.............................................................................................................................411
Exemples pratiques............................................................................................................................... 412
Sommaire 11
Leçon 7.4. Compilation dynamique
Présentation.........................................................................................................................................................414
Exemple.................................................................................................................................................................414
Leçon 7.5. Evénement Windows

Introduction...........................................................................................................................................................417
Exemple pratique................................................................................................................................... 417
Traitements optionnels proposés par WINDEV..................................................................................................417
Evénements de Windows.................................................................................................................................... 418
Exemple : Détecter le clic sur une liste.................................................................................................. 419
Leçon 7.6. Les threads

Définition.............................................................................................................................................................. 422
Exemple................................................................................................................................................................ 422
Leçon 7.7. Les sockets

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

Présentation........................................................................................................................................................ 429
Se connecter à un serveur FTP........................................................................................................................... 429
Envoyer un fichier................................................................................................................................................ 430
Lister les fichiers présents sur un serveur FTP...................................................................................................431
Récupérer un fichier............................................................................................................................................ 432
Se déconnecter d’un serveur FTP....................................................................................................................... 432
Leçon 7.9. La POO

Concepts............................................................................................................................................................... 434
Les classes.............................................................................................................................................434
Les objets...............................................................................................................................................434
Les membres..........................................................................................................................................434
Les méthodes.........................................................................................................................................434
Notion d’héritage....................................................................................................................................434
Constructeur et Destructeur..................................................................................................................435
Encapsulation de données....................................................................................................................435
Exemple..................................................................................................................................................435
Créer un programme orienté objet........................................................................................................435
12 Sommaire
Exemple simple................................................................................................................................................... 436
Déclarer une classe...............................................................................................................................436
Décrire les méthodes.............................................................................................................................437
Déclarer et manipuler les objets...........................................................................................................438
Diagramme UML................................................................................................................................................. 439
PARTIE 8 - Annexes
Annexe 1. Vocabulaire

Principaux termes utilisés.................................................................................................................................. 444
Annexe 2. Utiliser des données SQL

Présentation........................................................................................................................................................ 451
Création du projet................................................................................................................................................ 451
Création de l’analyse........................................................................................................................................... 453
Génération de l’analyse...................................................................................................................................... 455
Conclusion
Sommaire 13
14 Sommaire
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
familiariser 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 les quelques heures passées sur ce cours d’auto-formation.
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 (toutes les manipulations sont illustrées). Toutefois, pour
que les concepts soient plus rapidement assimilés, il est préférable d’effectuer les manipu-
lations.
WINDEV évoluant en permanence, les images des fenêtres illustrant le cours peuvent être diffé-
rentes des fenêtres affichées par le produit lors des différentes manipulations.
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 !
Introduction 15
Légende des symboles utilisés dans ce guide
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 via
la fenêtre de bienvenue 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.
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 3500
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].
• Les fenêtres de dialogue affichées par WINDEV peuvent proposer 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.
16 Introduction
L’aide peut être affichée :
• dans un "browser d’aide" spécifique :
• dans un navigateur Internet, si vous avez accès à Internet :
Introduction 17
Nous vous suggérons de consulter l’aide en ligne sur Internet plutôt que l’aide en
ligne locale. En effet, l’aide en ligne Internet est régulièrement mise à jour.
L’aide en ligne de WINDEV, WEBDEV et WINDEV Mobile sur Internet est acces-
Notes
sible depuis n’importe quel poste disposant d’un accès Internet, sans que le pro-
duit soit forcément installé.
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.
18 Introduction
Si vous connaissez WINDEV 22...
Si vous connaissez déjà WINDEV 22, 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 environnement 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 !
Introduction 19
20 Introduction
PARTIE 1
A la découverte
de WINDEV
22 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
Partie 1 : A la découverte de WINDEV 23

Présentation
WINDEV est un AGL (Atelier de Génie Logiciel) complet permettant de développer des applications
Windows (et Linux) dans de nombreux domaines : gestion, industrie, médical, ... Les applications
développé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 23 (si ce n’est déjà fait).

Si vous n’avez jamais lancé WINDEV 23, 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 23, identifiez-vous si nécessaire. L’environnement de
développement se lance. La fenêtre de bienvenue apparaît. Cette fenêtre de bienvenue
permet de :
• créer un projet,
• ouvrir un projet existant,
• ouvrir un exemple,
• ouvrir un des projets du cours d’auto-formation.
Arrêtons-nous un instant sur l’environnement de développement de WINDEV. Pour cela,
depuis la fenêtre de bienvenue :
• Cliquez sur "Cours d’auto-formation".
• Double-cliquez sur "Application complète (avec fenêtres)".
• Le projet correspondant s’ouvre sous l’éditeur.

Environnement de développement
L’éditeur
L’environnement de développement de WINDEV est constitué d’une interface spécifique et de
plusieurs é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. Par exemple :
• le volet "Explorateur de projet" (ici, affiché à droite) permet de lister tous les éléments du projet
par catégorie.
• le volet de recherche (ici, affiché en bas) permet de réaliser des recherches dans tout le projet
et ses éléments.
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 (1).
• la zone des volets en haut (2).
• la zone des options (3).
Voyons ces différentes zones en détail.
La zone des boutons (1)

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 logos 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.
• Les 2 logos suivants permettent de retrouver les barres d’outils et les me-
nus déroulants de l’ancienne interface des éditeurs.
La zone des volets (2)
Les différents volets du ruban permettent d’accéder aux options des différents éditeurs pour le
projet en cours. Plusieurs types de volets sont disponibles :
• le volet en cours : L’onglet du volet apparaît en blanc et un trait orange pâle est affiché en haut
de l’onglet.
• les volets contextuels, spécifiques à l’élément en cours : Le nom du volet est affiché en bleu.
• les volets disponibles : Le nom du volet apparaît en noir.

La zone des options (3)
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".
Les couleurs de l’environnement

Par défaut, l’environnement utilise un thème clair.
Deux autres thèmes sont également disponibles :
• Thème clair, ruban gris. Dans ce mode, la barre de menu n’est plus colorée : elle est grise.
• Thème foncé. Dans ce mode, l’environnement et les différentes fenêtres de l’interface sont affi-
chées sur fond noir ou gris foncé.
Pour modifier le thème utilisé par l’environnement :
l’option "Options générales de WINDEV".
2. Dans l’onglet "Editeur", dans la zone "Thèmes", sélectionnez le thème de l’éditeur à utiliser.
3. Validez. Le thème sera pris en compte au prochain lancement de WINDEV.
Remarque : Pour une meilleure lisibilité de ce manuel, nous avons choisi d’utiliser le thème clair
pour les différentes images illustrant les manipulations à réaliser.

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 une fenêtre.
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, ...
Nous allons voir comment :

• Ouvrir un projet,
• Créer et enregistrer une fenêtre,
• Saisir et afficher des données.
Ces premières manipulations vous permettront de connaître les bases du développement avec
WINDEV. Vous pourrez ainsi aborder dans les parties suivantes des sujets plus complets.
Ouverture du projet
Lancez WINDEV 23 (si ce n’est déjà fait). Si nécessaire, affichez la fenêtre de bienvenue de
WINDEV : utilisez la combinaison de touches [CTRL <].
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 partie (ainsi que dans la partie 2). 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. La fenêtre de création d’un nouvel élément s’affiche. Cette fenêtre permet de créer tous les
éléments pouvant être associés à un projet.
3. Cliquez sur "Fenêtre" puis 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. La fenêtre de sauvegarde de

l’élément créé apparaît. Cette fenêtre permet de renseigner :
• Le titre de l’élément. Pour une fenêtre, ce titre sera affiché dans la barre de titre de la fe-
nêtre.
• Le nom de l’élément. Ce nom correspond au nom logique de l’élément. Ce nom sera utilisé
pour manipuler l’élément par programmation.
• L’emplacement de l’élément. Cet emplacement correspond au répertoire de sauvegarde de
l’élément.

6. Indiquez le titre de l’élément "Ma première fenêtre" (ici, l’élément correspond à la fenêtre
WINDEV). Le nom de l’élément "FEN_Ma_première_fenêtre" est automatiquement proposé.
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".
7. Pour cet exemple, nous voulons utiliser un nom de fenêtre plus court : remplacez "FEN_Ma_
première_fenêtre" par "FEN_Bienvenue".
8. Validez les informations affichées dans la fenêtre de sauvegarde 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 manuellement 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
édition.
Pour éditer rapidement le libellé d’un champ, il est également possible de :

Astuce
• Sélectionner le champ.
• Appuyer sur la touche [ENTREE] ou [ESPACE].
4. Saisissez le libellé "Afficher". Le nom du bouton devient automatiquement "BTN_Afficher".

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

Le WLangage est le langage de programmation fourni avec WINDEV. C’est un
langage de 5ème génération (L5G), possédant des ordres évolués.
Conventions du WLangage à connaître
• Le WLangage n’utilise pas de caractère de terminaison de fin de ligne.
• Les caractères ‘//’ permettent de mettre des lignes de code en commentaire.
Ces lignes de code ne sont pas interprétées. Elles permettent une meilleure
lisibilité du code.
• Dans les fonctions WLangage, les parenthèses entourent les paramètres pas-
sés à la fonction.
Notes
• Le caractère virgule sert de séparateur de paramètres.

• Le WLangage n’est pas sensible à la casse.
• Les caractères "espace" ne sont pas interprétés.
• Le point est le séparateur décimal.
• Le nom des fonctions WLangage est en français. Il est également disponible
en anglais en standard.
• Le nom des fonctions WLangage utilise un préfixe afin de regrouper les fonc-
tions par famille ("Fen" pour les fonctions manipulant les fenêtres, "email" pour
les fonctions manipulant les emails, ...).
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.
L’éditeur de code propose différents traitements pour chaque type de champ.

Ces traitements correspondent aux événements liés au champ.
Ainsi, pour le champ "Bouton", deux traitements sont affichés :
Notes
• Initialisation,
• Clic sur le bouton, exécuté lorsque l’utilisateur clique sur le bouton.
Remarque : Des traitements supplémentaires peuvent être ajoutés si néces-
saire.
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 deux premiers caractères, WINDEV propose
tous les mots du vocabulaire WLangage contenant ces caractères. L’assistance au développe-
ment est poussée très loin. Vous ne pouvez plus vous tromper en saisissant le nom d’un élément :
les erreurs de syntaxe sont minimisées. Il suffit de sélectionner le mot désiré et de valider par la
touche [ENTREE]. 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. Ainsi, dans l’éditeur de code utilisant le thème clair :
• 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 sur une ou plusieurs lignes. Notre mes-
sage est construit à partir du texte "Bonjour " et de la valeur du champ "SAI_Prénom". Le signe ","
sépare les paramètres de la fonction Info. Chaque paramètre est affiché sur une ligne différente.
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 tester la fenêtre :

1. Cliquez sur parmi les boutons d’accès rapide (ou utilisez la touche [F9]).
2. La fenêtre que vous avez créée est automatiquement sauvegardée puis elle se lance en
exécution.
3. 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".
Une erreur est affichée dans le volet "Erreurs de compilation". Cette erreur indique que la
fenêtre est redimensionnable mais qu’aucun ancrage n’est défini. Ne vous inquiétez pas :
Nous allons traiter cette erreur dans le paragraphe suivant.

Lors du développement d’une application, WINDEV vous informe au fur et à
mesure du développement des problèmes potentiels de votre application via le
volet "Erreurs de compilation".
Ce volet présente différents types d’erreurs :
• Erreurs de compilation : Les erreurs signalent un problème grave (erreur de
programmation, ...). Le test ou l’exécution du projet ne pourra pas fonctionner.
Notes
• Warning de compilation : Les warnings signalent des cas de programmation

pouvant entraîner des comportements inattendus.
• Informations de compilation : Les informations expliquent les choix du compila-
teur ou présentent d’éventuels conseils pour améliorer le code.
• Erreurs d’IHM : Les erreurs de compilation d’IHM vous informent des pro-
blèmes potentiels détectés sur vos interfaces : images inexistantes, libellés
tronqués, ...
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.
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 type de saisie peut poser pro-
Notes blème lors d’une recherche par exemple.
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 réapparaît.
Fermez la fenêtre "FEN_Bienvenue" affichée sous l’éditeur : sous le volet "Accueil", dans le
groupe "Général", cliquez sur "Fermer".

Un exemple pour chaque type de champ
Dans cette leçon, nous avons utilisé deux types de champs : un champ de saisie
et un bouton.
WINDEV propose plus d’une cinquantaine 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 la fenêtre de bienvenue de WINDEV (touches CTRL + <).
Notes
2. Cliquez si nécessaire sur "Ouvrir un exemple".

3. La liste des exemples complets, didactiques et unitaires s’affiche.
4. 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, tous les exemples unitaires correspondant aux
champs commencent par les mots "Le champ ". Vous pouvez saisir ces mots
dans le champ de recherche de la fenêtre de bienvenue.
Fermez le projet : sous le volet "Accueil", dans le groupe "Général", déroulez "Fermer" et
sélectionnez "Fermer le projet".
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).
Projet 1
Classes Feuille Fenêtres

de styles et champs
Analyse
Projet 2 Projet N
Classes Feuille Fenêtres Classes Feuille Fenêtres

de styles et champs de styles et champs
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 signification 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 par exemple :

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

PARTIE 2
Les bases du
WLangage
42 Partie 2 : Les bases du WLangage
Leçon 2.1. Les variables
• Qu’est-ce qu’une variable ?

• Les différents types de variables
• La portée des variables
• Le type Chaîne en détail
• Le type Tableau en détail
Durée estimée : 1 heure
Partie 2 : Les bases du WLangage 43

Qu’est ce qu’une variable ?
Dans un langage de programmation, une variable permet de conserver des données. Ce sont des
parties de la mémoire qui contiennent des chaînes, des nombres, etc.
Les variables permettent d’effectuer des calculs mathématiques, de faire des comparaisons ou
tout simplement de stocker des informations pour les retrouver plus tard.
Une variable est représentée par :

• un nom : Nom donné à la variable afin de la manipuler par le langage.
• un type : Nature de la donnée stockée dans la variable (voir Types de variables).
• une valeur : Information stockée dans la variable.
• une portée : Limite d’utilisation de la variable dans le programme. (voir Portée des variables). La
portée est définie principalement par l’endroit où la variable est déclarée.

Déclarer une variable
Avant d’utiliser une variable, il faut tout d’abord la déclarer (c’est-à-dire la créer).
• Exemple de déclaration simple :
Prix est un monétaire
• Prix représente le nom de la variable.
• est un permet de déclarer la variable. Le WLangage utilise le langage naturel en français.
• monétaire correspond au type de la variable.
• Exemple de déclaration multiple :
Nom, Prénom sont des chaînes
• Nom, Prénom représentent les noms des variables.
• sont des permet de déclarer un ensemble de variables.
• chaînes représente le type des variables.
Affectation et utilisation
Lorsque la variable est déclarée, il est possible de l’affecter (ou lui donner une valeur).
Par exemple :
// Affectation d’une variable de type monétaire
Prix = 1256.67
// Affectation d’une variable de type chaîne
Nom = “Dupont”
L’opérateur = permet d’effectuer cette affectation.
En WLangage, le caractère " (double quote) est le caractère utilisé pour délimiter
Notes
une chaîne de caractères. Dans l’exemple ci-dessus, les doubles quotes sont uti-
lisées pour affecter la valeur Dupont à la variable Nom.
Le contenu d’une variable peut aussi être lu et manipulé : il suffit tout simplement d’utiliser le
nom donné à la variable pour y accéder.
L’exemple suivant permet de lire et d’afficher le contenu de la variable Prix à l’écran :
Info(Prix)

Les types de variables
Le type de la variable permet d’indiquer quelle est la forme de l’information que l’on stocke dans
la variable. Les types les plus basiques sont :
• booléen (Vrai ou Faux),
• chaîne ("Dupont"),
• entier (1234),
• monétaire (12.32),
• réel (7.766666),
• etc.
Utilisez le type correspondant à l’information que vous voulez stocker. Vous opti-
Important
misez ainsi l’utilisation de la mémoire mais surtout vous évitez des erreurs de
calcul ou de traitement lors de l’utilisation des variables dans les fonctions du
WLangage.
Pendant ce cours d’auto-formation, nous allons utiliser la plupart de ces types de variables. Pour
plus de détails, consultez l’aide en ligne concernant le type voulu.
D’autres types existent comme les tableaux, les structures, les dates, les heures,
...
Il existe également des variables de type "avancé". Ces types avancés regroupent
Notes
toutes les caractéristiques de l’élément manipulé en une seule variable.

Il existe des types avancés notamment pour manipuler les documents XML, les
emails, les fichiers XLS, ... Nous manipulerons ce type de variable dans la suite
de ce cours.
La portée des variables

Il est possible de déclarer les variables à n’importe quel endroit dans le code. Cependant, en fonc-
tion de la position de sa déclaration, la variable n’est pas utilisable (ou visible) pour effectuer des
traitements ou des calculs. On parle alors de portée des variables.
Il existe 2 types de portée :
• Globale.
• Locale.
Portée Globale
Le terme Global(e) signifie que la variable a une visibilité étendue dans le code. La variable est
visible en dehors de l’endroit où elle a été déclarée. Il y a plusieurs niveaux de Globalité :
• niveau Projet et Collection de procédures,
• niveau Fenêtre, Fenêtre Mobile, Page, Etat.

Une variable déclarée au niveau du projet a la visibilité la plus importante dans le programme. La
variable est visible partout, dans tous les traitements du programme. Attention toutefois à ne pas
trop déclarer de variables de cette portée : en effet, la mémoire occupée par la variable est tou-
jours réservée même si la variable n’est pas utilisée. L’utilisation massive de variables globales
n’est pas conseillée dans l’architecture d’un programme informatique. Pour passer les variables
à un traitement, il est conseillé d’utiliser des paramètres (pour plus de détails, consultez "Para-
mètres et résultat d’une procédure", page 74).
Une variable déclarée au niveau d’une Collection de procédures à la même visibilité qu’une va-
riable déclarée au niveau du projet. L’avantage de déclarer une variable au niveau d’une Collec-
tion est de regrouper (ou classer) les variables par thème (collection) afin de rendre plus lisible le
traitement d’initialisation du projet.
Une variable déclarée au niveau d’une Fenêtre, Fenêtre Mobile, Page ou Etat limite la portée de
la variable à tous les traitements de l’élément (Fenêtre, Fenêtre Mobile, Page ou Etat) et de ses
champs. Cela permet d’encapsuler et de limiter les utilisations.
Portée Locale
Le terme Local(e) signifie que la variable a une visibilité très limitée dans le code. La variable est
visible uniquement dans le traitement où elle a été déclarée. Cela permet ainsi de restreindre
l’utilisation de la variable au traitement.
Schéma récapitulatif de la portée
Chaque niveau a accès aux variables des

niveaux supérieurs.
Projet
Variables globales
Procédures globales
IHM
(Fenêtres, Pages, Fenêtres Mobile, Etats)
Variables globales
Procédures locales
Traitements
Variables locales
Une variable est globale lorsqu’elle est déclarée :

• dans le code d’initialisation du projet (ou dans le code de déclaration de la collection de procé-
dures). La variable est globale au projet.
• dans le code de déclaration des globales de la fenêtre, de la page ou de l’état. La variable est
globale à l’élément (fenêtre, page ou état) dans lequel elle a été déclarée.
Dans tous les autres cas, une variable est locale au traitement dans lequel elle est déclarée.

Opérations simples sur les variables
Pour effectuer des calculs sur des variables, le WLangage met à disposition les opérateurs mathé-
matiques classiques :
• + pour faire une addition.
• - pour faire une soustraction.
• * pour faire une multiplication.
• / pour faire une division.
D’autres opérateurs peuvent être utilisés pour réaliser des calculs :

• ++ pour incrémenter de 1 (additionner 1 à la variable).
• - - pour décrémenter de 1 (soustraire 1 à la variable).
• += pour affecter en additionnant une valeur.
• - = pour affecter en soustrayant une valeur.
Exemples :
// Déclaration de variables
Cpt est un entier
V1 est un entier
Res est un numérique
// Affectation
Cpt = 10
V1 = 3
// Utilisation des opérateurs

Cpt = Cpt + 3 // Cpt vaut 13
Cpt ++ // Cpt vaut 14
Cpt -= 8 // Cpt vaut 6
Cpt = Cpt * V1 // Cpt vaut 18
Res = Cpt / 5 // Res vaut 3.6
Des opérateurs de comparaison sont également disponibles :

• < inférieur strict
• > supérieur strict
• <= inférieur ou égal
• >= supérieur ou égal
• <> différent de
• = égal à
D’autres opérateurs sont disponibles. Pour plus de détails sur les opérateurs, consulter l’aide en
ligne (mot-clé : "Opérateurs").

Conseils
• Il est très pratique de nommer les variables avec des noms longs (et éviter les noms très courts
i, j, k, ...). Lors de la relecture du programme, il est ainsi possible de se rappeler à quoi sert la
variable.
• Pour définir le nom des variables, le WLangage accepte tous les caractères Unicode, y compris
les accents. Autant en profiter pour plus de lisibilité ! Attention toutefois : certains caractères
sont interdits : espace, =, point, virgule, ...
• Il est très important de donner le bon type à la variable en fonction de son utilisation. Par
exemple, pour stocker une suite de chiffres, il peut être nécessaire :
• d’utiliser une variable de type numérique si cette variable doit être utilisée pour des calculs.
• d’utiliser une variable de type chaîne si cette variable permet de stocker des chiffres sans
effectuer de calculs (par exemple pour mémoriser le numéro de sécurité sociale).
Détail d’un type de variable : les variables de type Chaîne

Les variables de type Chaîne sont un des types de variables les plus utilisés.
Nous allons détailler une partie des fonctionnalités disponibles sur ce type de variable.
Le type Chaîne
Nous savons déjà que le type Chaîne permet de stocker et manipuler les caractères et les chaînes
de caractères.
Nous avons déjà vu comment initialiser une variable de type chaîne :
Nom est une chaîne
Nom = “Dupont”
Il n’est pas nécessaire de déclarer la longueur de la chaîne : le WLangage adapte automatique-

ment cette longueur lors de l’utilisation de la variable.
Pour initialiser une variable de type chaîne avec un texte sur plusieurs lignes,
utilisez la syntaxe suivante :
<Nom variable> = [
<Texte de la ligne 1>
<Texte de la ligne 2>
Astuce
]
Par exemple :
MaChaîne est une chaîne
MaChaîne = [
Exemple de
chaîne multi-ligne
]

Il est également possible d’affecter une variable de type chaîne avec le contenu d’un champ ma-
nipulant des chaînes. Ainsi, le code permettant d’affecter une variable de type chaîne avec le
contenu d’un champ de saisie est le suivant :
Nom est une chaîne

// avec le contenu du champ de saisie SAI_NOM
Nom = SAI_Nom
En plus des opérateurs de comparaison de base, le WLangage propose des opérateurs puissants,
permettant de gérer les extractions et concaténations de manière avancée.
Quelques exemples :
• " + " : Pour concaténer des chaînes
• " ~= " : Pour tester l’égalité souple
Le WLangage propose également des fonctions spécifiques permettant de réaliser de nom-
breuses opérations : recherche, extraction, taille, passage en majuscules, ...
Exemples :
ch est une chaîne

ch = “WINDEV est un outil formidable”
// Extraction d’une sous-chaîne à partir de la gauche
Info(Gauche(ch,6)) // Affiche “WINDEV”
// Extraction d’une sous-chaîne à partir de la droite
Info(Droite(ch,3)) // Affiche “ble”
Le WLangage permet d’imbriquer les différentes fonctions WLangage. Une fonc-

tion WLangage peut être utilisée comme paramètre d’une autre fonction WLan-
Notes
gage.
Par exemple :
Info(Milieu(Gauche(ch,13),8,3)) // Affiche “est”
Pour plus de détails, consultez l’aide sur les chaînes de caractères et les fonctions de manipula-
tion des chaînes de caractères.
Exemple pratique
Pour manipuler les différents concepts de cette leçon, nous allons réaliser différentes fenêtres.
Ces fenêtres vont être créées dans le projet "WD Mes premières fenêtres".
Ouvrez si nécessaire le projet "WD Mes Premières Fenêtres".

Pour manipuler les variables de type Chaîne de caractères que nous venons d’étudier, nous allons
réaliser la fenêtre suivante :
Cette fenêtre permet de :

• rechercher une chaîne dans une autre.
• comparer deux chaînes.
Créez une nouvelle fenêtre vierge :
1. Cliquez sur parmi les boutons d’accès rapide. La fenêtre de création d’un nouvel élément
s’affiche : cliquez sur "Fenêtre" puis sur "Fenêtre". L’assistant de création de fenêtres s’affiche.
2. Sélectionnez "Vierge" et le gabarit "Elegant".
l’élément créé apparaît.
4. Indiquez le titre de l’élément "Variables". Le nom de l’élément "FEN_Variables" est automa-
tiquement proposé.
vert.
Pour créer le champ de saisie contenant la chaîne de base :
2. Cliquez à l’emplacement de création du champ de saisie (par exemple en haut, au milieu
de la fenêtre).
3. Faites un clic droit sur le champ et sélectionnez l’option "Description".
4. Dans l’onglet "Général", indiquez :
• Le nom du champ : "SAI_Texte".
• Le libellé du champ : "Texte".
5. Sélectionnez l’onglet "Contenu". Cet onglet permet de définir la valeur par défaut du champ
de saisie. Saisissez "WINDEV est un outil formidable".
6. Validez la fenêtre de description. Le texte saisi s’affiche directement dans le champ.
Le contenu du champ apparaît tronqué sous l’éditeur. Pour afficher correctement le champ :
2. Agrandissez le champ en largeur à l’aide des poignées de redimensionnement afin que le
contenu apparaisse en entier.

Recherche d’une chaîne
Pour créer le bouton "Rechercher une chaîne" :

2. Cliquez à l’emplacement de création du bouton (par exemple en dessous du champ de
saisie).
édition. Saisissez le libellé "Rechercher une chaîne".
4. Validez la saisie avec la touche [ENTREE].
5. Adaptez la taille du champ.
6. Affichez les traitements associés au bouton (touche [F2]).
7. Saisissez le code de clic suivant :
sChaîneARechercher est une chaîne = “WINDEV”

nPos est un entier
nPos = Position(SAI_Texte, sChaîneARechercher)
SI nPos = 0 ALORS
Info(sChaîneARechercher + “ non trouvé dans le texte”)
SINON
Info(sChaîneARechercher + “ trouvé à la position ”+nPos)
FIN
Examinons ce code :
• Deux variables sont déclarées : une variable de type Chaîne correspondant à la chaîne à re-
chercher et une variable de type Entier correspondant à la position de la chaîne recherchée.
• La fonction WLangage Position permet de rechercher une chaîne dans une autre. Dans
notre exemple, nous recherchons le contenu de la variable sChaîneARechercher dans le
contenu du champ SAI_Texte.
• Si la fonction Position renvoie 0, cela signifie que la chaîne à rechercher n’a pas été trou-
vée. Un message est affiché grâce à la fonction Info.
2. La fenêtre que vous avez créée s’enregistre puis se lance en exécution. Cliquez sur le bou-
ton. Le mot WINDEV est trouvé.
3. Modifiez le contenu du champ de saisie (en remplaçant WINDEV par WD par exemple) et
cliquez sur le bouton. Le mot WINDEV n’est pas trouvé.
4. Fermez la fenêtre.

Comparer deux chaînes
Pour créer le bouton "Comparer deux chaînes" :

2. Cliquez à l’emplacement de création du bouton (par exemple à droite du bouton existant).
édition. Saisissez le libellé "Comparer deux chaînes".
sChaîneAComparer est une chaîne = “WINDEV”
SI SAI_Texte ~= sChaîneAComparer ALORS

Info(“Le texte affiché correspond à ”+sChaîneAComparer)
SINON
Info(“Le texte affiché ne correspond pas à ”+sChaîneAComparer)
FIN
• Une variable de type Chaîne est déclarée. Cette variable contient la chaîne à comparer.
• L’opérateur ~= correspond à une égalité souple. Cet opérateur permet de faire une compa-
raison sans tenir compte de la casse, des espaces avant et après la chaîne et sans tenir
compte des accents.
• Si la comparaison est vraie, le champ de saisie correspond au mot contenu dans la chaîne à
comparer quelle que soit la casse utilisée.
2. Cliquez sur le bouton "Comparer deux chaînes". Le message indique que la comparaison
n’est pas bonne.
3. Validez le message.
4. Dans le champ de saisie, saisissez "WINDEV" en majuscules, puis cliquez sur le bouton
"Comparer deux chaînes". Le mot WINDEV est trouvé. Validez le message.
5. Modifiez le contenu du champ de saisie (en remplaçant WINDEV par WinDev par exemple)
et cliquez sur le bouton. Le mot WINDEV est également trouvé. Validez le message.

Détail d’un autre type de variable : les tableaux
Les tableaux sont également un type de variable très utilisé.
Un tableau est un type structuré qui permet de regrouper une série d’éléments de même type.
Chaque élément du tableau est accessible directement par son numéro d’ordre (indice).
Des fonctions WLangage spécifiques permettent de manipuler les tableaux et leurs éléments. Ces
fonctions commencent par le préfixe "Tableau".
Déclaration
La déclaration d’une variable de type tableau se fait de la façon suivante :
<Nom du tableau> est un tableau de <Type des éléments du tableau>
Par exemple :
tabChaîne est un tableau de chaînes
tabEntier est un tableau d’entiers
Remplissage d’un tableau et accès aux éléments

Lors de sa déclaration, le tableau est vide. L’ajout d’éléments est réalisé par la fonction Ajoute
grâce à la syntaxe suivante :
Ajoute(<Nom du tableau>, <Valeur de l’élément>)
Pour accéder aux éléments d’un tableau, il suffit d’utiliser la syntaxe suivante :
<Nom du tableau> [<Indice de l’élément>]

Important
Les indices des éléments du tableau commencent à 1.
Exemple :
// Création d’un tableau de chaînes
MonTableau est un tableau de chaînes
// Ajout d’éléments
Ajoute(MonTableau, “WINDEV”)
Ajoute(MonTableau, “WEBDEV”)
Ajoute(MonTableau, “WINDEV Mobile”)
// Affichage du contenu du troisième élément
Trace(MonTableau[3]) // Affiche “WINDEV Mobile”

Initialisation rapide d’un tableau
Pour initialiser un tableau, il est également possible d’utiliser la syntaxe sui-
Astuce vante :
// Déclare un tableau
tabJour est un tableau de chaînes
// Initialisation avec
// les noms des jours de la semaine
tabJour = [“Lundi”, “Mardi”, “Mercredi”, “Jeudi”,
“Vendredi”, “Samedi”, “Dimanche”]
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Tableau").
Des tableaux avancés

Le WLangage propose également des tableaux avancés : tableau à plusieurs dimensions, tableau
de tableaux, tableau associatif, tableau de structures, tableau d’objets, ... Pour plus de détails,
consultez l’aide en ligne (mot-clé : "Tableau").

Leçon 2.2. Les instructions condition-
nelles
• L’instruction SI
• L’instruction SELON
• Exemple pratique

Présentation
Le WLangage est une suite d’instructions manipulant des données.
Les instructions conditionnelles permettent de comparer des variables et/ou des valeurs entre
elles afin de faire des traitements différents. Il existe plusieurs instructions conditionnelles :
• SI... ALORS... SINON... FIN
• SELON ...
Les instructions SI et SELON
L’instruction SI
Cette instruction permet d’exécuter une action ou une autre en fonction du résultat d’une expres-
sion. Si l’expression est vérifiée, un traitement est lancé ; si l’expression n’est pas vérifiée, un
autre traitement peut être lancé.
L’instruction SI s’utilise comme ci-dessous :
SI <Expression à vérifier> ALORS

Traitement à exécuter dans le cas où l’expression est vérifiée
SINON
Traitement à exécuter dans le cas contraire
FIN
Exemple de code : Le code suivant sélectionne un nombre au hasard et selon la valeur affiche un
message.
Tot est un monétaire

// Prend un nombre au hasard entre 100 et 4000
Tot = Hasard(100, 4000)
SI Tot>2000 ALORS
Info(“Le montant est supérieur à 2000”)
SINON
Info(“Le montant est inférieur ou égal à 2000”)
FIN
Dans ce cas, l’expression à vérifier correspond à "Tot>2000".
Remarque : Il est possible d’exécuter plusieurs lignes de code lors du traitement correspondant à
une condition. Dans ce cas, la syntaxe à utiliser est la suivante :
SI <Expression à vérifier> ALORS

Ligne de code 1
Ligne de code N
SINON
Ligne de code 1
Ligne de code N
FIN

L’instruction SELON
Cette instruction permet d’évaluer une expression et d’exécuter un traitement pour chaque valeur
possible de l’expression.
L’instruction SELON s’utilise comme ci-dessous :
SELON <Expression>
CAS Valeur 1 :
Traitement 1...
CAS Valeur 2 :
Traitement 2...
...
CAS Valeur N :
Traitement N...
AUTRES CAS
Traitement ...
FIN
Exemple : Le code suivant récupère la date du jour et selon sa valeur affiche un message diffé-
rent. Pour le 1er et le 15 du mois, un message spécifique est affiché. Dans les autres cas, la date
du jour est affichée.
D est une Date

D = DateDuJour()
SELON D..Jour // Teste le jour de la date
CAS 1 : Info(“On est le premier jour du mois”)
CAS 15 : Info(“On est le 15 du mois.”)
AUTRES CAS : Info(“On est le : “+ DateVersChaîne(D))
FIN
Remarques :
• Si la ligne de code "CAS 1:..." est exécutée, les autres lignes de code correspondant aux valeurs
possibles ne sont pas exécutées.
• Il est possible de regrouper dans le même cas plusieurs valeurs. Les différentes valeurs sont
séparées par une virgule. Par exemple :
Ind est un entier = 2
SELON Ind
CAS 1,2 : Info("Cas 1 ou 2")
CAS 3 : Info("Cas 3")
AUTRE CAS : Info("Autre cas")
FIN

• Il est possible d’exécuter plusieurs lignes de code lors du traitement correspondant à une valeur
de l’expression. Dans ce cas, la syntaxe à utiliser est la suivante :
SELON <Expression>
CAS Valeur 1 :
Traitement 1 - Ligne de code 1...
Traitement 1 - Ligne de code 2...
CAS Valeur N :
Traitement N - Ligne de code 1...
Traitement N - Ligne de code 2...
AUTRES CAS
Traitement ...
FIN
Exemple pratique : Utilisation de l’instruction SI et SELON

Pour utiliser les instructions conditionnelles que nous venons d’étudier, nous allons réaliser la
fenêtre suivante :
Deux manipulations sont disponibles :

• Si l’utilisateur clique sur l’interrupteur, le bouton "Fermer" apparaît.
• Si l’utilisateur clique sur le bouton "Tester", la case cochée dans le sélecteur est affichée.
Projet manipulé


4. Indiquez le titre de la fenêtre "Instructions conditionnelles". Le nom de la fenêtre "FEN_Ins-
tructions_conditionnelles" est automatiquement proposé.
vert.
Création des champs de la fenêtre pour l’instruction conditionnelle SI

Deux champs doivent être créés :
• un champ Interrupteur permettant d’afficher ou non le bouton "Fermer".
• un bouton "Fermer" permettant de fermer la fenêtre.
Pour créer le champ Interrupteur :
1. Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur "Interrupteur" puis cli-
quez dans la fenêtre à la position où le champ doit être créé (par exemple en haut de la fenêtre).
2. Cliquez sur le champ que vous venez de créer : le libellé "Option 1" passe en édition.
3. Saisissez le libellé de l’option "Rendre visible le bouton de fermeture".
Le libellé de l’option apparaît tronqué sous l’éditeur. Pour afficher correctement le champ :
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.
Pour créer le bouton "Fermer" :
2. Cliquez à l’emplacement de création du bouton (par exemple à droite du champ Interrup-
teur).
édition. Saisissez le libellé "Fermer".
Ce bouton permet de fermer la fenêtre. Nous allons saisir le code WLangage correspondant :
1. Sélectionnez le bouton "Fermer".
2. Utilisez la touche [F2] : l’éditeur de code apparaît affichant les traitements associés au bou-
ton.
3. Dans le traitement "Clic sur BTN_Fermer", saisissez le code suivant :
Ferme()
La fonction Ferme permet de fermer la fenêtre en cours.

Le bouton "Fermer" doit être invisible à l’ouverture de la fenêtre. Cette information corres-
pond à son "état initial". Nous allons modifier cet état dans la fenêtre de description du
champ :
1. Sélectionnez le bouton "Fermer".
2. Affichez le menu contextuel du champ et sélectionnez l’option "Description".
3. Dans l’onglet "IHM", modifiez l’état initial du champ en cliquant sur "Visible". Cette option
est désormais décochée.
5. Le bouton "Fermer" est toujours visible sous l’éditeur. Nous avons changé son état unique-
ment en exécution.
6. Enregistrez les modifications en cliquant sur parmi les boutons d’accès rapide (à
gauche du ruban) ou par la combinaison de touches [CTRL] + [S].
Instruction conditionnelle SI
Dans notre exemple, le clic sur l’interrupteur doit déclencher l’apparition du bouton Fermer.
Nous allons saisir le code WLangage associé à l’interrupteur.
Nous allons saisir le code WLangage associé à l’interrupteur. :
1. Sélectionnez le champ Interrupteur.
2. Utilisez la touche [F2].
3. Dans le traitement "A chaque modification de INT_SansNom1", saisissez le code suivant :
SI INT_SansNom1=Vrai ALORS
BTN_Fermer..Visible = Vrai
SINON
BTN_Fermer..Visible = Faux
FIN
• INT_SansNom1 et BTN_Fermer correspondent respectivement aux noms des champs Inter-
rupteur et Bouton.
Pour manipuler le champ en cours dans un des traitements qui lui sont
Astuce
associés, il est possible d’utiliser le mot-clé MoiMême.

Dans notre exemple, il est également possible d’écrire :
Si MoiMême = Vrai ALORS
• Le champ Interrupteur est un champ à 2 états : coché/non coché. Il correspond en program-

mation à une variable de type Booléen. Si le champ est coché, sa valeur est Vrai ; si le
champ est décoché, sa valeur est Faux.
• Ce code teste la valeur de l’interrupteur.
• Si l’interrupteur est coché, le bouton BTN_Fermer devient visible à l’aide de la propriété
WLangage ..Visible.
• Si l’interrupteur est décoché, le bouton BTN_FERMER devient invisible.

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é ..Visible est utilisée sur le champ BTN_Fermer.
A tout moment, il est possible de consulter l’aide en ligne d’une fonction ou
d’une propriété grâce à la touche [F1]. Pour plus de détails sur l’aide en ligne,
consultez "Comment accéder à l’aide en ligne ?", page 16.

2. Dans la fenêtre en exécution, cliquez sur l’interrupteur. Le bouton "Fermer" devient visible.
3. Cliquez sur le bouton "Fermer" : la fenêtre se ferme et l’éditeur de fenêtres apparaît.
Création des champs de la fenêtre pour l’instruction conditionnelle SELON

Deux champs doivent être créés :
• un champ Sélecteur permettant de sélectionner la valeur à tester.
• un champ Bouton permettant de lancer le test.
Pour créer le champ Sélecteur :
1. Sous le volet "Création", dans le groupe "Champs usuels", déroulez "Sélecteur" (cliquez sur la
flèche). La liste des champs Sélecteurs proposés par défaut s’affiche.
2. Dans la liste des champs, dans la catégorie "Pré-Rempli", cliquez sur le premier champ pro-
posé (avec "Monsieur").
3. Cliquez dans la fenêtre pour créer le champ (par exemple sous le champ Interrupteur créé
précédemment).
Pour créer le bouton "Tester" :
2. Cliquez à l’emplacement de création du bouton (par exemple à droite du champ Sélecteur).
édition. Saisissez le libellé "Tester".

Instruction conditionnelle SELON
Dans notre exemple, le bouton Tester permet de tester la valeur sélectionnée et d’afficher un
message.
Nous allons saisir le code WLangage associé au bouton Tester :
1. Sélectionnez le bouton Tester.
2. Utilisez la touche [F2].
3. Dans le traitement "Clic sur BTN_Tester", saisissez le code suivant :
SELON SEL_Civilités
4. Lors de l’appui sur la touche [ENTREE] pour passer à la ligne suivante, l’éditeur de code
affiche automatiquement les différentes possibilités du SELON :
5. Saisissez le code suivant :

SELON SEL_Civilités
// Monsieur
CAS 1
Info(“Vous avez sélectionné Monsieur”)
// Madame
CAS 2
Info(“Vous avez sélectionné Madame”)
// Mademoiselle
CAS 3
Info(“Vous avez sélectionné Mademoiselle”)
// Autre
CAS 4
Info(“Vous avez sélectionné Autre”)
FIN
• SEL_Civilités correspond au nom du champ Sélecteur.

• Le champ Sélecteur est un champ proposant plusieurs options (dans notre cas, 4). Seule
une option peut être cochée à la fois. Le champ Sélecteur correspond en programmation à
une variable de type Entier. Chaque option est associée à une valeur. Si l’option est cochée,
le champ Sélecteur a pour valeur l’identifiant de l’option cochée.
• Ce code teste la valeur du sélecteur. Selon la valeur du sélecteur, un message est affiché.
2. Dans la fenêtre en cours de test, sélectionnez une option puis cliquez sur "Tester" : le mes-
sage correspondant à l’option sélectionnée s’affiche.

Leçon 2.3. Les boucles
• L’instruction POUR
• L’instruction BOUCLE
• L’instruction TANTQUE

Présentation
Les instructions de boucle permettent d’exécuter un traitement de manière récurrente. Selon le
nombre d’occurrences (connu ou pas), on utilise une instruction de boucle particulière. Il existe
plusieurs instructions pour faire des boucles :
• POUR ...
• BOUCLE ...
• TANTQUE ...
L’instruction POUR
L’instruction POUR est utilisée lorsque l’on connaît le nombre d’occurrences à traiter. Cette ins-
truction permet de gérer le nombre d’occurrences à l’aide d’une variable dans laquelle on va
compter les passages effectués dans la boucle.
La syntaxe de l’instruction POUR est la suivante :
POUR Indice = Valeur de départ A Valeur de fin

Traitement à exécuter
FIN
Par exemple, le code suivant exécute 2000 fois le traitement :
POUR nCpt = 1 A 2000

// Traitement à exécuter
FIN
Remarque : Il est possible de définir un pas d’incrémentation de l’indice grâce au mot-clé PAS. Par
exemple, le code suivant exécute 200 fois le traitement et la variable nCpt diminue de 10 en 10 :
POUR nCpt = 2000 A 1 PAS -10

FIN
L’instruction BOUCLE
L’instruction BOUCLE est utilisée pour faire des boucles lorsque le nombre d’occurrences à traiter
n’est pas connu. Dans ce cas, il faut utiliser un test pour sortir de la boucle.
La syntaxe de l’instruction BOUCLE est la suivante :

BOUCLE
SI <Expression> ALORS SORTIR
FIN

Par exemple :
Compteur est un entier
Compteur = 10
BOUCLE
Compteur = Compteur - 1
SI Compteur = 0 ALORS SORTIR
FIN
L’instruction BOUCLE permet d’avoir le même comportement qu’une instruction

POUR : il suffit d’utiliser la syntaxe avec sortie selon le nombre d’itérations :
BOUCLE (<Nombre d’itérations>)
...
Astuce
FIN
Exemple :
BOUCLE(10)
FIN
L’instruction TANTQUE
L’instruction TANTQUE fonctionne sur le même principe que l’instruction BOUCLE. La différence
réside dans le fait que le test de la condition de sortie est effectué AVANT l’exécution du code de
la boucle. Ce test permet de comparer une variable. Cette variable commence à une valeur de dé-
part et est modifiée dans la boucle jusqu’à arriver à la valeur qui provoque la sortie de la boucle.
La syntaxe de l’instruction TANTQUE est la suivante :

<Initialisation de la variable à sa valeur de début>
TANTQUE <Comparaison de la variable à sa valeur de fin>
<Modification de la variable>
FIN
Par exemple :
Compteur est un entier
Compteur = 0
TANTQUE Compteur<10
Compteur = Compteur + 1
FIN

Exemple pratique : Utilisation des boucles
Pour tester l’utilisation des boucles, nous allons créer une fenêtre dans laquelle nous allons dé-
placer un champ Image.
Projet manipulé

4. Indiquez le titre de la fenêtre "Boucles". Le nom de la fenêtre "FEN_Boucles" est automati-
quement proposé.
vert.
Création des champs

Nous allons tout d’abord créer le champ Image puis nous créerons les boutons permettant de
manipuler cette image.
Pour créer un champ Image :
1. Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur "Image". Positionnez le
champ dans la fenêtre.
3. Nous allons associer une image au champ Image grâce au catalogue d’images de WINDEV.
Dès qu’une image peut être affichée dans un champ ou une fenêtre, WINDEV
Notes
propose d’utiliser le catalogue d’images. Ce catalogue d’images est lancé via

l’option "Catalogue" (disponible en cliquant sur le bouton ). Ce catalogue
contient plusieurs milliers d’images, de cliparts, ...

4. Cliquez sur le bouton à droite du champ "Image". Dans le menu contextuel qui s’affiche,
sélectionnez l’option "Catalogue". La fenêtre du catalogue d’images apparaît.
5. Saisissez "Animal" dans la zone de recherche. Lancez la recherche en cliquant sur la loupe.
6. Sélectionnez l’image et validez (bouton vert).

7. Une fenêtre permettant de paramétrer l’image apparaît. Conservez les options par défaut
et validez.
8. L’image apparaît dans le champ Image. Validez.
9. Sauvez la fenêtre (CTRL S ou cliquez sur parmi les boutons d’accès rapide).
Nous allons maintenant créer un bouton permettant à l’image de se déplacer de 300 pixels
vers la droite dans la fenêtre. Nous allons pour cela utiliser l’instruction POUR du WLangage.
2. Cliquez à l’emplacement de création du bouton (par exemple sous le champ Image).
édition. Saisissez le libellé "Instruction POUR".
// Déplace l’image horizontalement de 300 pixels

POUR i=1 A 300
IMG_SansNom1..X++
FIN
Ce code permet de modifier l’abscisse du champ Image (propriété ..X) dans une boucle de 1
à 300. A chaque tour de boucle, l’abscisse augmente d’un pixel.
Lors de la saisie des instructions conditionnelles sous l’éditeur de code, l’éditeur

de code propose dans une liste les différentes syntaxes possibles.
Notes
Si vous sélectionnez une de ces syntaxes, la structure de l’instruction est auto-

matiquement insérée dans l’éditeur de code. Il suffit de saisir le code correspon-
dant à chaque partie de l’instruction.

Créons maintenant un bouton permettant de déplacer l’image jusqu’au bord droit de la
fenêtre. Nous allons pour cela utiliser l’instruction TANTQUE du WLangage.
2. Cliquez à l’emplacement de création du bouton (par exemple à droite du bouton "Instruction
POUR").
édition. Saisissez le libellé "Instruction TANTQUE".
// Déplace le bouton horizontalement jusqu’au bord

// de la fenêtre
TANTQUE IMG_SansNom1..X < FenIntLarg() - IMG_SansNom1..Largeur
IMG_SansNom1..X++
FIN
Ce code permet de modifier l’abscisse du champ Image (propriété ..X) jusqu’à ce qu’une
condition soit vraie. Dans notre cas, cette condition est la suivante : il faut que la position de
l’image (sa propriété ..X) corresponde à la largeur de la fenêtre moins la largeur de l’image.
Astuce
Lorsqu’une ligne de code est trop longue pour rentrer dans la fenêtre de l’éditeur
de code, il est possible de la couper en 2 en utilisant le retour à la ligne.
Créons maintenant un dernier bouton permettant de déplacer l’image jusqu’au bord gauche
de la fenêtre. Nous allons pour cela utiliser l’instruction BOUCLE du WLangage.
2. Cliquez à l’emplacement de création du bouton (par exemple à droite du bouton "Instruction
TANTQUE").
édition. Saisissez le libellé "Instruction BOUCLE".
// Déplace l’image à gauche
BOUCLE
IMG_SansNom1..X--
SI IMG_SansNom1..X <= 0 ALORS SORTIR
FIN
Ce code permet de modifier l’abscisse du champ Image (propriété ..X). A chaque tour, une
condition est vérifiée.

Si cette condition est vraie, le programme sort de la boucle. Dans notre cas, la condition est
la suivante :
• la position de l’image est 0,
• la position de l’image est inférieure à 0 (permet de gérer le cas où l’utilisateur appuie plu-
sieurs fois sur le bouton).
Lors de la saisie de ce code, l’instruction BOUCLE peut apparaître soulignée d’un

trait vert et un warning peut apparaître dans le volet des erreurs de compilation.
Notes
Ce warning rappelle qu’une instruction de sortie doit être présente dans le code
de la boucle pour éviter une boucle infinie.
Test de la fenêtre

2. La fenêtre que vous avez créée se lance en exécution.
3. Cliquez sur les différents boutons.
4. Fermez la fenêtre de test.

Leçon 2.4. Les procédures
• Types de procédures
• Création et appel d’une procédure
• Paramètres d’une procédure
• Résultat d’une procédure

Présentation
Une procédure permet d’associer un identificateur à une portion de code afin de la réutiliser.
Dans cette leçon, nous allons voir les différents types de procédures existant en WLangage, leur
mode de création, comment les appeler, leur passer des paramètres et récupérer un résultat.
Types de procédures
Les procédures peuvent être de trois types :
• Procédure globale : utilisable dans tous les traitements du projet (déclarée dans une collection
de procédures).
• Procédure locale à une Fenêtre, Page ou Fenêtre mobile : utilisable dans tous les traitements
dépendant de l’objet dans lequel cette procédure a été déclarée.
• Procédure interne à un traitement : utilisable uniquement dans le traitement dans lequel elle a
été déclarée.
Portée des procédures

Notes
Les procédures respectent les règles de portée que nous avons détaillées pour
les variables (voir "La portée des variables", page 46).
Création et appel d’une procédure
Procédure globale
Pour créer une procédure globale, il faut :
1. Créer si nécessaire une collection de procédures (via le volet "Explorateur de projet", dossier
"Procédures"). Donner un nom à la collection de procédures.
2. Créer une procédure globale dans la collection de procédures (via le volet "Explorateur de
projet", dossier "Procédures, Nom de la collection"). Donner un nom à la procédure.
3. Saisir le code de la procédure globale. Le code de la procédure est de la forme :
PROCEDURE <Nom de la procédure globale>()
Procédure locale
Pour créer une procédure locale, il faut :
1. Sélectionner l’élément associé à la procédure (fenêtre, page, ...).
2. Créer une procédure locale (par exemple via le volet "Explorateur de projet", déroulez le
nom de l’élément, dossier "Procédures locales").
3. Donner un nom à la procédure.
4. Saisir le code de la procédure locale. Le code de la procédure est de la forme :
PROCEDURE <Nom de la procédure locale>()

Procédure interne
Pour créer une procédure interne, il suffit de saisir le code suivant dans le traitement voulu :
PROCEDURE INTERNE <Nom de la procédure>()
<Code de la procédure interne>
FIN
Appel d’une procédure

Pour appeler une procédure, il suffit d’utiliser directement le nom de la procédure (avec éventuel-
lement les paramètres à lui passer).
<Nom de la procédure>(<Paramètre 1>, ..., <Paramètre N>)
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Procédure").
Paramètres d’une procédure
Qu’est-ce qu’un paramètre ?

Un paramètre est une valeur envoyée à une procédure lors de l’appel de la procédure.
L’exemple suivant permet d’appeler la procédure Multiplie10 en lui passant en paramètre la va-
leur à manipuler dans la procédure :
Multiplie10(50)
Il est possible de passer de 0 à plusieurs valeurs en paramètre à une procédure. Ces valeurs
peuvent être de tout type (comme pour les variables).
Le paramètre est spécifié dans la déclaration de la procédure sous forme de variable. Par
exemple, pour la procédure Multiplie10, le code de la procédure est :
PROCEDURE Multiplie10(P)
P=P*10
P est le paramètre attendu par la procédure.
Pour préciser la fonction du paramètre dans la procédure, il est possible de typer

Notes
le paramètre dans la déclaration de la procédure.

Par exemple, pour n’utiliser que des numériques, il est possible de déclarer :
PROCEDURE Multiplie10(P est un numérique)

Dans l’exemple suivant, la procédure Multiplication attend deux paramètres de type Entier et ren-
voie le résultat de la multiplication.
Le code de la procédure est le suivant :
PROCEDURE Multiplication(Nb1 est un entier, Nb2 est un entier)

Résultat est un entier
Résultat = Nb1 * Nb2
RENVOYER Résultat
Le code permettant d’appeler la procédure est le suivant :
res est un entier

res = Multiplication(10, 50)
// Res vaut 500
Comment utiliser les paramètres ?

Par défaut, le WLangage utilise le passage de paramètre par référence (ou par adresse). Le para-
mètre dans la procédure représente (référence) directement la variable passée lors de l’appel.
Ainsi, lorsqu’une instruction de la procédure modifie la valeur du paramètre, la valeur de la va-
riable correspondant à ce paramètre est modifiée.
Exemple :
• Le code de la procédure est le suivant :
PROCEDURE Test_adresse(P1)
P1 = P1 * 2
• Le code permettant d’appeler la procédure est le suivant :

T est un entier
T = 12 // T vaut 12 avant l’appel
Test_adresse(T)
// T vaut 24 après l’appel
Pour ne pas modifier la valeur de la variable correspondant au paramètre, il suffit d’utiliser le

passage de paramètre par valeur. Le passage de paramètre par valeur permet de manipuler une
copie de la valeur du paramètre. Si le code de la procédure modifie la valeur de la variable, la
valeur de la variable correspondant au paramètre n’est pas modifiée.
Pour forcer le passage d’un paramètre par valeur à une procédure, il faut utiliser le mot-clé LOCAL
devant le nom du paramètre dans la déclaration de la procédure. Ce mot-clé indique que le para-
mètre suivant ne sera pas modifié par la procédure.
Exemple :
• Le code de la procédure est le suivant :
PROCEDURE Test_valeur(LOCAL P1)

// Local indique que le paramètre sera passé par valeur
P1 = P1 * 2

• Le code permettant d’appeler la procédure est le suivant :
T est un entier
T = 12 // T vaut 12
Test_valeur(T)
// T ne change pas
Dans une même procédure, certains paramètres peuvent être passés par
Notes
adresse et d’autres paramètres peuvent être passés par valeur. Il suffit d’utiliser
le mot-clé LOCAL devant chaque paramètre passé par valeur.
Paramètres obligatoires ou optionnels ?

Les paramètres reçus dans la procédure peuvent être obligatoires ou optionnels. Un paramètre
obligatoire doit être renseigné lors de l’appel de la procédure alors qu’un paramètre optionnel
peut être omis : il prendra dans ce cas la valeur par défaut définie lors de la déclaration des para-
mètres de la procédure.
Notes
Dans la déclaration d’une procédure, les paramètres optionnels sont toujours

les derniers paramètres spécifiés (après tous les paramètres obligatoires).
Dans l’exemple suivant, la procédure Multiplication utilise un paramètre optionnel, Nb2. Ce para-
mètre optionnel est indiqué après les paramètres obligatoires, en précisant sa valeur par défaut.
Dans cet exemple, le paramètre optionnel a pour valeur par défaut 10.
PROCEDURE Multiplication(Nb1 est un entier, Nb2 est un entier=10)

Résultat est un entier
Résultat = Nb1 * Nb2
RENVOYER Résultat
Le code d’appel de la procédure est le suivant :

res est un entier
res = Multiplication(6)
// Res vaut 60
Dans cet exemple, le second paramètre n’a pas été précisé. C’est donc sa valeur par défaut qui
est utilisée.
Résultat d’une procédure

Les procédures peuvent retourner un ou plusieurs résultats. Le résultat peut être typé. Il faut utili-
ser le mot-clé RENVOYER pour retourner une valeur.
Pour plus de détails, consultez l’aide en ligne (mot-clé : Renvoyer).

Exemple pratique : Utilisation d’une procédure
Dans une nouvelle fenêtre, nous allons maintenant :
• Créer deux champs de saisie numériques contenant la valeur HT et la valeur TTC.
• Créer un champ Combo permettant de choisir le taux de TVA.
• Créer un bouton permettant de 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 :
Projet manipulé
Mise en place

4. Indiquez le titre de la fenêtre "Procédures". Le nom de la fenêtre "FEN_Procédures" est au-
tomatiquement proposé.
vert.
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.
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.
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’étape suivante de l’assistant.

5. Conservez les options proposées par défaut. Affichez les étapes suivantes.
6. Dans l’étape intitulée "Contenu initial", saisissez la liste des valeurs de TVA possibles :
• 5.5
• Appuyez sur la touche [ENTREE].
• 10
• Appuyez sur la touche [ENTREE].
• 20.

7. Affichez l’écran suivant et donnez un nom au champ (COMBO_TVA) et un libellé (TVA).
8. Validez.
Pour créer le bouton "Calculer" :
2. Cliquez à l’emplacement de création du bouton (par exemple sous le champ Combo).
édition. Saisissez le libellé "Calculer".
Le montant TTC va être obtenu dans le traitement du bouton "Calculer".
1. Affichez le code du champ "Calculer" (option "Code" du menu contextuel par exemple).
2. Dans le traitement "Clic sur BTN_Calculer", saisissez le code suivant :
SELON COMBO_TVA..ValeurAffichée
// 5.5 %
CAS 5.5
SAI_PrixTTC = SAI_PrixHT * 1.055
// 10 %
CAS 10
// 20 %
CAS 20
FIN
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).

3. Testez votre fenêtre ( parmi les boutons d’accès rapide). Donnez un prix HT. Sélection-
nez les différentes valeurs dans le champ Combo et cliquez sur le bouton "Calculer".
Maintenant, notre fenêtre fonctionne correctement. Cependant, au lieu d’utiliser 3 fois une for-
mule pour calculer le prix, il est possible d’utiliser une procédure pour effectuer ce calcul.
Fermez la fenêtre de test pour revenir sous l’éditeur de code.
Création et utilisation d’une procédure
Pour créer la procédure de calcul du montant TTC :

1. Cliquez sur le fond de la fenêtre.
2. Affichez les traitements associés à la fenêtre (touche [F2]).
3. Sous l’éditeur de code, sous le volet "Code" présent dans le ruban, dans le groupe "Procé-
dures", déroulez "Nouveau" et sélectionnez "Nouvelle procédure locale".
4. Dans la fenêtre qui s’affiche, saisissez le nom de la procédure locale "Calcul_TTC" et validez
(bouton "Ajouter").
5. La nouvelle procédure locale à la fenêtre est automatiquement créée et son code est affi-
ché sous l’éditeur de code.
PROCEDURE Calcul_TTC(PrixHT, TauxTVA)

moTTC est un monétaire
moTTC = PrixHT * (1 + TauxTVA/100)
RENVOYER moTTC
• La procédure Calcul_TTC attend 2 paramètres : le prix hors taxe et le montant du taux de
TVA.
• Cette procédure déclare une variable de type monétaire. Cette variable permet de stocker le
montant du prix TTC calculé.
• Cette procédure calcule le prix TTC et renvoie la valeur calculée.
7. Fermez l’éditeur de code.
Lors de la création d’une procédure, des commentaires sont automatiquement

générés AVANT le code de la procédure. Ces commentaires permettent notam-
ment de préciser le contenu des paramètres et de la valeur de retour.
Notes
Il est important de remplir ces commentaires. En effet, ils seront automatique-

ment affichés dans une bulle d’aide lors de la saisie de l’appel de la procédure
sous l’éditeur de code.

Il ne reste plus qu’à appeler la procédure depuis le bouton de calcul.
1. Sélectionnez le bouton "Calculer".
2. Affichez le code du bouton (touche [F2] par exemple).
3. Remplacez le code existant par le code suivant :
SELON COMBO_TVA..ValeurAffichée
// 5.5 %
CAS 5.5
SAI_PrixTTC = Calcul_TTC(SAI_PrixHT,5.5)
// 10 %
CAS 10
SAI_PrixTTC = Calcul_TTC(SAI_PrixHT,10)
// 20 %
CAS 20
SAI_PrixTTC = Calcul_TTC(SAI_PrixHT,20)
FIN
Ce code appelle la procédure Calcul_TTC pour calculer le montant TTC. Deux paramètres sont
passés à la procédure : le prix HT et le taux de la TVA. Le résultat renvoyé par la procédure
est directement affecté au champ SAI_PrixTTC.
1. Testez votre fenêtre ( parmi les boutons d’accès rapide). Donnez un prix HT. Sélectionnez
les différentes valeurs dans le champ Combo et cliquez sur le bouton "Calculer".
2. Le montant TTC s’affiche.
Conclusion
Cette partie vous a permis d’aborder les principaux concepts de la programmation WLangage de
WINDEV. De nombreuses autres fonctionnalités sont disponibles. Vous en découvrirez certaines
en suivant ce guide d’auto-formation.
Le WLangage est un langage très puissant permettant de développer également des applications
utilisant :
• la Programmation Orientée Objet (POO),
• le MVP (Modèle Vue Présentation),
• une programmation 3 tiers,
• des types avancés (XML, Email, ...), ...
Pour plus de détails, consultez l’aide en ligne concernant le sujet voulu.

Leçon 2.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 "Af-
fichage", dans le groupe "Aide à l’édition", cliquez sur "Afficher les numéros de ligne" (raccourci :
[CTRL]+[SHIFT]+[G]).

Question Existe-t-il un moyen d’obtenir facilement la syntaxe ou de l’aide sur une
fonction ?
Lors de la saisie d’une fonction sous l’éditeur de code :

• le nom de chaque paramètre est affiché dans une bulle dans la ligne de code en cours de
saisie. Pour le paramètre en cours de saisie, un survol du nom du paramètre permet
d’obtenir le détail du paramètre dans une bulle d’aide.
Si plusieurs syntaxes sont disponibles, il est possible de passer d’une syntaxe à l’autre
grâce aux touches [CTRL] + [ALT] + flèche droite ou flèche gauche.
• la syntaxe de la fonction s’affiche 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 ?
• [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]+[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).
• [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 Mes premières fenêtres" : sous le volet "Accueil", dans le
groupe "Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez "Mes premières fe-
nêtres (Corrigé)".
2. Ouvrez la fenêtre "FEN_Dialogue". Cette fenêtre illustre les différents modes de dialogue
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.

PARTIE 3
Ma première
base de
données
88 Partie 3 : Ma première base de données
• Présentation du projet réalisé dans cette partie
Partie 3 : Ma première base de données 89

Présentation du projet réalisée 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 4 de ce cours pour déve-
lopper une application complète. La base de données utilisée est HFSQL Classic, la base de don-
nées gratuite fournie avec WINDEV. Plus loin dans ce cours, nous étudierons la base de données
HFSQL Client/Serveur.

Leçon 3.2. WINDEV et les bases
de données

• Vocabulaire utilisé.
• Les différents modes d’accès aux bases de données.
Durée estimée : 5 mn

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.
• Oracle, SQL Server, MySQL, xBase, SQL Azure, ...
• AS/400, Access, Sybase, Informix, ...
• Toute base accessible en langage SQL sous Windows.
• Texte (fichiers ASCII).
Pour accéder aux données, il existe différentes techniques :
• Connecteur Natif (également appelé Accès Natif),
• Accès OLE DB,
• Accès ODBC direct,
• Accès ODBC via OLE DB.

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 CE, Windows 10),
sur les réseaux de toute taille et de tout type, et gère automatiquement plusieurs centaines d’ac-
cè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.
Les différents modes d’accès aux bases de données
Connecteur Natif (Accès Natif)

Un Connecteur 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 Connecteur 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)
• MariaDB (optionnel et gratuit)
• SQL Azure (optionnel et gratuit)
D’autres Connecteurs 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 multibase. Vous devez installer la couche
ODBC 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 "Source de données ODBC" (ou "Administrateur ODBC" selon la version de Windows utili-
sée).
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 et installez ce
pilote si nécessaire.
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.

Leçon 3.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.
Cette leçon permet de créer une application avec une base de données HFSQL.
Comme nous l’avons vu dans la leçon précédente, WINDEV permet également de
créer des applications manipulant d’autres bases de données.
Notes
La leçon "Annexe 2.2. Utiliser des données SQL", page 450 présente les mani-
pulations nécessaires pour créer un projet et une analyse basés sur une base de
données SQL (via OLE DB ou via un Connecteur Natif).
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 :

Astuce
1. Cliquer sur parmi les boutons d’accès rapide.

2. La fenêtre de création d’un nouvel élément 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’étape suivante à l’aide des flèches situées en bas.
6. Cette étape permet de définir la charte graphique. Sélectionnez "Gensteel". Passez à
l’étape suivante à l’aide des flèches situées en bas.
7. Cliquez sur l’étape "Base de données". Nous allons maintenant donner les renseignements
concernant la base de données.
8. 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’étape suivante 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’étape suivante 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 (tables) 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’étape suivante 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’étape suivante.
3. L’assistant propose la liste des rubriques à intégrer dans le fichier Client. Cette liste est
impressionnante car 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. Le fichier "Client est automatiquement créé sous l’éditeur d’analyses.
7. La fenêtre de création d’un nouvel élément s’affiche. Nous allons maintenant créer le fi-
chier de données contenant les commandes.
Création d’un fichier de données : création du fichier et des rubriques
Pour créer un fichier de données depuis la fenêtre de création d’un nouvel élément :
1. Cliquez sur "Données" puis sur "Fichier de données".
Il est également possible de créer un fichier de données directement depuis

Notes
l’éditeur d’analyses : 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".
4. Passez à l’étape suivante de l’assistant.

5. 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" permet d’avoir un

libellé clair lors de la description des liaisons entre les fichiers de données. Auto-
Notes
matiquement, un libellé est proposé à partir du nom du fichier.

Dans notre cas, saisissez "Une commande".
6. 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.
7. Passez à l’étape suivante 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’étape suivante.
8. 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 : "IDCommande".
Cette rubrique correspond à l’identifiant automatique du fichier de données. Cette rubrique 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, double-cliquez dans la colonne "Nom" de la
première ligne vide. 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é (un index) de notre fichier de données : les clés permettent
d’accélérer les accès aux données et les tris.
• Dans le cas d’une base de données au format SQL, le moteur utilise au mieux les index.
• Dans le cas d’un parcours séquentiel d’un fichier de données, il suffit d’indiquer l’index de
parcours (c’est-à-dire la clé).

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.
5. Il est également nécessaire de définir le sens de parcours de la clé. Le sens de parcours
permet de définir le tri par défaut de cette rubrique. Dans notre cas, lorsqu’un parcours sera
effectué sur cette clé, le tri par défaut sera "ascendant".
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 créé 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.
Un fichier CSV est un fichier texte utilisant un format spécifique. Ce fichier

Notes
contient des données sur chaque ligne. Les données sont séparées par un ca-
ractère de séparation (généralement une virgule, un point-virgule ou une tabula-
tion).
A partir du fichier CSV contenant les donné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. Sous le volet "Analyse", dans le groupe "Création", déroulez "Importer" et sélectionnez "Impor-
ter des descriptions de fichiers/tables".
Pour importer un fichier (CSV ou autre) dans l’analyse, il est également possible
Astuce
de réaliser directement un "Drag and Drop" du fichier CSV (présent dans l’explo-
rateur de fichiers Windows) vers l’éditeur d’analyses. Nous le verrons dans le
paragraphe suivant.
2. L’assistant d’importation de fichiers se lance.

3. Passez à l’étape suivante.
4. Sélectionnez le format des fichiers à importer. Ici, sélectionnez "Fichier texte". Passez à
l’étape suivante de l’assistant.

5. Indiquez le chemin du fichier à importer : "\Autoformation\Exercices\WD Ma Première Base
De Données\ModeRèglement.csv" présent dans le répertoire d’installation de WINDEV.
7. Indiquez les paramètres d’importation suivants :
• Enregistrements délimités par : "<Retour chariot/Saut de ligne>
• Colonnes délimitées par : "<Point-virgule>"
• Chaînes délimitées par : "<Aucun>"
• Séparateur décimal : "<Automatique : point ou virgule>"
8. N’oubliez pas de cocher l’option "La première ligne contient les noms des colonnes".
10. La structure du fichier de données qui va être créé apparaît. Conservez les options par
défaut. Passez à l’étape suivante.

11. 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 pro-
posées et passez à l’étape suivante.
12. Validez l’assistant. WINDEV crée le fichier de données.

Examinons la description du fichier de données importé :
1. Sélectionnez le fichier "ModeRèglement".
2. Dans le menu contextuel (clic droit), sélectionnez l’option "Description du fichier de don-
nées".
3. Dans la fenêtre qui s’affiche, modifiez le libellé du fichier : supprimez "(Importé)".
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. Effectuez 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.
Nous avons uniquement importé la description du fichier "Produit" dans l’ana-

lyse de notre projet. Les données contenues dans le fichier "Produit" n’ont pas
été importées dans le projet.
Attention !
Pour manipuler les données du fichier que vous venez d’importer, copiez dans
l’explorateur de fichiers, les fichiers "Produit.fic", "Produit.mmo" et "Produit.ndx"
(présents dans le répertoire "\Autoformation\Exercices\WD Ma Première Base
De Données") vers le sous-répertoire EXE du répertoire de votre projet.
Remarque : 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. Une liaison permet de
définir les contraintes d’intégrité (cardinalités) entre deux fichiers de données.
Créons tout d’abord la liaison entre le fichier "Client" et le fichier "Commande" : un client peut
avoir une ou plusieurs commandes et chaque commande est liée à un client.
1. Sous le volet "Analyse" (présent dans le ruban), dans le groupe "Création", cliquez sur "Nou-
velle 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
Vous pouvez également saisir directement les cardinalités de la liaison dans

l’assistant.
Notes

5. Passez à l’étape suivante. L’assistant propose automatiquement la clé utilisée par la liai-
son (IDClient).
6. Affichez l’écran suivant de l’assistant. L’assistant propose de créer la clé "IDClient" dans le
fichier Commande pour stocker le client correspondant à la commande.
7. Acceptez cette option en passant à l’écran suivant.

8. Cet écran permet de définir les règles d’intégrité qui seront automatiquement appliquées.
Dans notre cas, vous pouvez choisir le comportement que vous souhaitez lors de la suppres-
sion d’un client ainsi que le comportement lors de la modification de l’identifiant du client.
9. Validez les règles d’intégrité en passant à l’écran suivant.
10. Cliquez sur la flèche verte. La liaison est automatiquement créée dans l’éditeur d’ana-
lyses.
De la même manière, créez une liaison entre le fichier ModeRèglement et Commande. Ces
deux fichiers sont liés de la façon suivante :
• Une commande doit avoir un mode de règlement.
• Un mode de règlement peut être utilisé dans plusieurs commandes.
Dans l’assistant :
• Les cardinalités sont les suivantes : ModeRèglement (0,n), Commande (1,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, le fichier des lignes de commandes.
1. Créez de la même manière la liaison entre les fichiers.
2. Répondez aux questions posées par l’assistant :
• Chaque Produit a au moins une Commande : Non
• Chaque Produit peut avoir plusieurs Commandes : Oui
• Chaque Commande a au moins un Produit : Non
• Chaque Commande peut avoir plusieurs Produits : Oui
3. Passez à l’étape suivante. L’assistant propose de créer un fichier de relation. Conservez

l’option "Créer automatiquement le fichier de relation" et passez à l’étape suivante.
4. L’assistant propose la clé unique du fichier Produit à utiliser. Sélectionnez "Référence". Pas-
sez à l’étape suivante.
5. Validez la création de la clé en passant à l’écran suivant.
6. Conservez les options par défaut concernant les règles d’intégrité et passez à l’étape sui-
vante.
7. L’assistant propose la clé unique du fichier Commande à utiliser : "IDCommande". Passez à
l’étape suivante.
8. Validez la création de la clé en passant à l’écran suivant.
9. Conservez les options par défaut concernant les règles d’intégrité et passez à l’étape sui-
vante.
10. 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 "Produit_Commande".
2. Dans le menu contextuel (clic droit), sélectionnez l’option "Description du fichier de don-
nées".

3. Dans la fenêtre qui s’affiche, modifiez :
• le nom du fichier : "LigneCommande".
• le nom sur le disque : "LigneCommande".
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 "Réfé-
rence_IDCommande". Cette rubrique est une clé composée.
Une clé composée est un ensemble de rubriques constituant un index.

Notes
Ce type de clé permet de parcourir le fichier de données sur des critères com-
plexes ou de faire des recherches sur plusieurs rubriques simultanément.
3. Pour renommer cette rubrique :

• Cliquez dans la colonne "Nom".
• Remplacez "Référence_IDCommande" 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é,
TotalTTC et TotalHT.
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 : 
Conservez les options sélectionnées par défaut et validez (bouton vert).

4. 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.
5. La description des rubriques pour le fichier "LigneCommande" est la suivante.
6. 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 à valider les modifications de l’analyse (création de fichiers
de données, ajout ou suppression de rubriques, ...) et à les propager dans tout le projet (pages,
champs reliés, états, ...).
La génération est automatiquement proposée lorsque vous fermez l’éditeur d’analyses et que des
modifications ont été effectuées.
Il est également possible de générer l’analyse manuellement. C’est ce que nous allons faire.
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é.
• Passez à l’étape suivante.

• L’assistant propose de réaliser une sauvegarde des fichiers de données existants, ne chan-
gez rien et passez à l’étape suivante.
• 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’étape
suivante.
• 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 4 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 3.4. Le RAD complet
• Qu’est-ce que 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".
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 Table 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’étape suivante.

8. Indiquez si le menu automatique doit être intégré à l’application. Répondez "Oui : Intégrer
le menu ‘?’".
9. Passez à l’étape suivante. 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 options proposées par 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 23.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. 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.
8. Fermez la fenêtre de tests. L’éditeur de WINDEV réapparaît.

PARTIE 4
Application
complète avec
données
126 Partie 4 : Application complète avec données
• Présentation de l’application réalisée dans cette partie
Partie 4 : Application complète avec données 127

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)".
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 4.2 à 4.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)".
• Un projet corrigé correspondant aux leçons 4.5 à 4.9. Ce projet contient la totalité de l’applica-
tion proposée.
Pour utiliser ce projet corrigé :
"Application complète (Corrigé)".

Leçon 4.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, 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)".
"Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez l’option "Application com-
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 création 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 (ou utilisez le raccourci CTRL N).
• La fenêtre de création d’un nouvel élément s’affiche : cliquez sur "Fenêtre" puis sur "Fe-
nêtre".
• Dans l’assistant, cliquez sur l’onglet "Basée sur un modèle" et choisissez "Utiliser : FEN-
MOD_Modèle". Validez.

Les modèles 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
Notes
contenir du code. Dans ce cas, ce code sera également commun à toutes les
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. La fenêtre de sauvegarde de l’élément créé
apparaît.
3. Dans cette fenêtre, indiquez le titre de la fenêtre : "Menu".
4. 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.
5. 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 de WINDEV permet de visualiser ou de modifier des données :

• en mémoire : on parle alors de champ Table mémoire ou champ Table
remplie 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’étape suivante en cliquant sur la flèche en bas
de l’assistant.

4. L’étape suivante 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’étape suivante.
5. L’assistant propose la liste des rubriques présentes dans le fichier "Produit". 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’étape suivante.

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’étape suivante.

7. Les étapes suivantes 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. Le champ est automatiquement
positionné et agrandi afin d’occuper tout l’espace disponible dans la fenêtre.
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 sont utilisés dans les fenêtres ou les états ma-
nipulé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.
1. Cliquez sur parmi les boutons d’accès rapide.
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 (ou à l’aide des flèches du clavier).
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
affiché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 entê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".
• Cliquez sur parmi les boutons d’accès rapide.
• La fenêtre de création d’un nouvel élément s’affiche : cliquez sur "Fenêtre" puis sur "Fe-
nêtre".
• L’assistant de création de fenêtres se lance.
• Dans l’onglet "Basée sur un modèle", choisissez "Utiliser : FENMOD_Modèle" et validez l’as-
sistant.
3. La fenêtre de sauvegarde apparaît. Saisissez le titre de la fenêtre : "Fiche du produit". Le
nom "FEN_Fiche_du_produit" est automatiquement proposé.
4. 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 la multisélection 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.
7. Enregistrez la fenêtre.
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" :
1. Sous le volet "Création", dans le groupe "Champs usuels", déroulez "Bouton" (cliquez sur la
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. Dans le ruban, affichez le volet "Alignement" de WINDEV. Ce volet contient toutes les op-
tions d’alignement 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 et/ou redimensionné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.

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 à l’aide des poignées de redimensionnement.
3. Diminuez la taille du champ Table :
• Maintenez la touche [SHIFT] enfoncée.
• Réduisez le champ Table à l’aide de ses poignées de redimensionnement.
Notes
L’utilisation de la touche SHIFT permet de ne pas prendre en compte les options

d’ancrage des champs lors du redimensionnement.
4. 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 (également appelée
"complétion") : dès que vous allez taper la parenthèse ouvrante "(", une liste dé-
Notes roulante va s’ouvrir proposant le nom de toutes les fenêtres existantes dans le
projet. Il suffit de sélectionner la fenêtre 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 (appelée "Zone d’accueil"), 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".
3. Fermez la fenêtre de code.
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 :
1. Sous le volet "Création", dans le groupe "Champs usuels", déroulez "Bouton" : la liste des bou-
tons prédéfinis s’affiche. Cliquez sur "Modifier".
2. La forme du bouton apparaît sous la souris. Cliquez ensuite dans la fenêtre, sous l’image
du produit.
3. Redimensionnez si nécessaire le bouton (à l’aide des poignées) pour que le bouton ait la
même largeur que le champ Image.
Notes
Lors du redimensionnement du champ, un effet de magnétisme automatique

simplifie l’alignement du bouton avec le champ Image.
4. Faites un clic droit sur le bouton. Dans le menu qui s’affiche, sélectionnez l’option "Code".

fSélecteurImage(
6. 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.
7. 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...”)
8. 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.
9. 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()
• 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 "FEN_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)
• 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)
• 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()
• 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".
Le code de test du nouvel enregistrement peut être remplacé par la fonction

HEnregistre. Cette fonction permet de tester si l’enregistrement est déjà présent
dans le fichier de données, et selon le cas elle permet soit de l’ajouter, soit de le
Notes
modifier. Le code devient alors :

EcranVersFichier()
HEnregistre(Produit)
Ferme()

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 WD
• 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
• 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 : 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 affichée
Notes
à l’utilisateur. Cette fenêtre permet à l’utilisateur de modifier directement 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 par la
fenêtre de bienvenue de WINDEV (CTRL <), via l’option "Ouvrir un exemple".
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’entête de la colonne "Référence"), les
deux enregistrements que nous avons ajoutés apparaissent.

Leçon 4.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 "Onglet et associés" et sélec-
tionnez "Onglet".
• Cliquez dans la fenêtre pour créer le champ Onglet.
• Positionnez le champ Onglet en haut à gauche de la fenêtre.
• Par défaut, un champ Onglet est créé avec deux volets. Le champ Onglet occupe toute la
place disponible dans la fenêtre.
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
cours, cliquez sur un autre volet d’onglet : tous les champs associés à l’onglet
Notes
disparaissent.
• 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 "Volet2". 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. La liste des volets est affichée à gauche. Pour chaque volet sélectionné,
ses caractéristiques sont modifiables dans la partie droite de l’écran.
2. Dans la fenêtre de description, sélectionnez le volet "Liste des produits".
3. Les caractéristiques du volet sont affichées.
4. Nous allons associer une image à l’onglet grâce au catalogue d’images de WINDEV.

Notes Dès qu’une image peut être affichée dans un champ ou une fenêtre, WINDEV
propose d’utiliser le catalogue d’images. Ce catalogue d’images est lancé via
l’option "Catalogue" (disponible en cliquant sur le bouton ). Ce catalogue
contient plusieurs milliers d’images, de cliparts, ...
5. Cliquez sur le bouton à droite du champ "Image". Dans le menu contextuel qui s’affiche,
sélectionnez l’option "Catalogue". La fenêtre du catalogue d’images apparaît.
6. Sélectionnez le thème “Flat Soft” dans la combo “Thème”, puis saisissez "Produit" dans la
zone de recherche. Lancez la recherche en cliquant sur la loupe.
7. Sélectionnez l’image et validez (bouton vert).

8. 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.
9. 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.
10. Dans la fenêtre de description, cliquez sur "Recherche de clients" dans la liste des volets
statiques.
11. Cliquez sur le bouton à droite du champ "Image". Dans le menu contextuel qui s’af-
fiche, sélectionnez l’option "Catalogue". La fenêtre du catalogue d’images apparaît.
12. Dans la zone de recherche, indiquez "Personne" (le thème "Flat Soft" utilisé pour notre
dernière recherche est sélectionné par défaut). 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 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êts 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 des données d’un fichier ou d’une requête existante". Pas-
sez à l’étape suivante de l’assistant.
5. Sélectionnez le fichier de données "Client". Passez à l’étape suivante.
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’étape suivante.
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".

9. 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’étape
suivante.
10. Le champ Combo ne sera lié à aucune rubrique. Conservez l’option "Non" et passez à
11. Validez l’écran suivant avec la flèche jaune.
12. Donnez un nom au champ (par exemple "COMBO_Client") et un libellé (par exemple "Client
recherché").
13. Validez. Positionnez le champ Combo dans la fenêtre (par exemple en haut à gauche).
14. 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.
// 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.

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 si nécessaire 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 4.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.
Qu’est-ce qu’une requête de sélection ?

Une requête de sélection est une requête qui va "choisir" uniquement les enre-
Notes
gistrements correspondant aux critères spécifiés.

Ce type de requête s’appelle une requête de sélection car en langage SQL l’ordre
SELECT est utilisé.

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.

s’affiche : cliquez sur "Requête". L’assistant de création d’une requête 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’étape suivante.
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.
Remarque : Pour faire apparaître les rubriques des différents fichiers de données, il suffit de
cliquer sur la flèche présente devant le nom du fichier.
Nous voulons afficher :
• les renseignements concernant la commande. Déroulez le fichier "Commande" (clic sur la
flèche ) puis double-cliquez sur les rubriques : IDCommande, Date, Etat et TotalHT.
• les renseignements concernant le client ayant passé la commande. Déroulez le fichier
"Client" (clic sur la flèche ) puis double-cliquez sur la rubrique "NomComplet".
• les renseignements concernant le mode de règlement de la commande. Déroulez le fichier
"ModeRèglement" (clic sur la flèche ) puis 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 bleue 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 fenêtre de sauvegarde apparaît. Validez les informations proposées.
10. La représentation graphique de la requête est affichée :

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 :
• un fichier XLS (Excel).
Notes
• un fichier Word ou OpenOffice.

• un fichier XML (eXtensible Markup Language).
• un fichier texte.
• un fichier HFSQL.

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 (ou bien dans le
menu contextuel, utilisez l’option "Description 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 à".

• Sélectionnez "au paramètre".
• Indiquez le nom du paramètre "pEtat".
Nous vous conseillons de préfixer les paramètres des requêtes par "p". Il est
ainsi possible de les retrouver très facilement dans l’éditeur de code.
Notes
Si vous recherchez un paramètre de la requête, saisissez simplement ‘p’ et la

complétion de l’éditeur de code vous propose tous les paramètres.

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 l’icône présente à droite de la rubrique.
• 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 :
• Sélectionnez "au paramè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. Cliquez sur le bouton "Entre deux dates ...". Ce bouton permet de définir directement une
condition de sélection.
3. Dans la fenêtre qui s’affiche :
• La condition de sélection est "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élections 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/2013".
• Sélectionnez le paramètre pFinPériode. Dans la partie basse de l’écran, saisissez
"31/03/2013".
• 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 multicritè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 multi-critè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 partie "Description d’un volet statique", saisissez le libellé du volet : "Recherche de
commandes".
7. Nous allons associer une image à l’onglet grâce au catalogue d’images de WINDEV. Cliquez
sur le bouton à droite du champ "Image". Dans le menu contextuel qui s’affiche, sélection-
nez l’option "Catalogue". La fenêtre du catalogue d’images apparaît.
8. Dans la zone de recherche, indiquez "Recherche" et sélectionnez si nécessaire le thème
"Flat Soft". Lancezla recherche en cliquant sur la loupe.
9. Parmi les images proposées, sélectionnez l’icône représentant les jumelles et validez.
10. 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ère.
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éé précédemment). Sélectionnez l’option "Afficher les données d’un fichier ou d’une requête
existante". Passez à l’étape suivante 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’étape suivante de l’assistant.

6. Sélectionnez si nécessaire toutes les rubriques proposées.

8. Conservez les options par défaut dans les différentes étapes de l’assistant et validez la
création du champ Table.
9. Le champ Table est automatiquement créé dans l’onglet "Recherche de commandes".
10. 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 à l’aide des poignées de
redimensionnement des colonnes.
7. Diminuez la taille de la colonne "Mode de règlement" afin que toutes les colonnes appa-
raissent dans le champ Table.
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.
Live Data et champs basés sur des requêtes

Notes
Le Live data n’est pas affiché dans les champs utilisant une requête comme
source de données pour la raison suivante : 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 = “20130101”
MaSource.pFinPériode = “20130331”
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 utiliser 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 le code suivant :
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 le volet d’onglet, en haut à droite.
2. Sélectionnez le champ puis tapez sur la touche [ENTREE] du clavier. Le libellé du bouton
passe en édition. Saisissez "Rechercher" et appuyez sur la touche [ENTREE] 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, utilisez la combinaison de touches [CTRL F]. Dans le champ de
recherche, saisissez "BTN_Recherche".
• Le style est automatiquement sélectionné. 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’étape suivante.
6. La rubrique à afficher dans le champ Combo est "Libellé". Décochez "IDModeRèglement" et
cochez "Libellé". Passez à l’étape suivante.
7. Sélectionnez la rubrique de tri : "Libellé". Passez à l’étape suivante.
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’étape suivante.
9. Conservez les options par défaut dans les différentes étapes de l’assistant et validez la
création 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 (champ
"Valeur initiale" en bas de la fenêtre de description). 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 utiliser 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.pIDModeReglement = “1”
par le code :
MaSource.pIDModeReglement = 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 :
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 principal 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.
De plus, 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 également ê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 utiliser 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 = “20130101”
MaSource.pFinPériode = “20130331”
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 4.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
• Etat multicolonne
• Mailing
• Formulaire
• Composite
• Agenda ou planning
• Diagramme de Gantt
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
"Aide en ligne", déroulez "Guide d’Auto-formation" puis sélectionnez "Application
complète (Avec fenêtres)".
Corrigé
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é)". Dans ce cas, pour suivre la
suite de ce cours, sélectionnez la configuration "Exécutable Windows 32 bits"
dans l’explorateur de projet.
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 fonc-
tionnalité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 23.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 :
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 307.
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" :

1. Si nécessaire, sous l’éditeur de fenêtres, affichez l’onglet "Recherche de commandes" (cli-
quez dessus).
"Etat sur champ table".
3. 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.
4. 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" dans l’onglet "Recherche de commandes").
5. L’état est immédiatement créé.
6. Une fenêtre s’affiche proposant de sauvegarder l’état. Validez.
7. L’éditeur d’états apparaît avec l’état qui a été automatiquement créé.

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.
9. 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).
10. Modifiez si nécessaire la taille et la position du bouton "Imprimer" (pour qu’il ait la même
taille que le bouton "Rechercher").
12. Testez la fenêtre : cliquez sur parmi les boutons d’accès rapide.
• Sélectionnez si nécessaire l’onglet "Recherche de commandes".
• Définissez les différents paramètres de la recherche :
• Cliquez sur le bouton "Rechercher".
13. Lorsque les données sont affichées dans le champ Table, utilisez le bouton d’impression
ou l’option "Imprimer" du menu contextuel du champ Table : l’état que vous venez de créer
est utilisé dans les deux cas.

Leçon 4.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.
Corrigé

puis sélectionnez "Application complète (Corrigé)". Dans ce cas, pour suivre la
suite de ce cours, sélectionnez la configuration "Exécutable Windows 32 bits"
dans l’explorateur de projet.
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 don-

né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.
s’affiche : cliquez sur "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’étape suivante.
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 :
• Cochez "au paramètre".
• 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).

8. La représentation graphique de la requête est affichée :

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. La fenêtre de création d’un nouvel élément s’affiche : cliquez sur "Etat" puis sur "Etat". L’as-
sistant 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’étape suivante.

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 à
6. Dans la liste des fichiers de données et des requêtes, sélectionnez la requête "REQ_BonDe-
Commande". Passez à l’étape suivante.

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 à
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 "Entê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 "Entête
de page".
• Les rubriques concernant la commande vont également être affichées dans le bloc "Entê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 "Entê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 pied 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".
Le tableau suivant fournit les différentes affectations des rubriques dans l’ordre présenté
dans l’assistant :
Rubrique Bloc
NomComplet Entête de page
Adresse Entête de page
CodePostal Entête de page
Ville Entête de page
Pays Entête de page
IDCommande Entête de page
Date Entête de page
Référence Corps
Libellé Corps
PrixHT Corps
Quantité Corps
TotalHT Corps
TotalHT_Co Pied de page
TotalTTC Pied de page

10. 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’étape suivante.
11. Cette étape 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.

13. 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’étape suivante.
14. 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é.

15. Validez.
16. L’état étant trop grand pour être imprimé en mode Portrait, l’éditeur d’états propose d’uti-
liser le mode paysage, de réduire le tableau ou d’imprimer le tableau sur plusieurs pages.
Dans notre cas, acceptez le mode paysage.
17. Si nécessaire, acceptez ensuite de réduire le tableau.
18. La fenêtre de sauvegarde de l’état apparaît. Validez les informations de sauvegarde.
19. L’état apparaît en édition sous l’éditeur d’états :
20. Les différentes lignes de la commande sont regroupées sous forme de tableau.

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.
• 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.
Fermez l’aperçu avant impression.

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 l’entête de page :
1. Supprimez le libellé "Bon de commande" présent dans l’entête 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 "Entête de
page").
Nous allons positionner les totaux correctement dans le pied de page :
1. Sélectionnez les champs (libellés et rubriques) correspondant aux totaux présents dans le
pied de page.
2. Positionnez ces champs à l’aide de la souris en bas à droite du tableau.
Modifiez les options d’impression du bloc "Pied de page" :
1. Affichez la fenêtre de description du bloc "Pied de page" :
• Cliquez dans le bloc "Pied 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 "Pied de page" sur la dernière page.
• Le bloc "Pied 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 :
5. Enregistrez l’état en cliquant sur parmi les boutons d’accès rapide.
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 de la table" 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. Cliquez dans la fenêtre pour valider le menu contextuel.

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

puis sélectionnez "Application complète (Corrigé)".
Création de l’état
Pour créer un état :

1. Cliquez sur le bouton parmi les boutons d’accès rapide.
2. La fenêtre de création d’un nouvel élément s’affiche : cliquez sur "Etat" puis sur "Etat". L’as-
sistant de création d’états se lance. L’assistant de création d’états propose plusieurs types
d’états :
3. Sélectionnez "Tableau". Passez à l’étape suivante.

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’étape suivante.
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’étape suivante.
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 entête de rupture et d’une fin de rupture.
Notes
Les informations communes aux différentes lignes sont présentes dans l’entê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’étape suivante.

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 maintenant indiquer dans quel ordre sont imprimées les rubriques et leur répar-
tition dans les différents blocs. Dans notre exemple :
• seul le pays sera dans le bloc "Début de rupture 1". La rubrique "Pays" est automatiquement
associée au "Début de rupture 1".
• seul l’état sera dans le bloc "Début de rupture 2". La rubrique "EtatProvinceRégion" est auto-
matiquement associée au "Début 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’étape
suivante.

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’étape suivante.
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. Acceptez de passer en mode paysage en validant.
22. Acceptez de réduire l’état en validant.

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 (volet "Imprimer").
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)
• 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
• 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 4.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. Ce type de présentation peut être utilisé par exemple pour suivre :
• l’évolution des commandes dans le temps,
• l’évolution du chiffre d’affaires,
• 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. La fenêtre de création d’un nouvel élément s’affiche : cliquez sur "Requête".
3. Nous allons réaliser une requête de sélection. Sélectionnez l’option "Sélection (SELECT)".
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 la fenêtre de description de la requête.
5. La représentation graphique de la requête est la suivante :
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 droite de l’écran, saisissez le libellé du volet d’onglet : "Graphe".
6. Dans la partie droite de l’écran, sélectionnez une image dans le catalogue d’images :
• Cliquez sur le bouton à droite du champ "Image". Dans le menu contextuel qui s’affiche,
sélectionnez l’option "Catalogue".
• La fenêtre du catalogue d’images apparaît.
• Dans le champ de recherche, saisissez "Graphe".
• Sélectionnez le thème "Flat Soft" et validez.
• Sélectionnez par exemple l’icône 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’étape suivante
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’étape suivante.

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 "Sources 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_Evo-
lutionsVentes.

8. Nous n’allons pas associer d’image de fond au champ Graphe. Passez à l’étape suivante.
9. Donnez un nom au champ Graphe : "GRF_EvolutionsVentes" et validez l’assistant.
10. Le champ Graphe est automatiquement créé sous l’éditeur.
11. Cliquez sur pour tester la fenêtre.

12. 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, ...

13. Terminez le test et revenez sous l’éditeur.
Pour maîtriser l’utilisation d’un champ Graphe, n’hésitez pas à étudier les
exemples fournis avec WINDEV :
Exemple
• Exemple unitaire : Champ Graphe

• Exemple didactique : WD Graphe
Ces exemples sont disponibles depuis la fenêtre de bienvenue de WINDEV
(CTRL <).
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 droite de l’écran, saisissez le libellé du volet d’onglet : "Tableau croisé dyna-
mique".
6. Dans la partie droite de l’écran, sélectionnez une image dans le catalogue d’images :
• Cliquez sur le bouton à droite du champ "Image". Dans le menu contextuel qui s’affiche,
sélectionnez l’option "Catalogue".
• La fenêtre du catalogue d’images apparaît.
• Dans le champ 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 entê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
entête trois niveaux d’informations : les années, les trimestres et les mois.
8.  Validez et passez à l’étape suivante.

9. Dans les entê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 entête de ligne (Client.Pays et Produit.Li-
bellé). Validez chaque liaison et passez à l’étape suivante.
11. Donnez un nom au champ Tableau Croisé Dynamique : TCD_Ventes.
13. 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.
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’entê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 4.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 nécessaires pour gérer l’envoi et la réception d’emails.
Vous pouvez également accéder à 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 :
• Gestion via Lotus Notes, Outlook ou MS Exchange :
• Le logiciel de messagerie Lotus Notes ou Outlook : grâce à ces logiciels, il est possible
d’envoyer et de recevoir des emails.
• 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.
• Gestion via les protocoles POP3, IMAP et SMTP :
• Le protocole POP3 : ce protocole de réception des emails est reconnu par tous les fournis-
seurs de services. Il permet de dialoguer directement avec le serveur, disponible chez votre
fournisseur d’accès. Ce protocole permet de lister les messages reçus et de les lire.
• 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 depuis différents clients de messagerie ou web-
mails.
• Le protocole SMTP : ce protocole d’envoi d’emails est reconnu par tous les fournisseurs de
services.
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 :

Nous allons pour cela, utiliser le protocole SMTP. En effet, c’est le mode qui est actuellement le
plus utilisé dans le monde.
Pour plus de détails sur les autres méthodes, consultez l’aide en ligne.
Pour suivre cette leçon, il est nécessaire d’avoir effectué les leçons de cette par-
tie jusqu’à la leçon "Leçon 3.7. Imprimer une liste de clients", page 220.
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 la fenêtre de bienvenue de WINDEV (CTRL <).
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 :

• Cliquez sur parmi les boutons d’accès rapide.
• La fenêtre de création d’un nouvel élément s’affiche : cliquez sur "Fenêtre" puis sur "Fe-
nêtre".
• L’assistant de création de fenêtre se lance.
• Dans l’onglet "Basée sur un modèle", sélectionnez "Utiliser : FENMOD_Modèle" et validez
l’assistant.
3. La fenêtre de sauvegarde de l’élément créé apparaît. Cette fenêtre a pour titre "Envoi d’un
email", son nom "FEN_Envoi_d_un_email" est automatiquement proposé. Validez les informa-
tions proposé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.)".

3. Enregistrez la fenêtre ( ou CTRL S).
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’étape suivante.

5. Sélectionnez le fichier "Client". Passez à l’étape suivante.
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’étape suivante.
8. La valeur de retour est également la rubrique "Email". Passez à l’étape suivante.
9. Conservez les options par défaut. Passez à l’étape suivante.
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’étape suivante.
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 un champ de saisie
pré-défini de type fichier. Grâce au menu contextuel du champ (option "Parcourir"), l’utilisa-
teur pourra sélectionner le fichier à joindre.
1. Sous le volet "Création", dans le groupe "Champs usuels", déroulez "Saisie". La liste des
champs pré-définis disponibles par défaut s’affiche.
2. Sélectionnez le champ "Fichier" et réalisez un "Drag and Drop" 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éé.
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
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 SAI_Fichier <> “” ALORS
EmailChargeFichierAttaché(MonMessage, SAI_Fichier)
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 champ 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.
5. Enregistrez la fenêtre ( ou CTRL S).
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 l’ouverture de la fenêtre
d’envoi d’emails.

Leçon 4.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é : 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 l’option "Répertoire des don-
né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. Fermez la fenêtre de configuration.
8. 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 4.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’appel d’une procédure PRIVEE ne sera pas permis mais la
documentation concernant l’utilisation de la procédure 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,
• ou dans les trois types d’applications.
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é

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’étape suivante.
3. Donnez un nom à votre configuration de projet : par exemple "CompoCommandesParVille".
4. Conservez les options proposées par défaut. Passez à l’étape suivante.
5. Sélectionnez les éléments à intégrer dans la configuration de projet. Dans cet exemple, ces
éléments seront également présents dans le composant.
• Cliquez sur le bouton "Aucun".
• Sélectionnez les éléments "REQ_CommandesParVille" et "COL_Composant".
6.  Passez à l’étape suivante 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’étape suivante de l’assistant.
WINDEV liste les éléments à intégrer dans le composant (éléments spécifiés dans la configu-
ration et dans l’analyse).
3. Sélectionnez tous les éléments (bouton "Tous") et passez à l’étape suivante.

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’étape suivante.
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’étape suivante.

9. Saisissez les différentes informations concernant le composant :
• Propriétaire,
• Libellé, Copyright, ...
11. Vous pouvez associer une image à votre composant. Passez à l’étape suivante.
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’étape suivante. 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’étape suivante. Vous avez la possibilité de modifier la documentation générée.
Nous n’allons pas y toucher. Passez à l’étape suivante.
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’étape suivante.
16. Nous n’allons pas enregistrer le composant dans le GDS. Passez à l’étape suivante.
17. Il ne reste plus alors qu’à donner un nom physique à notre composant.

Validez. Un message indique que le composant a été généré. Validez le message en cliquant
sur "Terminer".
Voilà, votre premier composant est maintenant créé, il est prêt à l’emploi !
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 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".
Si vous avez créé le composant à partir de :

• l’exemple "WD Application Complète (Exercice)", sélectionnez le sous-répertoire
"EXE\CompoCommandesParVille", puis le fichier "CompoCommandesParVille.
wdi". Le projet "WD Application Complète (Exercice)" est disponible dans le
Notes
sous-répertoire "Autoformation\Exercices\WD Application Complète".

• l’exemple "WD Application Complète (avec fenêtres)", sélectionnez le sous-
répertoire "EXE\CompoCommandesParVille", puis le fichier "CompoCom-
mandesParVille.wdi". Le projet "WD Application Complète (avec fenêtres)" est
disponible dans le sous-répertoire "Autoformation\Exercices\WD Application
Complète (Avec fenêtres)".

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.
• 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. Dans ce cas, il est également possible
de définir le mode de chargement du composant.
8. Validez (bouton "Fermer"). 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 la sauvegarde.
2. Affichez le code associé à la fenêtre (option "Code" du menu contextuel).
3. 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".

Par exemple :
LocalisationDonnées(...// Indiquez le chemin de VOS données

“C:\WINDEV\Autoformation\Exercices\”+ ...
“WD Application Complète\Exe\Exécutable Windows 32 bits\”)
Si votre projet utilise une autre procédure nommée "LocalisationDonnées", il sera

Notes
nécessaire de préfixer le nom de la procédure du composant par le nom de la col-

lection de procédures utilisée pour supprimer l’ambiguïté. Le code devient alors :
COL_Composant.LocalisationDonnées(...

5. 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", rempli par programmation et 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 = 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" (en respectant la casse) 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.
Fermez le projet "CompoUtilisation" : sous le volet "Accueil", dans le groupe "Général",

déroulez "Fermer" et sélectionnez "Fermer le projet".
Ouvrez le projet "WD Application Complète" précédemment manipulé (par exemple, affichez
la fenêtre de bienvenue et sélectionnez le projet "WD Application Complète" présent dans les
projets récents). 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 4.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 plateforme 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é

puis sélectionnez "Application complète (Corrigé)"

Si nécessaire, placez-vous sur la configuration de projet "Exécutable Windows 32 bits" : dans
l’explorateur de projet, dans le dossier "Configurations", double-cliquez sur "Exécutable
Windows 32 bits".
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".
2. L’assistant d’importation se lance. Passez à l’étape suivante.
3. Indiquez l’adresse à laquelle la description WSDL du Webservice doit être importée : http://
exemples.webdev.info/WSAUTOFORMATIONV2_WEB/awws/WSAutoformationV2.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’étape suivante. 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 importés" de l’explorateur de projet.
6. Dans l’explorateur de projet, déroulez le dossier "Webservices importés".

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 (WSAutoformationV2 dans cet exemple),
• le nom de chaque fonction (ProduitEnStock dans cet exemple)
Pour connaître le mode d’appel du Webservice, il suffit de double-cliquer sur le nom de la fonction
dans l’explorateur de projet. L’éditeur de code affiche la description de la fonction, avec le proto-
type de l’appel 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é du 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 :
// Affiche la réponse du Webservice
InfoConstruit(...
“Nombre de produits “”%1”” en stock : %2”,
COL_Référence, ProduitEnStock(COL_Référence))
• La fonction du Webservice ProduitEnStock est appelée. Ce code utilise le prototype de la
fonction que nous avons précédemment affiché dans l’éditeur de code.
• 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 4.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, à la gestion des tests automatiques et à l’optimisation des requêtes.
Corrigé

puis sélectionnez "Application complète (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.

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.
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 scénario".
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
Note
ce cas, fermez la fenêtre en utilisant 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. L’éditeur de tests affiche le code WLangage du test que vous venez d’enregistrer :
Le test est actuellement disponible et n’est pas passé (icône devant le nom du test
sous l’éditeur).
12. Le test peut être lancé à tout moment :
• Sélectionnez le nom du test sous l’éditeur de tests.
• Dans le menu contextuel (clic droit), sélectionnez "Lancer".
13. Le test s’exécute automatiquement et l’éditeur de tests affiche le résultat dans une nou-
velle fenêtre (le test est passé avec succès dans notre cas).
14. Validez le résultat du test et enregistrez le test si nécessaire.
Les fonctions WLangage permettant de réaliser des tests automatiques sont les
Note
fonctions PiloteXXX.
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. Retournez sous l’éditeur de tests (cliquez sur le bouton correspondant dans la barre des
éléments ouverts).
8. Lancez à nouveau le test.

9. Le test apparaît de nouveau sous l’éditeur de tests. Le volet des erreurs de compilation
signale plusieurs erreurs de test.
10. Affichez à nouveau la fenêtre "FEN_Menu" sous l’éditeur.
11. Affichez la description du bouton "Rechercher" (option "Description" du menu contextuel).
12. Dans l’onglet "IHM", sélectionnez l’option "Actif".
14. Retournez sous l’éditeur de tests (cliquez sur le bouton correspondant dans la barre des
éléments ouverts).
15. 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
WLangage 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 si nécessaire (par exemple double-cliquez sur "TEST_Menu" dans
l’explorateur de projet).
2. Ajoutez le code suivant avant la ligne "PiloteMenu("_Menu","OPT_Quitter") :
// 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
3. Enregistrez le test.
4. Cliquez sur l’icône . 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 4.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écu-

Note
tables Linux, des services, des applications Java, ...
2. L’assistant de création d’exécutable se lance.

3. Décrivez 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. Plusieurs types de splash screen sont disponibles. 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’étape suivante.

4. Pour le fonctionnement de l’exécutable, nous garderons les options par défaut. Passez à
5. Vous pouvez personnaliser le message d’erreur de l’application. Nous garderons le mes-
sage proposé par défaut. Passez à l’étape suivante.
6. L’assistant propose d’activer la télémétrie dans l’application. Nous n’utiliserons pas cette
fonctionnalité. Passez à l’étape suivante.
La télémétrie permet d’obtenir des statistiques détaillées sur l’utilisation

de votre application par les utilisateurs finaux. Grâce à la télémétrie, vous
connaissez tout de vos applications déployées et vous pouvez facilement les
Note
améliorer.
Pour plus d’information sur la mise en place et la configuration de la télémé-
trie, consultez l’aide en ligne.

7. Cette étape 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’étape suivante.

8. Cette étape 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’étape
suivante.
9. Cette étape 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’étape suivante.
10. Cette étape concerne le répertoire des fichiers de données HFSQL Classic manipulés par
l’application.
Sélectionnez si nécessaire l’option "Automatique (conseillé)". Cette option permet d’installer

les fichiers de données :
• soit dans le répertoire des données de l’application (si l’exécutable est installé dans "Pro-
gramme files").
• soit dans le répertoire de l’exécutable.

12. Nous allons maintenant saisir les informations de l’exécutable. Ces informations sont affi-
chées sous l’explorateur Windows en sélectionnant les propriétés du fichier.
Saisissez par exemple les informations suivantes :
Cette étape permet également de signer si nécessaire l’exécutable.

13. Cette étape 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.
15. Nous allons maintenant définir les options d’intégration du framework WINDEV.

Le framework correspond aux différentes librairies nécessaires au fonction-
Note
nement de l’exécutable.
L’option "Dll du framework à côté de l’exécutable" permet d’utiliser uniquement les librairies
nécessaires. Ces DLL sont copiées dans le répertoire de l’exécutable.
L’option "Framework intégré dans l’exécutable" permet de diffuser uniquement l’exécutable
(les DLL étant présentes dans l’exécutable).
L’option "Framework commun" permet d’utiliser le framework commun à toutes les applica-
tions WINDEV installées sur le poste. Avec cette option, le framework est installé 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.
16. Sélectionnez "Framework commun" puis choisissez "Framework WINDEV commun".
17. Cette étape concerne Windows Vista (et supérieur). Il est possible d’intégrer un manifeste
pour une utilisation sous Windows Vista (et supérieur).
Pour notre exemple, cochez l’option "Ne pas intégrer de manifeste pour Windows Vista et
supérieur".
18. WINDEV propose de réaliser une sauvegarde du projet. Cette sauvegarde 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.
19. 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’options à renseigner, mais après une
première configuration de vos choix, vous pourrez valider dès le début toutes les étapes de l’assis-
tant.
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 simplifiée grâce à un assistant. Cet assistant vous permet de défi-
nir 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
bouton 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.
2. Nous avons déjà créé l’exécutable : les options choisies sont mémorisées.
3. Cliquez dans l’assistant sur l’intitulé "Compléments" de la partie "Exécutable".
4. L’assistant propose de réaliser une sauvegarde du projet. Sélectionnez l’option "Non : Ne
pas faire de sauvegarde du projet" et passez à l’étape suivante.
5. L’assistant propose de créer la page des nouveautés.
Cette option permet de créer un fichier d’aide pour présenter à l’utilisateur final les nouveau-
tés de la version. Lors d’une première installation, ce fichier peut correspondre à l’aide du lo-
giciel.

Sélectionnez l’option "Créer une documentation des nouveautés" et passez à l’étape sui-
vante.
6. Vous pouvez définir les éléments qui seront automatiquement intégrés au fichier d’aide.
Conservez les options par défaut et passez à l’étape suivante.
Si l’application possède déjà un système d’aide, il est possible de l’utiliser pour

Note
le compléter avec une page de nouveautés.
7. Validez le message. L’exécutable est automatiquement créé (avec les options que nous
avons définies lors de la création de l’exécutable) et le système d’aide est créé. Vous pouvez
saisir les informations spécifiques dans le système d’aide. Pour l’exemple, laissez les infor-
mations créées par défaut. Pour reprendre la création du programme d’installation, cliquez
sur l’option "Poursuivre la création de la procédure d’installation".
L’aide est automatiquement compilée.

8. 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.
9. Choisissez une installation standard. Passez à l’étape suivante.
10. Nous ne changeons pas le répertoire d’installation par défaut. Passez à l’étape suivante.
11. Dans la liste des fichiers installés, conservez les fichiers proposés. Par défaut, WINDEV
propose 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. Les fichiers sont automatiquement positionnés dans le répertoire commun des
données.

13. Dans les paramètres de la base de données, décochez toutes les options. Passez à
14. 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’étape suivante.
15. Nous allons sélectionner WDOptimiseur. Cet outil permet d’optimiser régulièrement les
fichiers de données de l’application.
16. 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.
17. Validez. Le programme d’installation est automatiquement créé.
18. 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. Deux modes d’installation sont disponibles :

• Installation rapide : L’installation est directement réalisée avec les paramètres spécifiés par
le fournisseur de l’application.
• Installation personnalisée : L’assistant demande à l’utilisateur les paramètres d’installation
de l’application.

4. Choisissez "Installation personnalisée". L’assistant demande le répertoire d’installation de
l’application.
5. Validez le répertoire d’installation de l’application.

6. Passez à l’étape suivante et terminez l’installation de l’application.
7. L’installation de l’application se lance. Validez les différentes étapes de l’installation.
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. Il est également pos-
sible de réaliser une installation multi-site.
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.

304
ADMINISTRATEUR SERVEUR(S) UTILISATEURS
Poste de Serveur de Postes
RÉSEAU LOCAL
l’administrateur référence1 utilisateurs
réseau
Partie 4 : Application complète avec données

Version de
référence
Demande
d’installation3
Application
Exécutable de WINDEV
l’installation
utilisateur
Base de données
Support Exécution de Exécution de HFSQL Classic
l’installation Centre de contrôle
d’installation des applications l’installation utilisateur (Optionnel)4
(CD,DVD,USB...) réseau (optionnel)2
1 Le serveur de référence peut correspondre à un répertoire partagé.

2 Lors de l’installation, l’administrateur réseau choisit d’installer ou non le Centre de Contrôle des applications réseau.
3 La demande d’installation se fait par le Centre de Contrôle Utilisateur ou le chemin d’installation fourni par l’administrateur réseau.
4 La base de données HFSQL Classic peut être installée ou créée par programmation.
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 de la page suivante présente le mode d’installation d’une application utilisant une
base HFSQL Client/Serveur, avec une mise à jour par Internet.
Remarque : Ce type d’installation peut également être effectué via le PCSCloud (si vous disposez
d’un compte).
Installation multisite
L’installation multi-site est la combinaison de :
• une installation réseau de référence déployée sur un réseau local.
• une installation HTTP utilisée pour la mise à jour de l’installation de référence sur le réseau
local.

306
ADMINISTRATEUR SERVEUR(S) INTERNET UTILISATEURS
Poste de Serveur Postes

l’administrateur HTTP Page de
utilisateurs n
réseau téléchargement
Version de
référence
Demande L’utilisateur
d’installation affiche la page Application
Exécutable de de téléchargement WINDEV
l’installation
utilisateur
Support Exécution de
d’installation l’installation Page de
(CD,DVD,USB...) téléchargement Téléchargement
et installation
de l’application
Partie 4 : Application complète avec données

Serveur HFSQL
Client/Serveur
Serveur Manta
Manta Manager
Le serveur HTTP et le serveur HFSQL Client/Serveur

peuvent être sur une seule et même machine.
Base de données
HFSQL Client/Serveur La base de données HFSQL Client/Serveur peuvent
(Optionnel) être installée ou créée par programmation.
Lors de l’installation, l’administrateur réseau choisit
d’installer ou non le Centre de Contrôle HFSQL.
Centre de Contrôle
La page de téléchargement est accessible par :
HFSQL - Le Centre de Contrôle utilisateur
(Optionnel) - L’adresse fournie par l’administrateur réseau
Leçon 4.15. Diffusez "Etats et Re-
quêtes" avec vos applications
• A quoi sert le logiciel "Etats et Requêtes".

• Comment diffuser le logiciel "Etats et Requêtes".
• Comment utiliser le logiciel "Etats et Requêtes".

Présentation du logiciel "Etats et Requêtes"
Le logiciel "Etats et 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 et 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 et Requêtes" est gratuit et librement redistribuable avec vos

Notes
applications créées avec WINDEV. Consultez la licence pour plus de détails sur
les conditions de redistribution.
Lancement du logiciel "Etats et 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 et Requêtes".
Pour permettre à vos utilisateurs finaux de lancer le logiciel "Etats et Requêtes" :
• soit affichez vos états sous la fenêtre d’aperçu avant impression. Les utilisateurs finaux
pourront lancer le logiciel "Etats et Requêtes" en cliquant sur 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 et Requêtes" avec votre application

Pour diffuser le logiciel "Etats et Requêtes" avec votre propre application WINDEV, il est néces-
saire de :
• indiquer au niveau du projet que l’application autorise le lancement du logiciel "Etats et Re-
quêtes".
• définir si nécessaire au niveau de l’analyse les fichiers et rubriques qui seront utilisables
avec le logiciel "Etats et Requêtes".
• définir les états et les requêtes modifiables sous le logiciel "Etats et Requêtes".
• créer l’exécutable et le programme d’installation intégrant le logiciel "Etats et Requêtes".
Nous allons détailler ces différentes étapes en manipulant le projet "WD Application Complète".
Corrigé

Paramétrage du projet
Pour utiliser le logiciel "Etats et 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 "Ap-
plication 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 "Ap-
plication 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 et 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 et 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 et Requêtes".

A partir du logiciel "Etats et Requêtes", l’utilisateur ne peut pas ajouter, modi-
fier 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 et 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 et 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 et 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 et Requêtes.
• l’option "Tout modifiable (interface et code)" pour que l’état soit entièrement modifiable
sous Etats et 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 et Requêtes".
Pour rendre la requête "REQ_BonDeCommande" présente dans le projet "WD Application
Complète" modifiable sous le logiciel "Etats & Requêtes" :
1. Ouvrez la requête "REQ_BonDeCommande" 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é" (présent parmi les "Actions").
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 et Requêtes" se fait de la
même façon que pour une application classique. Vous pourrez indiquer les paramètres spéci-
fiques au logiciel "Etats et Requêtes" lors de la création de la procédure d’installation.
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 et éditer l’aide". La création de l’exécutable est réalisée.
Notes
Si l’assistant propose la création du fichier d’aide, validez les différents mes-
sages.
3. L’assistant de création d’installation se lance.

4. Choisissez une "Installation individuelle". Passez à l’étape suivante.
5. Choisissez une "Installation standard". Passez à l’étape suivante.
6. Validez le répertoire d’installation proposé et passez à l’étape suivante.
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.
8. Cliquez à gauche sur le lien "Compléments".

9. Dans l’écran "Modules complémentaires", vérifiez que l’option "Intégrer l’installation de
Etats et Requêtes" est cochée.
10. Dans l’écran intitulé "Etats et Requêtes" :
• Spécifiez si vous voulez incorporer l’installation de "Etats et Requêtes" dans votre pro-
gramme d’installation.
Dans ce cas, le package d’installation du logiciel "Etats et Requêtes" (présent dans le
sous-répertoire "Etats et Requêtes" du répertoire d’installation de WINDEV) sera utilisé.
Il est possible de :
• Proposer l’installation du logiciel "Etats et Requêtes" en même temps que l’application.
• Proposer l’installation du logiciel "Etats et Requêtes" lors de sa première utilisation.
Attention : Incorporer le logiciel "Etats et Requêtes" augmente la taille de votre installation
de façon non négligeable (environ 270 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".
11. Cliquez sur l’option "Support" à gauche de l’assistant.
12. 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 et Requêtes"
Installation de l’application
Pour tester l’installation et l’utilisation du logiciel "Etats et 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. Deux modes d’installation sont disponibles :
• Installation rapide : L’installation est directement réalisée avec les paramètres spécifiés par
le fournisseur de l’application.
• Installation personnalisée : L’assistant demande à l’utilisateur les paramètres d’installation
de l’application.
4. Choisissez "Installation personnalisée". L’assistant demande le répertoire d’installation de
l’application.
5. Validez le répertoire d’installation de l’application.
6. L’écran "Etats et Requêtes" permet d’installer le logiciel "Etats et Requêtes" (uniquement si
ce programme n’est pas déjà installé sur le poste en cours).

8. L’écran suivant permet de définir les répertoires utilisés pour l’enregistrement des états et
des requêtes (si l’option "Autoriser la modification de ces répertoires lors de l’installation" a
été cochée dans l’assistant de création du programme d’installation).
9. Passez à l’étape suivante et terminez l’installation de l’application.

10. L’installation de l’application, puis l’installation du logiciel "Etats et Requêtes" se lancent.

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 est affiché dans l’aperçu avant im-
pression. Cliquez sur le volet "Aperçu".
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 et 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 et 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 4.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.

1. Affichez la description du projet : sous le volet "Projet", dans le groupe "Projet", cliquez sur
"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.
Remarque : Les libellés existant dans la langue de base du projet sont automatiquement
recopiés dans la ou les langues ajoutées.
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.

Note Pour prendre en compte toutes les langues du projet lié à l’analyse en cours, il
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. 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. Dans le menu contextuel qui s’affiche, sélectionnez "Multi-langues".

6. 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.
7. Pour notre exemple, dans la zone "Anglais", sélectionnez le fichier "header-us.png" :

• Cliquez sur l’icône .
• Sélectionnez l’option "Parcourir".
• Sélectionnez le fichier voulu.
8. Validez. Le libellé "<Valeurs multi-langues>" apparaît désormais dans la zone "Image" de la
fenêtre de description.

10. Enregistrez le modèle de fenêtres ( ou CTRL S).
11. 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.
12. 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. Double-cliquez sur le champ Onglet pour afficher sa fenêtre de description.
2. Dans l’onglet "Général" de la fenêtre de description, sélectionnez le premier onglet "Liste
des produits".
3. Dans la partie "Description d’un volet statique", il est possible de :
• saisir la traduction du libellé du volet : "List of products".
• définir une image spécifique pour le volet d’onglet par langue (comme nous l’avons fait pré-
cédemment).
• définir une bulle d’aide par langue.
4. 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" et validez.
7. Repassez la langue affichée en français : sous le volet "Affichage", dans le groupe "Options",
déroulez "Langue affichée" et sélectionnez "Français".

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 Trad (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 :
"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 [ENTREE] deux fois et saisissez le libellé de la seconde option "An-
glais".
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 4.17. GDS
• Présentation
• Le gestionnaire de sources
• Utilisation du gestionnaire de sources

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 propose en standard un gestionnaire de sources nommé "GDS" permettant de parta-
ger les sources de différents projets entre développeurs et de connaître l’historique complet des
modifications 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.
COPIE LOCALE
Serveur GDS
Projet Développeur
local Réseau local
COPIE LOCALE
Projet de Projet Développeur

local ADSL (Internet)
référence
COPIE LOCALE
Projet Développeur
local Déconnecté
• 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 dans 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.
Serveur GDS Développeur

1 EXTRACTION
Réseau local
D’UN ÉLÉMENT
Projet
local
Projet de 3 RÉINTÉGRATION 2 MODIFICATION
référence
Développeur
SYNCHRONISATION ADSL (Internet)
4
SY
Projet
N
4 local
CH
RO
N
IS
Développeur
AT
IO
Déconnecté
N
Projet
local
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.
• quand vous le souhaitez, directement depuis WINDEV ou depuis l’administrateur du GDS.
La base de sources peut être installée en mode :
• HFSQL Classic,
• HFSQL Client/Serveur,
• PCSCloud. Le mode PCSCloud permet d’avoir accès aux sources des projets depuis n’im-
porte où, n’importe quand. Ce mode correspond à un Cloud privé et propose de nombreuses
options (plateforme dédiée, utilisation des Centres de Contrôle, ...). Pour plus de détails,
consultez le site www.pcscloud.net
• GDS Drive. Le mode GDS Drive permet d’avoir accès aux sources des projets présents dans
le GDS depuis n’importe où, n’importe quand. Pour plus de détails, consultez le site www.
pcscloud.net

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 du

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

• sous le volet "Administration", dans le groupe "Sauvegardes", sélectionner l’op-
tion "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 "Ajouter le projet", cliquez sur "Ajouter le projet dans le
GDS". 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. Sélectionnez l’option "Création d’une base en mode partage réseau" et indiquez le réper-
toire 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’étape suivante.

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’étape suivante.
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’étape sui-
vante.

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 et les modifications sont automatiquement reportées
dans les autres projets.
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 les paramètres de localisation de la base de sources et valider (cette étape est
nécessaire uniquement 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 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", cochez si nécessaire l’option "Extraction des éléments à la
première modification".
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 :
1. Affichez la description du projet : sous le volet "Projet", dans le groupe "Projet", cliquez sur
"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. L’option "Réintégrer automatiquement le projet à la fin de l’opération" permet de réintégrer

automatiquement le projet à la fin de sa modification. Conservez cette option.
3. Validez cette fenêtre.
4. WINDEV propose de recompiler le projet. Acceptez la recompilation complète du projet.
5. La fenêtre de description du projet se ferme et le projet est automatiquement réintégré
dans la base de sources.

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").
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.
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.
2. L’extraction automatique est activée à la première modification : il suffit de déplacer un

champ pour extraire l’élément. Il est également possible d’utiliser l’icône "Extraire" présente
dans le ruban ( ).

3. La fenêtre d’extraction apparaît :
4. 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.
5. Nous allons extraire la fenêtre en mode exclusif. Conservez l’option "Exclusif" cochée.
6. Saisissez un commentaire ("Modification de l’image" par exemple). Ce commentaire sera
utile pour les autres développeurs.
7. Validez l’extraction. La fenêtre est extraite.
8. Affichez la fenêtre de description du champ Image (option "Description" du menu contex-
tuel).
9. Dans l’onglet "IHM", modifiez le curseur utilisé : sélectionnez le curseur "Main système".
11. Affichez le code du champ Image : sélectionnez le champ Image et utilisez par exemple la
touche [F2].
12. 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)

14. 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.
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.
• 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 375.

PARTIE 5
Administrer
une base HFSQL
Client/Serveur
348 Partie 5 : Administrer une base HFSQL Client/Serveur
Leçon 5.1. Introduction
• Principe du Client/Serveur
• Pourquoi passer une application en HFSQL Client/Serveur ?
Partie 5 : Administrer une base HFSQL Client/Serveur 349

Présentation
WINDEV permet de créer des applications accédant à des bases de données HFSQL Client/Ser-
veur.
Une base de données en mode Client/Serveur permet de déporter la ou les bases de données sur
un poste serveur.
Ce mode de fonctionnement :
• accroît la sécurité de vos données,
• permet de gérer très facilement le mode multi-utilisateurs,
• facilite la maintenance, ...
Poste Client 1
Application WINDEV
Poste Client 2 Serveur HFSQL

Windows ou Linux
Serveur Manta
Application WINDEV
Bases de données
Poste Client n HFSQL
Client/Serveur
Application WINDEV
WINDEV permet de :

• créer entièrement une application utilisant une base de données HFSQL Client/Serveur.
• modifier une application utilisant une base de données HFSQL Classic pour qu’elle utilise une
base de données 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 via une connexion Inter-
net.
• Une gestion du mode multi-utilisateur native : les performances en mode multi-utilisateur sont
optimisées.

Leçon 5.2. Mise en place d’une
base de données Client/Serveur
• Installation d’un serveur HFSQL local

• Création d’une application utilisant une base de données HFSQL Client/Serveur
• Adaptation d’une application pour gérer une base de données HFSQL 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 utilisant une base de données HFSQL Client/Serveur.
Installation d’un serveur HFSQL local

La première opération à faire avant de commencer à développer 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 DVD de WINDEV. Si vous ne
possédez pas ce DVD, 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 ou mettre à jour un serveur HFSQL Client/Serveur".
4. Acceptez la licence.
5. Choisissez la plateforme (option "Pour Windows sur cette machine").
6. Si des serveurs HFSQL sont déjà installés sur le poste en cours, Choisissez l’option "Instal-
ler 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.
Notes
Pensez à ouvrir ce port sur le firewall pour se connecter au serveur HFSQL

depuis une autre machine.
8. Installez 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.
9. L’assistant propose de paramétrer l’envoi de notifications afin de connaître les dysfonction-

nements du serveur en temps réel. Pour notre exemple, passez à l’étape suivante et indiquez
que le paramétrage sera effectué "Plus tard".
10. Validez (ou non) la participation à l’amélioration du produit installé en autorisant la col-
lecte d’informations relatives à l’utilisation du produit. Cette collecte, facultative et anonyme,
permet à PC SOFT d’améliorer les fonctionnalités du produit.
11. 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.

Notes
Pour des raisons évidentes de sécurité, pensez à changer le mot de passe de
l’administrateur.
Création d’une application utilisant une base de données

HFSQL Client/Serveur
La création d’une application WINDEV utilisant une base de données HFSQL Client/Serveur se fait
très simplement. 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.
Notes
Vous pouvez aussi décrire la connexion au serveur HFSQL par programmation.

Pour plus de détails, consultez l’aide en ligne : “HDécritConnexion”.
Adaptation d’une application pour utiliser une base de

données HFSQL Client/Serveur
Présentation
Le passage d’une base de données HFSQL Classic en mode Client/Serveur est l’opération la plus
courante.
WINDEV propose plusieurs solutions pour réaliser ce passage :
• réaliser cette adaptation dans l’éditeur d’analyses.
• réaliser cette adaptation depuis le Centre de Contrôle HFSQL.
Pour mieux se rendre compte des différentes étapes, nous allons passer en mode Client/Ser-
veur l’application que nous avons réalisée dans la partie 3 de ce livre, en utilisant la première
méthode, l’éditeur d’analyses.
Adaptation de l’exemple
Corrigé

Pour adapter le projet :
2. Dans l’explorateur de projet, sélectionnez si nécessaire, la configuration de projet "Exécu-
table Windows 32 bits".
3. Chargez l’analyse de votre projet sous l’éditeur d’analyses : cliquez sur parmi les bou-
tons d’accès rapide. L’éditeur d’analyses s’affiche.
4. Sous le volet "Analyse", dans le groupe "Connexion", cliquez sur "Nouvelle connexion". Un
assistant s’ouvre, permettant de créer une connexion.
5. Sélectionnez le type de connexion à créer : "HFSQL Client/Serveur".

7. Indiquez dans les étapes suivantes :
• le nom du serveur (nom de votre machine par exemple) et le numéro de port. Passez à
• le nom de l’utilisateur et son mot de passe (laissez ces informations vides pour utiliser l’ad-
ministrateur). Passez à l’étape suivante.
• le nom de la base de données ("WD Application Complète" dans notre exemple). Passez à
8. Saisissez le nom de la connexion (conservez le nom proposé).

9. Passez à l’étape suivante 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.
10. Cliquez sur "Oui".

11. Dans l’étape suivante, sélectionnez tous les fichiers proposés :

12. L’assistant propose ensuite de copier les fichiers de données sur le serveur. Validez (op-
tion "Copier maintenant").
13. 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.

14. Passez à l’étape suivante et validez.
15. 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.
16. 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, ... 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.
17. Vous avez adapté le projet de développement. Il peut être également nécessaire d’adapter
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 5.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/adapter une application pour qu’elle fonctionne 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.
Nous allons tout d’abord lancer le Centre de Contrôle HFSQL depuis le projet WINDEV.
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. Ce mode de lancement permet de

voir les différents fichiers liés à l’analyse du projet en cours.

4. Cliquez si nécessaire sur l’onglet vertical "HFSQL C/S". La liste des fichiers de données au
format HFSQL Client/Serveur s’affiche.
Le Centre de Contrôle liste ici les fichiers de données Client/Serveur trouvés dans l’analyse
liée au projet en cours. Aucune connexion n’est réalisée : les fichiers apparaissent grisés.
5. Pour visualiser les données des fichiers, double-cliquez sur un des fichiers de données
dans la liste à gauche (par exemple "Commande"). Si le Centre de Contrôle HFSQL ne connaît
pas tous les paramètres de la connexion, une fenêtre de connexion permet de réaliser la
connexion effective au serveur HFSQL Client/Serveur utilisé. Si cette fenêtre s’affiche, indi-
quez le mot de passe et validez.
6. Les différentes informations sur le fichier de données sélectionné et utilisant cette
connexion sont affichées dans un nouvel onglet :
• L’onglet "Description" présente les informations sur les fichiers de données (rubriques du fi-
chier, ...).
• L’onglet "Contenu" affiche les enregistrements contenus dans les fichiers de données.

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.
Pour se connecter directement à la base de données présente sur le serveur :
1. Déroulez le menu situé en haut à gauche du Centre de Contrôle HFSQL et sélection-
nez l’option "Se connecter à un serveur HFSQL".
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 puis validez.
4. Les caractéristiques du serveur HFSQL sont affichées :
• dans le panneau de gauche, le nom du serveur HFSQL ainsi que la liste des bases présentes
sur ce serveur apparaissent.
• dans la partie droite de l’écran, un nouvel onglet est affiché permettant de voir les caracté-
ristiques du serveur HFSQL.

5. Dans la partie droite de l’écran, sélectionnez l’onglet "Utilisateurs". Cet onglet permet de
gérer les utilisateurs du serveur.
6. Pour le moment, seul l’utilisateur "Admin" est présent.
7. Pour créer un nouvel utilisateur, dans le ruban, dans le groupe "Utilisateurs", cliquez sur le
bouton "Nouveau". 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 uni-
quement pour un nombre de jours donnés. (paramétrable).
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, double-cliquez sur la base de données "WD Application
Complète".
2. Sous le volet "WD Application Complète", dans le groupe "Droits", cliquez sur "Gestion des
droits".
3. Sélectionnez l’utilisateur "Test" dans la liste des utilisateurs.
4. Dans la liste des droits, pour l’action "Droit de se connecter au serveur (connexion cryptée
et non cryptée)", cliquez dans la colonne "Droit défini" et sélectionnez la coche verte.
5. Cliquez sur le bouton "Appliquer" présent à droite de la liste des droits. Le droit devient ef-
fectif.
6. Fermez la fenêtre de gestion des droits.

Pour donner le droit de lire le fichier Client :
1. Dans le Centre de Contrôle HFSQL, déroulez la base de données "WD Application Complète",
puis double-cliquez sur le fichier Client (à gauche de l’écran).
2. Sous le volet "Client", dans le groupe "Droits", cliquez sur "Gestion des droits".
3. Sélectionnez l’utilisateur "Test" dans la liste des utilisateurs.
4. Dans la liste des droits, pour l’action "Droit de lire les enregistrements d’un fichier", cliquez
dans la colonne "Droit défini" et sélectionnez la coche verte.
5. Cliquez sur le bouton "Appliquer" présent en bas de la fenêtre (Flèche bleue). Le droit de-
vient effectif.
6. Fermez la fenêtre de gestion des droits.
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
Pour sauvegarder la base de données :
1. Positionnez-vous sur l’onglet correspondant à la base "WD Application Complète".
2. Sélectionnez l’onglet vertical "Sauvegardes".
3. Dans le menu, dans le groupe "Sauvegardes", déroulez "Nouvelle sauvegarde" et sélection-
nez "Nouvelle sauvegarde à chaud".
Remarque : Ce bouton est accessible dans le groupe "Sauvegardes" :
• sur l’onglet correspondant au serveur HFSQL,
• sur l’onglet correspondant à la base de données.
Remarque : L’assistant permet également de réaliser une sauvegarde d’une sélection de fichiers.
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 5.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’étape "Paramètres des bases de données". Dans cette étape, il est possible
de :
• Intégrer l’installation d’un serveur HFSQL,
• Configurer l’emplacement des fichiers de données de l’application,
• Déployer les fichiers HFSQL Client/Serveur.
Si ces options sont cochées, les étapes suivantes 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 6
Optimiser et
déboguer
un projet
372 Partie 6 : Optimiser et déboguer un projet
• Pourquoi optimiser une application

• Projet exemple
Partie 6 : Optimiser et déboguer un projet 373

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 pro-
pose 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 23 (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 6.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.
Deux types d’audits sont disponibles :

• 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 sources d’un
projet pour détecter différents problèmes et proposer des améliorations.
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 :
• activer le Widget si nécessaire (cliquez sur le lien "Cliquez ici pour réactiver").
• cliquer sur la flèche.
Notes

2. L’assistant se lance. Nous allons définir la cible de l’audit statique.
3. Sélectionnez l’option "Lancer l’audit statique sur le projet complet".

5. Le rapport d’audit est affiché :
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.
Examinons avec attention les points présentés par ce rapport.

Procédure non exécutée
Dans notre projet, l’audit nous indique qu’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 utile"). Dans
ce cas, la procédure ne sera plus prise en compte lors de l’audit.
• supprimer la procédure si elle est réellement inutilisée (bouton "Supprimer").
• voir la procédure (bouton "Voir").
• rechercher les cas d’utilisation dans les chaînes par exemple (bouton "Rechercher").
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
L’audit nous indique que 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 orphe-
lins 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 utile"). 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.
• supprimer l’élément s’il est réellement inutilisé (bouton "Supprimer").
• voir l’élément (bouton "Voir").
• rechercher les cas d’utilisation dans les chaînes par exemple (bouton "Rechercher").
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.

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. L’exécutable et l’installation client ne sont pas alourdis
avec des images, fichiers externes, ... non utilisés
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’étape suivante.
6. Terminez l’assistant.
Nous avons optimisé notre projet en suivant tous les conseils de l’audit statique.
L’audit statique permet d’avoir un état général sur les sources de votre projet. Notre conseil : lan-
cez-le régulièrement !
Maintenant, voyons ce qui se passe en exécution en lançant l’audit dynamique.
Audit dynamique
L’audit dynamique permet d’analyser l’exécution de l’application. 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,
• ...
Un audit dynamique peut être effectué dans un environnement de test ou sur une application en
production.
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 la flèche 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 :
2. Cliquez sur le bouton "Fenêtre de test de l’audit dynamique".

3. 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é. Pour
l’option "Assertion et Exception", une assertion est affichée : cliquez "Continuer" pour voir ap-
paraître le message sous forme de toast.
4. Arrêtez le test de l’application.
5. 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ème 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 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 6.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 des traitements 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 sauve-
garde les temps d’exécution de chacun des traitements 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,
• la durée et le nombre d’appels de tous les traitements exécutés.
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 sélectionner "Analyser les performances".
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(“www.google.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 6.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 ou utilisez
le raccourci [CTRL] + B, 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ébogueur 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. Appuyez 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, apparaît le volet "Débogueur". 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 trai-
tement de clic sur le bouton BTN_TraitementLong.
• la liste des expressions à évaluer. Par défaut, dans cette zone les principales variables utilisées
dans le code sont affichées. 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 MetAJourStock-
Produits 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 InterrogeBaseFour-

nisseur sans le dérouler pas à pas sous le débogueur.
2. Cliquez avec la souris sur la ligne suivante (attention : cliquez dans la ligne et non devant
la ligne) :
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 de code où le
curseur est positionné. Les lignes de code présentes jusqu’au curseur 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". Cliquez une
seconde fois sur l’expression : la colonne "Expression" passe en édition. Dans la zone "Expres-
sion", ajoutez "=50". Vous obtenez "JAUGE_Progression = 50".
7. Appuyez sur la touche [F5]. L’exécution du programme continue. Le débogueur est à nou-
veau lancé lorsque la jauge a pour valeur 50.
Voilà, 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 7
Programmation
avancée
398 Partie 7 : Programmation avancée
• Présentation
• Comment ouvrir un exemple didactique
• Comment ouvrir un exemple unitaire
Partie 7 : Programmation avancée 399

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, didactique ou unitaire depuis la fenêtre de bienvenue :
1. Affichez la fenêtre de bienvenue (CTRL + <).
2. Dans la fenêtre de bienvenue, cliquez sur "Ouvrir un exemple". La liste des exemples com-
plets, didactiques et unitaires fournis avec WINDEV apparaît. Ces exemples sont regroupés
par type d’exemple (complet, didactiques, ...).
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 exemple, il suffit de cliquer sur le lien présent dans la fenêtre.
5. Pour les exemples complets et didactiques, le projet en cours est automatiquement fermé
puis le projet exemple est ouvert.
6. Pour les exemples unitaires, la fenêtre associée est ouverte dans le projet en cours.

Leçon 7.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 défaut 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, didactiques et unitaires 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ébogage 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 "WD Detection erreurs HFSQL" (exemple di-
dactique), livré en standard avec WINDEV. Cet exemple est accessible depuis la
fenêtre de bienvenue de WINDEV.

Leçon 7.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 WLan-
gage permettent de créer, lire ... des fichiers externes. Toutes les fonctions peuvent être très faci-
lement 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 unitaire "Manipulation de fichiers texte".

Testez la fenêtre "FEN_Fichier_Texte". Cette fenêtre regroupe de nombreuses manipulations
possibles sur les fichiers externes avec WINDEV.

Les différents boutons de la fenêtre 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 unitaire "Manipulation des répertoires" et testez la fenêtre

correspondante.
Cette fenêtre 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 et 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 un langage de bali-
sage, c’est-à-dire un langage qui présente de l’information encadrée par des balises. XML est un
métalangage 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*).
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".

Testez la fenêtre "FEN_ManipulationXML". 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 "Les fonctions Excel".
Testez la fenêtre "FEN_FonctionXLS". 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 unitaire "Type xls".
Testez la fenêtre "FEN_Type_xls".
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 7.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 unitaire "Compi-
lation dynamique".
La fenêtre "Compilation dynamique" montre comment compiler dynamiquement du code WLan-
gage (stocké sous forme de chaîne), exécuter la procédure générée dynamiquement et traiter les
éventuelles erreurs d’exécution.
Pour tester cette fenêtre :
1. Ouvrez l’exemple unitaire "Compilation dynamique".
2. Lancez le test de la fenêtre "FEN_COMPILATION_DYNAMIQUE".
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 appelé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éap-
paraît sous l’éditeur de code. Dans la suite de ce code, vous pouvez voir que la fonction com-
pilée dynamiquement est exécutée grâce à la fonction Exécute.

Leçon 7.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 "La
fonction Evénement".
Ouvrez l’exemple unitaire "La 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. Cliquez sur le lien "Ajouter d’autres traitements ..." :
3. La liste complète des traitements optionnels disponibles s’affiche :
4. 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 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 :
EXTERNE “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 7.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.
• 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
WINDEV est livré en standard avec plusieurs exemples unitaires permettant de

Exemple
comprendre l’intérêt et l’utilisation des threads :

• Les threads (Pool),
• Les threads.
Pour plus de détails sur la gestion des threads avec WINDEV, consultez l’aide en ligne (mot-clé :
"Thread").

Leçon 7.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.
Un 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 de 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 un socket.
• Application WINDEV, WEBDEV ou WINDEV Mobile "Serveur" : l’application WINDEV (ou WEB-
DEV ou WINDEV Mobile) est un serveur, échangeant des informations par sockets avec plu-
sieurs postes client quelconques. Pour gérer plusieurs connexions simultanées, il est néces-
saire d’utiliser des threads.
Exemple
WINDEV est livré en standard avec un exemple didactique permettant de com-

prendre l’utilisation des sockets : "WD Utilisation des sockets". Cet exemple est
accessible depuis la fenêtre de bienvenue de WINDEV (CTRL <).
Application Serveur : cas d’un serveur simplifié

WINDEV offre la possibilité de créer un serveur de sockets simplifié. Ce serveur permet de com-
muniquer 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 du socket.
2. Echange de données.
3. Fermeture du socket.
Création du socket
Pour créer le socket, le poste serveur utilise la fonction SocketCrée. Un socket est associé à un
port spécifique. Pour simplifier la manipulation du socket par programmation sur le poste serveur,
précisez le nom du socket.
Le poste client va venir se connecter sur ce 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 le 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
le 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 le 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 le socket : il envoie une requête au poste serveur.
2. Le poste serveur effectue une lecture sur le 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 du socket
Pour terminer la communication, le serveur peut fermer le socket avec la fonction SocketFerme.
Remarque : le socket peut aussi être fermé 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’un 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 à un socket du serveur, il suffit d’utiliser la fonction SocketConnecte. Cette
fonction permet d’effectuer une demande de connexion au serveur.
Le socket est identifié par son port et par son adresse.
Echange de données
Lorsque deux postes utilisent le 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
le 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 le socket, l’application cliente WINDEV doit utiliser les fonctions SocketLit et
SocketEcrit.
Fin de communication
Pour terminer la communication, il suffit de fermer le 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 le socket en cliquant sur le bouton "Créer".
2. Le poste B peut alors se connecter au socket créé 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és.

Nous allons tout d’abord étudier les traitements réalisés par le serveur de sockets (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 le
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 IP N° “+...
SocketClientInfo(“PosteA”, SocketAdresse))
FIN
Nous retrouvons la fonction SocketLit qui permet de lire le socket précédemment créé. 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 au socket créé 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 le socket
auquel 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 7.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 manipulation des fichiers sur un serveur
FTP grâce à l’exemple unitaire "Les fonctions FTP".
Ouvrez l’exemple unitaire "Les fonctions FTP". Cet exemple présente les principales fonction-
nalité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 = SAI_Serveur_FTP
// 2 - Nom d’utilisateur : si ce nom n’est pas indiqué,
// une connexion de type “anonyme” sera utilisée
sNomUtilisateur est une chaîne = SAI_Utilisateur
sMDPUtilisateur est une chaîne = SAI_Mot_de_passe

// 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 7.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 permet à ses objets d’accéder à toutes les méthodes, à tous les membres et à
toutes les propriétés de ses classes ancêtres; tout se passe comme si les méthodes, les membres
et les propriétés des classes ancêtres faisaient partie de la classe dérivée.

Constructeur et Destructeur
Les notions de Constructeur et Destructeur sont importantes puisqu’elles permettent un appel
automatique 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 "WD POO Simple".
1. Ouvrez l’exemple didactique "WD 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 (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
"Créer une classe vierge".
3. Dans la fenêtre qui s’affiche, indiquez le nom de la classe (par exemple TestGAF) et validez.
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_sNomChampImagePourDessin" 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 classes 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 "WD 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. La fenêtre de création d’un nouvel élément s’affiche : cliquez sur "Architec-
ture" puis 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").

PARTIE 8
Annexes
442 Partie 8 : Annexes
Annexe 1. Vocabulaire
• Les termes utilisés par WINDEV, WEBDEV et WINDEV Mobile
Partie 8 : Annexes 443

Principaux termes utilisés
Accès natif (connecteur)

Méthode de connexion à une base de données depuis un programme.
Affectation
Opération qui consiste à mettre une valeur dans une variable ou dans un champ. Par exemple :
// Affectation de la valeur DUPONT dans la variable Nomclient
Nomclient = "DUPONT"
Le signe = est l’opérateur d’affectation.
Alignement
Façon d’organiser les champs d’une fenêtre ou d’une page. Par exemple, centrer un champ dans
une fenêtre, mettre plusieurs champs à la même largeur, ...
Analyse
Description de la structure des fichiers de données (ou tables) et de leurs relations.
Ancrage
Mécanisme qui consiste à définir des règles de position ou de redimensionnement pour que le
contenu d’une fenêtre ou d’une page s’adapte au redimensionnement d’une fenêtre ou d’un navi-
gateur.
Base de données
Elément contenant les données d’un programme. Les données sont organisées en fichiers ou
tables.
Bloc d’un état

Elément constituant un état. Par exemple, un bloc Haut de page, un bloc Bas de page, un bloc
Corps.
Champ (fenêtre ou page)

Elément graphique servant à la constitution de l’IHM d’un programme ou d’un site.
Classe
Elément défini en Programmation Orientée Objet (POO). Une classe rassemble des méthodes (ac-
tions) et des membres (données).
Classic
Type d’accès à un fichier HFSQL. Un fichier HFSQL est de type Classic lorsque l’on accède à celui-
ci directement dans son répertoire.

Clé
Caractéristique d’une rubrique de fichier. Une rubrique clé permet d’optimiser les recherches et
les tris dans un fichier de données.
Synonyme : index
Client/Serveur
Type d’accès à un fichier HFSQL. Un fichier HFSQL est de type Client/Serveur lorsque l’on accède
à celui-ci en se connectant à un serveur contenant ce fichier via le moteur HFSQL.
Code du projet
Code exécuté lors du lancement d’un programme ou d’un site.
Composant Externe
Brique logicielle qui permet d’exporter une ou plusieurs fonctions métier à des fins de réutilisabi-
lité.
Composant Interne
Conteneur regroupant des éléments d’un projet (fenêtre, page, requête, état, classe,...) afin de
permettre et de faciliter un partage avec un autre projet.
Configuration de projet
Description du format de sortie d’un projet : exécutable Windows, Linux, JAVA, ...
Contrainte d’intégrité
Règle à respecter associée à une rubrique de fichier afin d’assurer la cohérence des données
dans une base de données.
Data binding
Méthode qui permet d’associer un élément graphique de l’IHM à une donnée contenue dans une
variable, une rubrique ou un tableau, ...
Déploiement
Action d’installer un programme sur le poste d’un utilisateur ou sur un serveur.
Editeur
Programme qui permet de créer un élément d’un projet (éditeur de fenêtres, éditeur d’états,..).
Etat
Elément d’un projet qui définit une impression à réaliser.
FAA
Abréviation de Fonctions Automatiques de l’Application.

Feuille de styles
Contient la liste des styles utilisés dans un projet.
Fichier
Elément constituant une base de données. Un fichier sert à stocker des données saisies dans un
programme.
Par exemple, un fichier CLIENT va contenir les informations des clients qui ont été saisies dans un
programme.
Synonyme : Table
GDS
Abréviation de Gestionnaire De Sources. Outil pour organiser, partager des sources des projets,
gérer les droits, ...
Global(e) (variable ou procédure)

Correspond à la portée en mémoire d’une variable ou d’une procédure. Un élément global est
accessible depuis n’importe quel autre élément du projet. L’inverse est local.
Groupware utilisateur
Outil de description des droits d’accès à l’IHM pour les utilisateurs d’un programme ou d’un site.
Par exemple, empêcher un utilisateur de pouvoir cliquer sur un bouton "Supprimer" en fonction de
son login ou de son groupe.
Homothétique
Méthode de redimensionnement d’une image afin de l’afficher au plus grand sans déformer son
contenu.
IHM
Abréviation de Interface Homme Machine. Description des fenêtres ou des pages qui constituent
un programme. C’est ce que voit l’utilisateur lors de l’utilisation du programme.
Index (fichier)
Synonyme : clé
Liaison dans une analyse

Décrit la nature de la relation ou le point commun entre 2 fichiers de l’analyse. D’une liaison dé-
coule la description des règles d’intégrité à respecter lors de l’écriture dans les fichiers concernés.
Synonyme : Relation
Live Data
Mécanisme qui consiste à afficher des données réelles provenant de la base de données durant
la création de l’IHM. Ce mécanisme n’est utilisé qui si l’élément est lié au fichier de données.

Local
Correspond à la portée en mémoire d’une variable ou d’une procédure. Un élément local n’est
accessible que dans le traitement dans lequel il a été défini. L’inverse est global.
Membre
Variable faisant partie d’une classe.
Menu contextuel
Menu déroulant contenant des actions possibles dépendant de l’endroit où s’est effectué le clic
droit de la souris et du type de l’élément sur lequel ce clic droit a été effectué.
Méthode
Procédure faisant partie d’une classe permettant d’agir sur les données (membres) de la classe.
Modèle de champs
Conteneur d’un ou plusieurs champs (avec traitements) qui peut être réutilisé indéfiniment dans
des fenêtres ou des pages.
Modèle de fenêtres
Conteneur représentant une fenêtre type qui peut être appliqué à une fenêtre ou plusieurs fe-
nêtres d’un projet.
Modèle d’états
Conteneur représentant un état type qui peut être appliqué à un état ou plusieurs états d’un pro-
jet.
n-tiers
Méthode de programmation en couches. Chaque couche est indépendante et peut être changée
sans impact sur les autres.
Paramètre (fenêtre, page, état, procédure, méthode)

Elément attendu dans une fenêtre, une page, un état, une procédure ou une méthode lors de
l’appel de celle-ci. Chaque valeur passée en paramètre doit être affectée dans une variable.
POO
Abréviation de Programmation Orientée Objet.
Popup
Type de fenêtre (ou page). Une popup est une fenêtre (ou page) qui se superpose à une fenêtre
(ou page). Il est ainsi possible de continuer à visualiser le contenu de la fenêtre (ou page) de des-
sous tout en continuant à saisir dans la popup.
Privé(e)
Variable ou procédure utilisable uniquement dans l’élément en cours.

Procédure
Elément d’un projet contenant le code d’un traitement à exécuter.
Programmation événementielle
Type de programmation. Une action d’un utilisateur sur une fenêtre ou une page induit un code
à exécuter. Le code de l’action à exécuter est saisi dans l’événement représentant l’action de
l’utilisateur.
Par exemple, l’événement de "Clic d’un bouton" correspond à un clic avec la souris d’un utilisateur
sur ce bouton.
Programmation Orientée Objet (POO)

Méthode de programmation avancée, par opposition à la programmation procédurale.
En POO, on manipule uniquement des objets, c’est-à-dire des ensembles groupés de variables
et de méthodes associées à des entités intégrant naturellement ces variables et ces méthodes.
Programmation procédurale
Type de programmation. En programmation procédurale, on définit des fonctions s’appelant mu-
tuellement. Chaque fonction ou procédure est associée à un traitement particulier qui peut être
décomposé en sous-traitements jusqu’à obtenir des fonctions basiques.
Projet
Elément regroupant tous les éléments constituant un programme ou un site. Un projet contient
par exemple, une analyse, des pages, des états, des requêtes, ...
Propriété (champ, fenêtre, ...)

Mot-clé représentant une caractéristique d’un élément. Les propriétés permettent de manipuler
et modifier les caractéristiques des éléments d’un projet par programmation.
Public(que)
Variable ou procédure utilisable depuis tous les éléments.
RAD
Abréviation de Rapid Application Development
Méthode de développement rapide d’un programme à partir d’une analyse (description des fi-
chiers de données).
RAD Applicatif
Méthode de développement rapide d’un programme à partir d’un modèle de programme.
Requête
Elément écrit en langage SQL qui permet d’accéder en lecture ou écriture au contenu d’une base
de données relationnelle.

Rubrique
Elément faisant partie de la structure d’un fichier de données ou d’une table (d’une analyse). Par
exemple, un fichier CLIENT peut être composé des rubriques Nom et Prénom.
Rupture (Etat, Zone répétée, Table)

Mécanisme qui consiste à regrouper et séparer des données suivant une valeur.
Par exemple, faire une rupture dans un état qui liste des clients par ville. On regroupe donc les
clients de la même ville ensemble. Visuellement, on sépare les clients à chaque changement de
ville.
Structure
Type de variable qui est composée de plusieurs sous-variables.
Style
Elément qui permet de décrire l’aspect graphique d’un champ dans une fenêtre, dans une page
ou dans un état. Un style est constitué par exemple, d’un type de police de caractères, de la taille
des caractères, de la couleur des caractères, etc.
Table (fichier)
Elément constituant une base de données. Une table sert à stocker des données saisies dans un
programme. Par exemple, une table CLIENT va contenir les noms et les adresses des clients qui
ont été saisis dans un programme.
Table (champ)
Elément graphique présent dans une fenêtre ou une page. Un champ table est constitué d’une ou
plusieurs colonnes ainsi que de plusieurs lignes.
Tableau
Type de variable qui contient plusieurs valeurs. Les valeurs sont accessibles au travers d’un in-
dice. Les [ ] permettent depuis le langage d’accéder aux éléments d’un tableau.
Variable
Elément qui permet de stocker en mémoire une valeur du programme. Il existe plusieurs types de
variables. Chaque type correspond à la nature de la valeur que l’on veut mémoriser. Par exemple,
une variable de type chaîne pour stocker le nom d’une personne, une variable de type monétaire
pour stocker un montant.
Webservice
Programme installé sur un serveur Web dont les traitements sont accessibles par le Web.
XML
Langage pour organiser des données afin de normaliser et faciliter l’échange de ces données (uti-
lisé notamment dans les échanges avec les Webservices).

Annexe 2. Utiliser des données SQL
• Création d’un projet

• Création d’une analyse

Présentation
Cette leçon va vous permettre de découvrir comment manipuler des bases de données SQL avec
WINDEV.
Cette leçon est destinée aux personnes maîtrisant les bases de données SQL.
Notes
Toutes les manipulations à faire sur la base de données SQL ne seront pas dé-
taillées.
Pour créer une application utilisant une base de données SQL, 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, ...).
• Importer la description des fichiers de données SQL.
Pour réaliser cette leçon, vous devez :

1. Vous connecter à votre serveur SQL.
2. Importer sur le serveur SQL les fichiers de script SQL et le répertoire des
images (présents dans le répertoire "\Autoformation\Exercices\BaseSQL\")
Notes
avec les outils d’importation fournis (MySql, Oracle, SQL Server, ...). Le réper-
toire des images permet d’obtenir les images du fichier Produit.
3. Exécuter les fichiers de script SQL sur le serveur SQL.
Votre base de données SQL de travail pour cette leçon est prête.
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érentes étapes
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 :

Astuce
1. Cliquer sur parmi les boutons d’accès rapide.

2. La fenêtre de création d’un nouvel élément s’affiche : cliquer sur "Projet".
3. La première étape de l’assistant permet de saisir le nom du projet, son emplacement et sa
description. Dans notre cas, ce projet va simplement s’appeler "basesql".
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’étape suivante à l’aide des flèches situées en bas.

6. Cette étape permet de définir la charte graphique. Sélectionnez "Elegant". Passez à l’étape
suivante à l’aide des flèches situées en bas.
7. Cliquez sur l’étape "Base de données". Cette étape permet de donner les renseignements
concernant la base de données.
8. Sélectionnez l’option "Oui, utiliser une base de données existante" et passez à l’étape sui-
vante.
9. Sélectionnez l’option "Importer la description depuis une base de données existante".
10. L’assistant de création de l’analyse se lance.

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’étape suivante de l’assistant.
2. Vous pouvez ensuite choisir le ou les types de bases de données manipulées par le projet.
Sélectionnez OLE DB (ou la base de données SQL utilisée si vous possédez l’Accès Natif cor-
respondant).
Remarque : Les Accès Natifs sont listés en premier.

3. Sélectionnez la source OLE DB correspondant au type de votre base de données.
4. Indiquez dans les étapes suivantes les paramètres de votre connexion OLE DB (si vous avez
choisi un Accès Natif, les étapes sont identiques) :
• le nom de la connexion (le libellé associé à la connexion est optionnel). Passez à l’étape

suivante.
• le nom du serveur de la base de données. Passez à l’étape suivante.
• le nom de l’utilisateur et son mot de passe. Passez à l’étape suivante.
• le nom de la base de données si nécessaire. Passez à l’étape suivante.
5. Indiquez le mode d’accès aux données. Il est possible de :
• accéder directement aux données dans leur format actuel. Seule la description des tables
est importée dans l’analyse. Aucune conversion n’est nécessaire.
• convertir les données dans le format HFSQL Classic.
6. Dans notre cas, choisissez "Accéder directement aux données dans leur format actuel".
7. Sélectionnez la (ou les) table(s) (fichiers) à importer.
8. Validez et terminez l’assistant. Les tables sont importées et visualisées sous l’éditeur
d’analyses.

L’analyse est alors la suivante :
Génération de l’analyse
La génération de l’analyse consiste à valider les modifications de l’analyse (création de fichiers
de données, ajout ou suppression de rubriques, ...) et à les propager dans tout le projet (pages,
champs reliés, états, ...).
La génération est automatiquement proposée lorsque vous fermez l’éditeur d’analyses et que des
modifications ont été effectuées.
Il est également possible de générer l’analyse manuellement. C’est ce que nous allons faire.
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.
Lorsque votre analyse est générée, la manipulation des données se fait de la même manière que
les données HFSQL. Il n’y a aucune différence. Il est possible de :
• Créer une application complète grâce au RAD (Rapid Application Developpement). Pour plus de
détails, consultez "Leçon 3.4. Le RAD complet", page 118.
• Créer une application complète entièrement personnalisée. Pour plus de détails, consultez la
partie 4, page 127.

456 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 23, AGL n°1 en France !
Conclusion 457

Autoformation WINDEV PDF

Transféré par

Droits d'auteur :

Formats disponibles

Autoformation WINDEV PDF

Transféré par

Informations du document

Titre original

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 PDF

Transféré par

Droits d'auteur :

Formats disponibles

WINDEV 23

Documentation version 23 (2) - 1217

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

PARTIE 2 - Les bases du WLangage

Leçon 2.1. Les variables

Leçon 2.2. Les instructions conditionnelles

Leçon 2.3. Les boucles

Leçon 2.4. Les procédures

Leçon 2.5. Questions / Réponses

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

Leçon 3.1. Présentation

Leçon 3.2. WINDEV et les bases de données

Leçon 3.3. Projet et analyse

PARTIE 4 - Application complète avec données

Leçon 4.1. Présentation

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

Leçon 4.3. Recherche simple et parcours des enregistrements

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

Leçon 4.6. Imprimer une commande

Leçon 4.7. Imprimer une liste de clients

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

Leçon 4.9. Envoyer un email

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

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

Leçon 4.12. Consommer un Webservice

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

Leçon 4.14. Déployer l’application

Leçon 4.15. Diffusez "Etats et Requêtes" avec vos applications

Leçon 4.16. Gérer le multilingue

Leçon 4.17. GDS

PARTIE 5 - Administrer une base HFSQL Client/Serveur

Leçon 5.1. Introduction

Leçon 5.2. Mise en place d’une base de données Client/Serveur

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

Leçon 5.4. Installation en clientèle

PARTIE 6 - Optimiser et déboguer un projet

Leçon 6.1. Présentation

Leçon 6.3. Analyseur de performances

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

PARTIE 7 - Programmation avancée

Leçon 7.1. Présentation

Leçon 7.2. Gestion automatique des erreurs

Leçon 7.3. Manipuler des fichiers externes

Leçon 7.5. Evénement Windows

Leçon 7.6. Les threads

Leçon 7.7. Les sockets

Leçon 7.8. Le FTP

Leçon 7.9. La POO

Annexe 1. Vocabulaire

Annexe 2. Utiliser des données SQL

Présentation du cours d’auto-formation

Ce symbole indique la durée de la leçon et de ses manipulations. Attention, le temps

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.

Depuis l’impression de ce document, le cours d’auto-formation a peut-être évo-

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

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

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.

• dans un navigateur Internet, si vous avez accès à Internet :

Pour lancer directement l’aide en ligne Internet depuis le produit :

Lancez WINDEV 23 (si ce n’est déjà fait).

Pour créer la fenêtre :

5. Validez. La fenêtre est automatiquement créée sous l’éditeur. La fenêtre de sauvegarde de

• Ce champ a pour nom : "SAI_Prénom" (1).

4. Saisissez le libellé "Afficher". Le nom du bouton devient automatiquement "BTN_Afficher".

• soit dans la barre de message de l’éditeur :

1. Sélectionnez à l’aide de la souris le bouton "Afficher".

4. Dans le traitement "Clic sur BTN_Afficher", saisissez le code suivant :

Nous allons tester la fenêtre :

• Warning de compilation : Les warnings signalent des cas de programmation

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

Pour modifier le masque de saisie :

3. Validez la fenêtre de description du champ.

2. Cliquez si nécessaire sur "Ouvrir un exemple".

WINDEV : Concepts de base et terminologie

Dans une application, l’entité "NomClient" peut correspondre par exemple :

Durée estimée : 1 heure

Une variable est représentée par :