Windev 10 Guide Autoformation PDF

GAF WinDev.BOOK Page 1 Mardi, 11.
juillet 2006 5:42 17
Auto-Formation
GAF WinDev.BOOK Page 2 Mardi, 11. juillet 2006 5:42 17
WinDev 10 Express
Documentation version 10 (1) - 0606
Version d’évaluation
Diffusion interdite sans l’accord écrit de PC SOFT
Visitez régulièrement le site www.pcsoft.fr, espace actualités pour vérifier si des mises à jour sont proposées.
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 2006 : Aucune reproduction intégrale ou partielle du présent ouvrage sur quelque support que ce soit ne peut être effectuée sans
l’autorisation expresse de PC SOFT.
SOMMAIRE
Licence d’utilisation
Licence d’utilisation du logiciel en version "Express" .........................................................................................19
PARTIE 1 : A LA DÉCOUVERTE DE WINDEV

Introduction
Préliminaires ...........................................................................................................................................................22
Présentation du cours d’auto-formation ..............................................................................................................22
Comment accéder à l'aide en ligne ? ...................................................................................................................23
Le guide ...................................................................................................................................................................23
Légende des symboles ...........................................................................................................................................23
Gestion de la souris et action des touches du clavier ........................................................................................23
Si vous connaissez WinDev 9 ... ............................................................................................................................24
Que fait-on avec WinDev ? .....................................................................................................................................24
Les nouveautés de WinDev 10 ..............................................................................................................................25
Environnement de travail......................................................................................................................... 25
Programmation ......................................................................................................................................... 26
WinDev 10 version "Express" ................................................................................................................................26
Avant de commencer ...

WinDev : à quoi ça sert ? .......................................................................................................................................30
Survol de WinDev ....................................................................................................................................................31
L’environnement de WinDev.................................................................................................................... 32
L’éditeur de fenêtres ................................................................................................................................ 34
L’éditeur de code...................................................................................................................................... 35
L’éditeur d’analyses ................................................................................................................................. 36
L’éditeur de requêtes ............................................................................................................................... 37
L’éditeur d’états........................................................................................................................................ 39
L’éditeur d’aide......................................................................................................................................... 40
L’éditeur d’installation.............................................................................................................................. 40
En conclusion............................................................................................................................................ 40
PARTIE 2 : VOS PREMIÈRES APPLICATIONS

Sommaire
Leçon 2.1. Votre 1ère application

Présentation ............................................................................................................................................................44
Passons maintenant aux choses sérieuses ! .......................................................................................................44
Qu'est-ce qu'un projet ?............................................................................................................................ 44
Comment créer un projet ?...................................................................................................................... 45
Créez votre première fenêtre................................................................................................................... 46
Créez un bouton pour sortir de la fenêtre............................................................................................... 47
Gestion du compteur................................................................................................................................ 49
Gérer la saisie d’un texte ......................................................................................................................... 52
(c) PC SOFT - Version Express - Diffusion interdite

Gérer la saisie d’un numérique pour faire un calcul.............................................................................. 53

Mettre en forme la fenêtre....................................................................................................................... 55
Création d’une fenêtre avec des images ................................................................................................ 56
Comment animer une image ? ................................................................................................................ 58
Utiliser une image en fond de fenêtre .................................................................................................... 60
Création d’une fenêtre avec un menu .................................................................................................... 61
Insertion du menu "?" automatique ........................................................................................................ 65
Création du programme exécutable .....................................................................................................................66
La diffusion de l’application ..................................................................................................................................67
Installation autonome .............................................................................................................................. 67
Installation avec mise à jour automatique ............................................................................................. 68
Editeur d’installations : WDINST.............................................................................................................. 68
Leçon 2.2. Concepts W-Langage

Introduction .............................................................................................................................................................70
Les différents types de variables ..........................................................................................................................70
La déclaration des variables ..................................................................................................................................70
Variable locale........................................................................................................................................... 70
Variable globale ........................................................................................................................................ 70
Instructions du W-Langage ....................................................................................................................................72
Les instructions conditionnelles.............................................................................................................. 72
Les instructions de boucle ....................................................................................................................... 72
Les commentaires .................................................................................................................................... 73
Les procédures et les fonctions .............................................................................................................................74
Définition ................................................................................................................................................... 74
Procédure locale ....................................................................................................................................... 74
Procédure globale et Collection de procédures ..................................................................................... 74
Comment choisir si une procédure est globale ou locale ?................................................................... 74
Utilisation des procédures ....................................................................................................................... 74
A propos du passage des paramètres .................................................................................................... 75
Appel d’une procédure ............................................................................................................................. 75
Création d’une procédure (ou fonction) .................................................................................................. 75
Leçon 2.3. Chaînes et Numériques

Introduction .............................................................................................................................................................78
Manipuler une chaîne .............................................................................................................................................79
Manipuler un numérique ........................................................................................................................................80
A propos du type des champs numériques ............................................................................................ 81
Sommaire
Les monétaires ......................................................................................................................................... 81
Leçon 2.4. Dates et heures

Présentation ............................................................................................................................................................84
Manipuler les dates et les heures .........................................................................................................................84
Les dates ..................................................................................................................................................................85
Quel jour sommes-nous? ......................................................................................................................... 85
Quel jour sommes-nous, mais avec le jour et le mois en lettres ? ....................................................... 86
Quel est le nombre de jours entre 2 dates ?.......................................................................................... 86
Quel est le jour de la semaine d’une date donnée ? ............................................................................. 87

Les heures ...............................................................................................................................................................87

Quelle heure est-il ?.................................................................................................................................. 87
Combien de temps s'est écoulé entre deux heures ?............................................................................ 87
Variable de type Date, Heure, DateHeure, Durée .................................................................................. 88
Calculs avec des dates et des heures .................................................................................................... 88
PARTIE 3 : FENÊTRES ET CHAMPS

Leçon 3.1. Introduction
Présentation ............................................................................................................................................................92
Les barres d’outils ...................................................................................................................................................93
Les volets .................................................................................................................................................................93
Barre des documents ouverts ...............................................................................................................................94
Leçon 3.2. Manipulations des Champs

Introduction .............................................................................................................................................................96
Sélectionner plusieurs champs .............................................................................................................................96
Déplacer un ou plusieurs champs dans la fenêtre .............................................................................................97
Supprimer un champ ..............................................................................................................................................97
Copier des champs .................................................................................................................................................97
Superposer des champs et visualiser l’altitude des champs .............................................................................98
Modifier les caractéristiques d’un ou plusieurs champs ....................................................................................99
Leçon 3.3. Éditeurs de fenêtres et de code

L'éditeur de fenêtres ........................................................................................................................................... 101
Paramétrage de l’éditeur .......................................................................................................................102
Aide contextuelle de l'éditeur de fenêtres ............................................................................................102
Assistant de création de fenêtres .........................................................................................................102
L’éditeur de code ................................................................................................................................................. 103
Assistance à la saisie du code...............................................................................................................103
Glossaire de fonctions............................................................................................................................104
Time stamp .............................................................................................................................................104
Point d’arrêt ............................................................................................................................................105
Pose de marques dans le code .............................................................................................................105
Documentation automatique du code ..................................................................................................105
Vérification du code................................................................................................................................105
Quelques combinaisons de touches utiles...........................................................................................106
Sommaire
Refactoring (propagation des modifications) .......................................................................................106

Enroulé de code......................................................................................................................................106
Leçon 3.4. Les champs

Introduction .......................................................................................................................................................... 108
Type de champ : Libellé..........................................................................................................................109
Type de champ : Champ de saisie.........................................................................................................111
Type de champ : Bouton ........................................................................................................................115
Type de champ : Image ..........................................................................................................................118
Type de champ : Sélecteur.....................................................................................................................118
Type de champ : Interrupteur ................................................................................................................119

Type de champ : Liste.............................................................................................................................120

Type de champ : Liste Image .................................................................................................................123
Type de champ : Combo.........................................................................................................................126
Type de champ : Table ...........................................................................................................................128
Caractéristiques des tables (fichier ou mémoire) ................................................................................130
Type de champ : Arbre............................................................................................................................131
Type de champ : Jauge...........................................................................................................................131
Type de champ : Ascenseur ...................................................................................................................132
Type de champ : Potentiomètre.............................................................................................................133
Type de champ : Spin .............................................................................................................................133
Type de champ : Onglet..........................................................................................................................133
Type de champ : Web caméra ...............................................................................................................135
Type de champ : OLE, ActiveX................................................................................................................136
Type de champ : Forme..........................................................................................................................137
Type de champ : Champ Code-Barres ...................................................................................................137
Type de champ : HTML...........................................................................................................................138
Type de champ : Bouton "Etat sur Table"..............................................................................................138
Type de champ : Superchamp ...............................................................................................................138
Type de champ : Champ Fenêtre interne..............................................................................................139
Détail .......................................................................................................................................................139
Type de champ : Barre d’outils ..............................................................................................................140
Type de champ : Champ au format RTF................................................................................................141
Type de champ : Champ Séparateur.....................................................................................................141
Type de champ : Champ Graphe ...........................................................................................................142
Détail .......................................................................................................................................................142
Type de champ : Zone répétée ..............................................................................................................142
Leçon 3.5. Optimisez vos interfaces

Manipulations sous l’éditeur de fenêtres .......................................................................................................... 146
Ordre de saisie des champs (ou ordre de navigation) .........................................................................146
Etat d’un champ......................................................................................................................................146
Modification de la taille d’une fenêtre ..................................................................................................147
Ancrage des champs dans une fenêtre ................................................................................................147
Une aide pour les champs .....................................................................................................................148
Permuter des types de champs entre eux............................................................................................150
Le clonage de champ par programmation............................................................................................150
La feuille de styles et les styles .............................................................................................................150
Persistance des champs ........................................................................................................................152
Sommaire
Leçon 3.6. Description des Fenêtres

Introduction .......................................................................................................................................................... 154
Les onglets de description d’une fenêtre .......................................................................................................... 154
Onglet "Général"......................................................................................................................................154
Onglet "IHM" ............................................................................................................................................154
Onglet "Détail" .........................................................................................................................................154
Onglet "Image" ........................................................................................................................................155
Onglet "Langue" ......................................................................................................................................155

Onglet "Note"...........................................................................................................................................155
Onglet "Aide" ...........................................................................................................................................155
Onglet "Style"...........................................................................................................................................155
La barre de message d’une fenêtre ................................................................................................................... 156
Les plans d’une fenêtre ....................................................................................................................................... 156
Traitements associés à une fenêtre .................................................................................................................. 157
Déclarations globales.............................................................................................................................157
Initialisation.............................................................................................................................................157
Fermeture................................................................................................................................................157
Prise de focus .........................................................................................................................................157
Perte de focus.........................................................................................................................................158
Modification de la taille..........................................................................................................................158
Leçon 3.7. Applications multilingues

Qu’est-ce qu’une application multilingue ? ...................................................................................................... 160
Etape par étape .................................................................................................................................................... 160
Choix des langues du projet...................................................................................................................160
Internationalisation de l’analyse ...........................................................................................................161
Internationalisation des fenêtres et des champs ................................................................................162
Internationalisation des états................................................................................................................163
Internationalisation du menu ................................................................................................................163
Traduction des messages de programmation......................................................................................163
Programmation du changement de langue..........................................................................................164
Gestion des alphabets spécifiques .................................................................................................................... 165
Les outils WDMSG et WDINT .............................................................................................................................. 166
PARTIE 4 : BASES DE DONNÉES ET ANALYSES

Présentation ......................................................................................................................................................... 170
Les différents mode d’accès aux bases de données ....................................................................................... 170
Accès Natif ..............................................................................................................................................170
Accès ODBC direct..................................................................................................................................171
Accès OLE DB..........................................................................................................................................171
Accès ODBC via OLE DB.........................................................................................................................171
Quel accès utiliser ? ...............................................................................................................................171
Qu'est ce qu'une application et une analyse ? ................................................................................................. 172
Hyper File .............................................................................................................................................................. 172
Sommaire
Rubriques d’un fichier............................................................................................................................173

Définition des clés ..................................................................................................................................173
Définition des relations (contraintes d’intégrités)................................................................................174
Leçon 4.2. Définition d’une analyse

Présentation ......................................................................................................................................................... 176
Description du projet ........................................................................................................................................... 176
Création de l’analyse ........................................................................................................................................... 177
Création d’une liaison dans l’analyse ................................................................................................................ 182

Leçon 4.3. Les fichiers Hyper File

Présentation ......................................................................................................................................................... 185
Création physique d’un fichier de données ....................................................................................................... 186
Ajouter un enregistrement .................................................................................................................................. 187
Parcourir un fichier .............................................................................................................................................. 189
Rechercher un enregistrement .......................................................................................................................... 191
Supprimer et modifier un enregistrement ........................................................................................................ 192
Visualiser les enregistrements ........................................................................................................................... 194
Leçon 4.4. Cryptage de données

A quoi sert le cryptage des données ? ............................................................................................................... 198
Comment crypter les fichiers ? .......................................................................................................................... 199
Mettre en place le cryptage des fichiers...............................................................................................199
Gestion du cryptage en W-Langage.......................................................................................................200
Leçon 4.5. Les transactions

Qu’est-ce qu’une transaction ? ........................................................................................................................... 203
Un exemple simple de la nécessité des transactions pour certains types de traitements ..............203
Les transactions sur Hyper File .............................................................................................................204
Utilisation des transactions ................................................................................................................................ 204
Mettre en place la gestion des transactions ........................................................................................204
Manipuler les enregistrements lors d'une transaction : les règles à suivre.......................................205
Que faire si une transaction a été interrompue ? ................................................................................205
Leçon 4.6. La Journalisation

Qu’est-ce que la journalisation ? ........................................................................................................................ 207
La journalisation pour quoi faire ? ........................................................................................................207
Comment mettre en place la journalisation ..................................................................................................... 207
Physiquement, comment se matérialise la journalisation ? ...............................................................208
Comment réussir la mise en place de la journalisation ? ............................................................................... 209
Leçon 4.7. La réplication de données

A quoi sert la réplication de données ? ............................................................................................................. 211
Mise en oeuvre de la réplication de données ................................................................................................... 211
Mise en place ....................................................................................................................................................... 212
1. Activation ............................................................................................................................................212
2. Déclaration de la base maître ...........................................................................................................212
Sommaire
3. Déclaration des bases abonnées......................................................................................................212

4. Réplication ..........................................................................................................................................212
Leçon 4.8. Client / Serveur

Présentation ......................................................................................................................................................... 214
Mettre en place une application Hyper File Client/Serveur ............................................................................ 215
Etape 1 : Paramétrage du serveur utilisé ......................................................................................................... 215
Etape 2 : Connexion des postes client au serveur ............................................................................................ 216
Définition des connexions depuis l’éditeur d’analyses........................................................................216
Définition des connexions par programmation ....................................................................................217
Etape 3 : Paramétrage des fichiers de données sur le serveur ...................................................................... 217

Leçon 4.9. Accès Distant

Qu’est-ce que l’accès distant ? ........................................................................................................................... 219
Quand utiliser l’accès distant sur Hyper File ? .................................................................................................. 219
Quand ? ...................................................................................................................................................219
Leçon 4.10. Bases externes

Présentation ......................................................................................................................................................... 222
Description de l’analyse ...................................................................................................................................... 222
Leçon 4.11. Le réseau

Modes de gestion ................................................................................................................................................. 226
Leçon 4.12. Les triggers

A quoi sert un trigger ? ........................................................................................................................................ 228
Mise en place ....................................................................................................................................................... 228
Etape 1 : décrire le trigger (ici dans le code d’initialisation du projet) ...............................................228
Etape 2 : créer une procédure globale liée au trigger .........................................................................229
Leçon 4.13. Le RAD Projet

Présentation ......................................................................................................................................................... 231
Etape par étape, utiliser le RAD ......................................................................................................................... 231
Exécution du module RAD......................................................................................................................231
Options de l’interface .............................................................................................................................232
Type de code généré ..............................................................................................................................233
Gabarit utilisé pour les fenêtres ............................................................................................................234
Paramétrage des fenêtres .....................................................................................................................234
Les fichiers gérés par l’application........................................................................................................235
Test du projet..........................................................................................................................................236
Fenêtres générées par le RAD ............................................................................................................................ 237
Présentation............................................................................................................................................237
Fenêtre Menu..........................................................................................................................................237
Fenêtre en mode Fiche ..........................................................................................................................239
Fenêtre en mode Table ..........................................................................................................................241
Etats générés par le RAD .................................................................................................................................... 243
Présentation............................................................................................................................................243
Etat de type Table...................................................................................................................................243
RAD SQL ................................................................................................................................................................ 246
Sommaire
Fenêtres générées..................................................................................................................................246
Conclusion ............................................................................................................................................................ 247
PARTIE 5 : LES REQUÊTES

Leçon 5.1. Créez votre 1ère Requête
Introduction .......................................................................................................................................................... 252
Votre première requête ....................................................................................................................................... 253

10
Leçon 5.2. Requêtes avec comptage

Réalisation d’une requête avec comptage ....................................................................................................... 259
Leçon 5.3. Requêtes Somme

Réalisation d’une requête "Somme" ................................................................................................................. 262
Leçon 5.4. Le langage SQL

Code source d’une requête ................................................................................................................................. 266
Les ordres SQL ..................................................................................................................................................... 267
L’instruction SELECT...............................................................................................................................267
L’instruction FROM .................................................................................................................................267
La clause WHERE....................................................................................................................................267
La clause GROUP BY ..............................................................................................................................268
La clause ORDER BY ..............................................................................................................................268
Leçon 5.5. Utilisation des Requêtes

Utilisation d’une requête depuis un état ........................................................................................................... 270
Utilisation d’une requête depuis un champ ...................................................................................................... 270
Utilisation d’une requête depuis le W-Langage ................................................................................................ 270
PARTIE 6 : LES ÉTATS

Leçon 6.1. Votre premier Etat
Vocabulaire de base ............................................................................................................................................ 274
Présentation ......................................................................................................................................................... 276
Imprimer avec l'éditeur d'états ou imprimer en W-Langage................................................................276
Les états à créer .....................................................................................................................................277
Création de votre premier état ........................................................................................................................... 277
Création de l’état : Liste des clients triée par code postal ..................................................................277
Qu'est-ce qu'une rupture?......................................................................................................................281
Leçon 6.2. Etats statistiques

Présentation ......................................................................................................................................................... 287
Etape par étape .................................................................................................................................................... 287
Leçon 6.3. Etats Tableau Croisé

Sommaire
Présentation ......................................................................................................................................................... 298

Etape par étape .................................................................................................................................................... 298
Leçon 6.4. Champs spécifiques

Présentation ......................................................................................................................................................... 303
Manipulations pour créer un champ Lien ......................................................................................................... 303
Manipulations pour créer un champ clicable ................................................................................................... 304

11
Leçon 6.5. Exécution des Etats

Exécuter les états en W-Langage ....................................................................................................................... 307
Fonction iAperçu.....................................................................................................................................307
Fonction iImprimeEtat............................................................................................................................308
Leçon 6.6. Diffusez "Etats et Requêtes" avec vos applications

Lancement du logiciel Etats et Requêtes ......................................................................................................... 310
Paramétrage du projet ...........................................................................................................................311
Paramétrage de l’analyse pour l’application "Etats et requêtes" .......................................................311
Paramétrage des états...........................................................................................................................312
Création de l’exécutable et diffusion de l’application..........................................................................312
Installation de l’application....................................................................................................................313
Test de l’application ...............................................................................................................................315
PARTIE 7 : PROGRAMMATION
Leçon 7.1. Le multi-fenêtrage
Présentation ......................................................................................................................................................... 320
Manipulations sur une fenêtre en W-Langage ................................................................................................. 321
Ouverture et fermeture d'une fenêtre...................................................................................................321
Iconiser une fenêtre ...............................................................................................................................322
Une fenêtre dans tous ses états ! .........................................................................................................323
Positionnement d’une fenêtre par rapport à une autre ......................................................................323
Exemples .............................................................................................................................................................. 323
Exemple de programme gérant le multi fenêtrage de fenêtres libres (non MDI) ..............................323
Exemple de programme gérant des fenêtres MDI...............................................................................327
Accès aux champs, aux procédures et aux traitements .................................................................................. 330
Leçon 7.2. Gestion de fichiers texte

Présentation ......................................................................................................................................................... 332
Manipulations sur les fichiers externes ............................................................................................................. 332
A propos des caractères accentués......................................................................................................332
Exemples de manipulations...................................................................................................................332
Leçon 7.3. Imprimer en W-Langage

Présentation ......................................................................................................................................................... 335
Possibilités d’impression en W-Langage .......................................................................................................... 335
Sommaire
Leçon 7.4. Dessiner en W-Langage

Dessiner dans une fenêtre .................................................................................................................................. 337
Exemples .............................................................................................................................................................. 338

12
Leçon 7.5. Les Listes Graphiques

Quand utiliser des listes graphiques .................................................................................................................. 340
Programmer les listes graphiques ..................................................................................................................... 340
Dessiner dans une liste graphique........................................................................................................341
Afficher une image..................................................................................................................................342
Récupérer du texte dans une liste graphique ......................................................................................343
Leçon 7.6. Les indirections

Présentation ......................................................................................................................................................... 345
Exemple ................................................................................................................................................................ 345
Leçon 7.7. Les timers

Introduction .......................................................................................................................................................... 347
Leçon 7.8. Les Evénements Windows

Introduction .......................................................................................................................................................... 350
Exemples .............................................................................................................................................................. 351
Interdire la sortie de Windows ...............................................................................................................351
Détecter le clic sur une liste ..................................................................................................................351
Leçon 7.9. Les Composants

Présentation ......................................................................................................................................................... 353
Travail en équipe ....................................................................................................................................353
Les projets volumineux ..........................................................................................................................353
Les bases de données accédées par plusieurs projets.......................................................................354
Les traitements utilisés dans plusieurs projets ...................................................................................354
La possibilité de diffuser une fonctionnalité ou un ensemble de fonctionnalités.............................354
Composant multiproduits.......................................................................................................................354
Etape par étape .................................................................................................................................................... 355
Etape 1 : Création d’un composant.......................................................................................................355
Etape 2 : Utilisation du composant .......................................................................................................361
Distribuer un composant ..................................................................................................................................... 363
Distribution simple..................................................................................................................................363
Distribution professionnelle...................................................................................................................363
Leçon 7.10. Programmation Objet

Sommaire
Concepts ............................................................................................................................................................... 365

Les classes..............................................................................................................................................365
Les objets ................................................................................................................................................365
Les membres ..........................................................................................................................................365
Les méthodes .........................................................................................................................................365
Notion d’héritage ....................................................................................................................................365
Constructeur et Destructeur ..................................................................................................................366
Encapsulation de données ....................................................................................................................366
Créer un programme orienté objet........................................................................................................366
Déclarer une classe................................................................................................................................366
Décrire les méthodes .............................................................................................................................367
Déclarer et manipuler les objets ...........................................................................................................369

13
Leçon 7.11. UML

Qu’est-ce que UML ? ............................................................................................................................................ 371
Les diagrammes gérés par WinDev ................................................................................................................... 371
Diagramme de classes...........................................................................................................................371
Diagramme de cas d’utilisation.............................................................................................................371
Diagramme d’objets ...............................................................................................................................371
Diagramme de composants...................................................................................................................371
Diagramme d’activité .............................................................................................................................371
Diagramme de séquence.......................................................................................................................371
Diagramme de collaboration .................................................................................................................372
Diagramme d’états-transitions ..............................................................................................................372
Diagramme de déploiement ..................................................................................................................372
Leçon 7.12. WinDev et XML

Qu’est-ce que le langage XML ? ......................................................................................................................... 374
Exemple de lecture d’un fichier XML ................................................................................................................. 375
Traiter un document XML.......................................................................................................................376
Parcours ..................................................................................................................................................376
Récupérer des valeurs ...........................................................................................................................379
Effectuer une recherche ........................................................................................................................379
Leçon 7.13. Le multithread

Définition .............................................................................................................................................................. 381
Exemple ................................................................................................................................................................ 381
PARTIE 8 : APPLICATIONS JAVA

Leçon 8.1. Concepts
Qu’est-ce qu’une application Java ? .................................................................................................................. 386
Pourquoi développer une application Java avec WinDev ? ............................................................................. 386
Principe de génération d’une application Java avec WinDev ......................................................................... 386
Leçon 8.2. première application java

Présentation ......................................................................................................................................................... 389
Créer un projet JAVA ............................................................................................................................................ 390
Le RAD Java .......................................................................................................................................................... 390
Test d’un projet Java sous l’éditeur ................................................................................................................... 391
Sommaire
Compiler un projet Java sous WinDev ............................................................................................................... 391

Créer une archive Java ........................................................................................................................................ 392
Déployer une application Java ........................................................................................................................... 394
Intégration à Eclipse...............................................................................................................................396
Réaliser l’interface d’une application Java avec WinDev....................................................................396

14
Partie 9 : Communication

Communiquez avec WinDev ............................................................................................................................... 400
Leçon 9.2. La gestion des e-mails

Présentation ......................................................................................................................................................... 402
Les protocoles POP3 / SMTP ............................................................................................................................. 402
Ouvrir une session de messagerie ..................................................................................................................... 403
Envoyer un e-mail ................................................................................................................................................ 403
Lire un e-mail ........................................................................................................................................................ 405
.................................................................................................................................................................405
Comment récupérer un document attaché ? .......................................................................................405
Déconnexion ......................................................................................................................................................... 406
Autres possibilités ................................................................................................................................................ 406
Leçon 9.3. Transferts FTP

Présentation ......................................................................................................................................................... 408
Connexion à un serveur FTP ............................................................................................................................... 408
Envoyer un fichier ................................................................................................................................................ 409
Récupérer un fichier ............................................................................................................................................ 409
Déconnexion ......................................................................................................................................................... 410
PARTIE 10 : UTILISATION AVANCÉE

Leçon 10.1. Imports / Exports
Importer des éléments ........................................................................................................................................ 414
Exporter des éléments ........................................................................................................................................ 416
Importations spécifiques .................................................................................................................................... 417
Importation d’un projet WebDev ...........................................................................................................417
Importation d’une fenêtre ......................................................................................................................417
Importation Access .................................................................................................................................418
Importation Visual Basic ........................................................................................................................418
Leçon 10.2. Dictionnaire

Introduction .......................................................................................................................................................... 420
Sommaire
Manipulation du dictionnaire .............................................................................................................................. 420

Création et ouverture d’un dictionnaire ................................................................................................421
Ajouter des éléments dans le dictionnaire ...........................................................................................421
Ré-utilisation des éléments d’un dictionnaire ......................................................................................422
Leçon 10.3. Développement En Groupe

Introduction .......................................................................................................................................................... 424
Le gestionnaire de sources ................................................................................................................................. 424
Présentation............................................................................................................................................424
Fonctionnalités .......................................................................................................................................424

15
Utilisation du groupware développeur ............................................................................................................... 425

Création d’un projet................................................................................................................................425
Caractéristiques du projet......................................................................................................................426
Ouverture d'un élément du projet (fenêtre, état, ...) ............................................................................426
Connaître l'état des éléments d'un projet.............................................................................................426
Fin de la modification d'un élément : réintégration .............................................................................426
Test d'un projet ou création d'un exécutable .......................................................................................427
Droits des développeurs ........................................................................................................................427
Cas particuliers .......................................................................................................................................428
Leçon 10.4. Analyseur de performances

Présentation ......................................................................................................................................................... 430
Utiliser l’analyseur de performances ................................................................................................................. 430
Optimiser un traitement avec l’analyseur de performances .......................................................................... 431
Lire le résultat de l’analyseur de performances...................................................................................431
Choisir un traitement à optimiser..........................................................................................................431
Optimiser un traitement.........................................................................................................................431
Leçon 10.5. Comparateur de projets

Présentation ......................................................................................................................................................... 434
Comparer des éléments ...................................................................................................................................... 434
Comment le faire ? .................................................................................................................................434
Visualiser les différences trouvées entre deux éléments....................................................................435
Leçon 10.6. Tests de non régression

Présentation de WDTest ..................................................................................................................................... 437
Conditions d'utilisation...........................................................................................................................437
Utilisation de WDTest .......................................................................................................................................... 437
Enregistrement d’un script de test........................................................................................................437
Exécution d’un script..............................................................................................................................439
PARTIE 11 : COMMENT LE FAIRE ?

Questions / Réponses
Champs, fenêtres ................................................................................................................................................. 444
Comment dupliquer un champ dans une fenêtre par programmation ? ...........................................444
Comment supprimer un champ dans une fenêtre par programmation ?..........................................444
Sommaire
Comment gérer les plans d’une fenêtre ? ............................................................................................444

Comment gérer le clic sur un volet d’un onglet ?.................................................................................445
Comment afficher la progression d’un traitement ?............................................................................445
Comment afficher un site internet dans une fenêtre ? .......................................................................445
Comment modifier la couleur d’un champ ? ........................................................................................446
Comment rendre un bouton invisible ?.................................................................................................446
Comment créer le menu principal de mon application ? ....................................................................447
Comment lier une fenêtre à une option de mon menu principal ?.....................................................447
Comment insérer automatiquement le menu "?" ? .............................................................................447
Comment créer un menu contextuel ? .................................................................................................447
Comment fermer une fenêtre automatiquement après une durée prédéfinie ?...............................448

16
Comment modifier le curseur de survol pour un champ ou une fenêtre ? ........................................448

Comment passer des paramètres à une fenêtre ? ..............................................................................448
Comment récupérer des paramètres passés en ligne de commande à un exécutable ? ................449
Comment regrouper des champs pour modifier leurs propriétés par programmation ?..................449
Comment transformer un champ interrupteur en un champ sélecteur ?..........................................450
Comment mettre des boutons à la même taille ?................................................................................450
Comment gérer la persistance des champs ?......................................................................................450
Comment ajouter une image en fond dans une fenêtre ? ..................................................................450
Comment gérer la transparence d’une fenêtre ?.................................................................................450
Environnement ..................................................................................................................................................... 451
Comment visualiser l’élément auquel appartient le traitement en cours ?.......................................451
Comment imprimer le code source ? ....................................................................................................451
Comment imprimer le dossier d’analyse ? ...........................................................................................451
Comment imprimer le dossier complet de mon projet ? .....................................................................451
Comment créer un gabarit ? ..................................................................................................................451
Comment rechercher et/ou remplacer une variable dans le code ?..................................................451
Comment gérer une liste de tâches dans mon projet ? ......................................................................452
Comment connaître la liste des éléments de mon projet ? ................................................................452
Comment visualiser et changer l’ordre de navigation des champs dans une fenêtre ?...................453
Comment ajouter une langue à mon projet ?.......................................................................................453
Comment modifier les options de WinDev ? ........................................................................................453
Comment créer un perso-dossier dans l’éditeur de projet ?...............................................................453
Divers .................................................................................................................................................................... 454
Comment créer un site Internet dynamique relié à vos données ?....................................................454
Comment créer une application pour Pocket PC reliée à vos données ? ..........................................454
Comment piloter Word et Excel par OLE Automation ? .......................................................................454
Comment faire une "hard copy" ?..........................................................................................................455
Je souhaite numériser un document, est-ce possible avec WinDev ?................................................455
Je souhaite compresser des données, est-ce possible avec WinDev ?..............................................455
Comment lire et écrire dans la base de registres ? .............................................................................455
Comment lire et écrire dans un fichier INI ?.........................................................................................456
Comment désinstaller une application réalisée avec WinDev ?.........................................................456
Comment créer une installation par CD-ROM ? ...................................................................................456
Comment créer un exécutable ? ...........................................................................................................456
Comment installer une application ? ....................................................................................................457
Comment associer un icone à mon exécutable ? ................................................................................457
Comment associer une image de lancement (splash screen) à mon exécutable ?..........................457
Comment mettre l’icone de mon application en bas à droite dans la barre de tâches ?.................457
Sommaire
Comment installer un raccourci d’une application sur le bureau ?....................................................458

Comment partager le framework WinDev ?..........................................................................................458
Gestion des fichiers et des disques ................................................................................................................... 459
Comment lister tous les fichiers d’un répertoire ?...............................................................................459
Comment connaître le type d’un disque ?............................................................................................459
Comment faire une copie de fichiers ? .................................................................................................459
Comment créer un répertoire ? .............................................................................................................459
Comment lire un fichier texte ? .............................................................................................................459
Est-il possible de crypter ou de décrypter efficacement un fichier ou du texte avec WinDev ? .......460

17
Tables .................................................................................................................................................................... 461

Comment modifier la clé de parcours d’une table reliée à un fichier ? .............................................461
Comment imprimer le contenu d’une table ?.......................................................................................461
Comment modifier la rubrique mémorisée d’une table reliée à un fichier ?.....................................461
Comment récupérer le contenu d’une table dans Excel ? ..................................................................462
Comment récupérer le contenu d’une table dans Word ? ..................................................................462
Comment exporter les données d’une table vers un fichier au format XML ? ..................................462
Hyper File .............................................................................................................................................................. 463
Comment désactiver une contrainte d’intégrité ?................................................................................463
Comment gérer la valeur NULL ?...........................................................................................................463
Comment gérer une erreur de doublons lors d’une écriture dans un fichier ? .................................463
Comment gérer une erreur d’intégrité lors d’une écriture ou d’une suppression dans un fichier ?464
Comment remplir un champ Arbre à partir d’un fichier ?....................................................................464
Comment gérer une clé composée lors d’une recherche ? ................................................................465
Requêtes ............................................................................................................................................................... 466
Comment optimiser la vitesse d’exécution d’une requête ?...............................................................466
Comment ajouter ou modifier une condition dans une requête ?......................................................466
Comment ajouter ou modifier un tri dans une requête ?....................................................................466
Comment remplir un champ Arbre à partir d’une requête ?...............................................................467
Comment passer des paramètres à une requête ?.............................................................................467
Impression ............................................................................................................................................................ 469
Comment imprimer au format PDF ? ....................................................................................................469
Communication .................................................................................................................................................... 469
Puis-je utiliser des assemblages .NET dans une application WinDev ? .............................................469
Puis-je envoyer des fax avec WinDev ?.................................................................................................470
Est-il possible d'accéder aux données contenues dans mon Palm Pilot ?.........................................470
Comment récupérer des données provenant de mon PALM ?...........................................................470
Comment transférer un fichier par FTP ? .............................................................................................471
Comment envoyer un email à une personne ? ....................................................................................471
Comment communiquer avec Microsoft Outlook ?..............................................................................471
Ports ...................................................................................................................................................................... 472
Comment lire un code-barres ? .............................................................................................................472
Comment lire les données envoyées par un lecteur de carte magnétique ? ....................................472
Comment gérer un port série ?..............................................................................................................472
Comment gérer un port parallèle ? .......................................................................................................472
Conclusion
Annexe
Sommaire

18
Sommaire

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

20
5. Utilisation
L'EVALUATEUR doit utiliser le LOGICIEL pour l'usage pour lequel il est diffusé. Il est interdit de modi-
fier ou tenter de modifier ce LOGICIEL, de désassembler ou tenter de désassembler ce LOGICIEL. Il
est interdit d'enlever ou de tenter d'enlever les mentions de copyright pouvant apparaître et/ou
étant contenues dans le LOGICIEL.
La location ou le prêt de ce LOGICIEL est interdit.
Il est interdit d'utiliser WinDev "Express" pour créer et diffuser tout ou partie d'outil de développe-
ment, de LOGICIEL de création d'applications, de générateur de programmes, ou de tout LOGICIEL
de même nature que WinDev lui-même. Interrogez-nous en cas de doute.
Les fonctions de génération de code JAVA ne peuvent être utilisées que dans le cadre de la manipu-
lation habituelle du LOGICIEL, dans le but de créer une APPLICATION autonome.
Le code généré par WinDev "Express" ne doit pas être réutilisé dans d’autres logiciels ou dispositifs
de création de logiciel. Le code généré avec cette fonctionnalité ne peut pas être inclus dans un
logiciel, payant ou gratuit, qui ferait concurrence à WINDEV, WINDEV MOBILE ou WEBDEV, en tota-
lité ou en partie.
6. Absence de responsabilités
Le LOGICIEL et la documentation qui l'accompagne sont fournis en l'état, SANS AUCUNE GARANTIE
D'AUCUNE SORTE. PC SOFT ne saurait être tenu pour responsable pour tout dommage de quelque
nature que ce soit, et en particulier en cas de perte ou détérioration des données, en cas de perte
financière, en cas de perte d'exploitation, en cas de divergence des informations contenues dans la
documentation avec le comportement du LOGICIEL, en cas de comportement du LOGICIEL différent
de celui attendu. L'EVALUATEUR est seul et unique responsable du fonctionnement et du support
des programmes qu'il aura réalisé avec le LOGICIEL.
7. Cas particuliers
7.1 Compilateur d'aide
Si le LOGICIEL est accompagné du compilateur d'aide "MS Help Compiler", il est précisé que la
société Microsoft en détient les droits. PC SOFT ne détient que le droit de permettre à l'EVALUA-
TEUR de créer et diffuser des aides réalisées à l'aide de ce compilateur d'aide.
7.2 Impressions sous Linux

Si le LOGICIEL permet l'impression à travers des serveurs LINUX, la licence de l'organisme Image-
Introduction
Magick Studio LLC s'applique.

Cette licence est présente sur le support et doit être lue et acceptée.

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

22
INTRODUCTION
Préliminaires
Attention : ce manuel est un cours d'auto-formation. Il est conseillé de consulter l’aide en ligne lors-
que vous utilisez WinDev.
Le manuel du cours d'auto-formation a pour objectif de vous faire découvrir WinDev, de vous fami-
liariser avec les éditeurs et de vous apprendre les concepts de WinDev. Ce manuel n'est PAS
exhaustif des possibilités de WinDev.
Consacrez au moins deux journées pour suivre ce cours et pour apprendre WinDev : vous les renta-
biliserez vite !
Si vous essayez de démarrer le développement d'une application sans avoir suivi ce cours, vous
perdrez du temps, beaucoup plus que deux jours.
Le cours a été conçu pour être suivi de deux façons :

• soit vous suivez tous les exercices détaillés dans les leçons du cours (méthode conseillée).
• soit, si vous êtes pressé et disposez d’une expérience significative, vous pouvez uniquement
le lire sans exécuter les exemples, tous les exercices sont illustrés. Toutefois, pour que les
concepts soient plus rapidement assimilés, il est préférable de suivre les manipulations.
WinDev évoluant en permanence, les copies des fenêtres illustrant le cours peuvent être différen-
tes de celles du produit que vous possédez.
L’aspect langage n’est qu’un des nombreux aspects de développement. En prenant en compte
tous les aspects du développement, la programmation devient beaucoup plus simple.
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
Introduction
viennent d'être expliqués.
Vous disposez en Annexe, page 474, d’un glossaire récapitulant les termes utilisés qui pourraient
vous poser des difficulté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 dizaines d'exemples livrés avec WinDev : ils sont très
didactiques !

23
Comment accéder à l'aide en ligne ?

1. Sous les éditeurs, directement par la touche [F1].
2. Dans les éditeurs, le menu d'aide du menu déroulant (symbolisé par "?") vous permet d'obte-
nir le sommaire de l'aide ou de rechercher une information précise.
3. De plus, depuis l'éditeur de code, une aide spécifique est directement accessible pour cha-
que nom de fonction sélectionné grâce à la touche [F1].
4. Le bouton accessible depuis chaque fenêtre.
Le guide
Le guide regroupe plus de 150 assistants et de nombreux exemples. Accessible grâce à la "sou-
coupe" ( ) il vous permettra de vous familiariser avec les fonctionnalités de WinDev et
même de découvrir des fonctionnalités que vous ne connaissiez pas ou peu ! La soucoupe est affi-
chable par l’option "Affichage .. Barre d’outils .. Soucoupe".
Légende des symboles
Ce symbole indique la durée de la leçon et de ces manipulations. Attention, le temps

réel peut varier selon votre expérience
Un exemple est disponible pour compléter le cours.
Ce symbole présente une "Astuce", la lecture du texte associé est vivement conseillé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.
Gestion de la souris et action des touches du clavier

Introduction
Un rapide rappel des standards utilisés sous Windows :

• La souris réagit lors du relâchement du bouton.
• [ALT]+ [F4] ferme la fenêtre en cours et [TAB] passe d'un champ à l'autre. Attention, [Entrée]
valide la fenêtre (la boîte de dialogue).
• Un clic droit (avec le bouton droit de la souris) permet généralement d’afficher un menu dit
"contextuel".

24
Si vous connaissez WinDev 9 ...

Si vous connaissez déjà WinDev 9 et si vous souhaitez vous familiariser rapidement avec les nou-
veautés de WinDev 10, nous vous conseillons de lire et de suivre plus particulièrement les chapi-
tres suivants :
• Chapitre "Gestion des timers", page 346.
• Chapitre "Gestionnaire de sources", page 423.
• Chapitre ‘‘Développer une Application Java’’, page 385.
• Chapitre "Logiciel Etats et Requêtes", page 309.
Mais 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 (Comptabilité, Paie, Finances, Commerce, Stock, ERP, CRM, EAI, EDI, VPC, GRM, …)
• Industrie (robots, caisses, automates, balances, lecteur de badge, supervision, ...)
• Médical
• Multimedia
• Internet
• Accès distant
•…
WinDev est un outil de développement complet qui intègre tous les outils nécessaires au cycle de
réalisation d’une application.
Contrairement à d’autres langages de développement traditionnels, il n’est pas nécessaire de cher-
cher 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 W-Langage, vous étonnera par sa simplicité :
quelques heures suffisent pour appréhender le langage, une semaine suffit en général pour maîtri-
ser toute sa puissance !
Comme il est en français, le W-Langage (disponible également en anglais) vous fera gagner du
temps !
Introduction
Si vous ne connaissez pas WinDev, il est conseillé de suivre la leçon “Avant de commencer ...”,
page 29.

25
Les nouveautés de WinDev 10

Voici la liste, non exhaustive, des principales nouveautés de WinDev 10 par rapport à WinDev 9 :
Environnement de travail
Les principales nouveautés de l’environnement de travail :
• Editeur de projet :
•Gestionnaire de sources.
•Positionnement personnalisé des différents volets et onglets de l’environnement (volet "Pro-
jet", volet "Analyse", ...).
•Perso-Notes : Saisie des penses-bêtes dans les différents éléments du projet (option "Nou-
velle Perso-Notes" du menu contextuel).
•FishEye : Zoom sur la partie du graphe du projet survolée (icone "FishEye").
•Détection des éléments non-utilisés dans le projet avec possibilité de les supprimer et de
les archiver (option "Outils .. Nettoyer le répertoire du projet").
•Image des composants dans les perso-dossiers.
•Débranchement d’un warning donné (option "Ne plus afficher" du menu contextuel).
• Editeur de fenêtres :
•Nouveaux champs : champ Graphe, champ Zone Répétée.
•RID (Rapid graphical Interface Design) : Possibilité de créer uniquement l’interface des fenê-
tres en fonction de l’analyse du projet.
•Zoom interactif : Zoom d’une partie spécifique d’une fenêtre (option "Affichage .. Barres
d’outils .. Modules additionnels .. Zoom interactif").
•Onglet "Détail" des champs : options visuelles et donc facilement compréhensibles.
•Multilangue : description des différents formats des dates, des heures, des monétaires et
des numériques pour une langue donnée (onglet "Langues" dans la description du projet).
• Editeur d’états :
•Possibilité de fournir gratuitement avec l’application le logiciel "Etats et Requêtes". Ce logi-
ciel permet de créer et de modifier les états et requêtes de l’application.
•Champ clicable et champ Lien en aperçu.
•Gabarits personnalisables pour l’aperçu avant impression.
Introduction
• Editeur de code :
•Brique de code : possibilité de saisir des morceaux de code réutilisable (option "Code .. Bri-
ques de code .. Gestionnaire des briques de code").
•Bulle d’aide sur une fonction : affichage des valeurs de retour.
•Saisie assistée : propose les paramètres des fenêtres.
•Complétion : liste les éléments déjà manipulés.
•Correction automatique : propose une liste des corrections possibles.
•Correcteur orthographique des variables.
•Gestion centralisée des erreurs.
•Préfixage automatique des variables et des champs.
•Débogueur : débogage multithread, débogage des composants, saisie de code possible
pendant le débogage, édition de classes, des tableaux, ...

26
• Editeur d’UML :
•Mise à jour automatique du diagramme lors de la modification du code d’une classe ou
d’une structure.
• Editeur de modélisation :
Nouvel éditeur permettant de modéliser facilement et sans contrainte les différentes éta-
pes d’un traitement, l’organisation d’un service, le déroulement d’un mode opératoire, ...
• Bases de données :
•Utilitaire HFDiff : compare le contenu de deux fichiers de données de structure identique.
•Hyper File Client/Serveur : support des transactions, journalisation, contraintes d’intégrité.
•3-Tiers
Programmation
Les principales nouveautés de programmation :
• Analyse d’impact des modifications effectuées.
• Création de procédures par sélection de code.
• Parcours des tableaux du langage, des lignes sélectionnées ou de toutes les lignes d’un
champ table (instruction POUR TOUT).
• Interrogation directive : amélioration de la compréhension des messages destinés aux utilisa-
teurs.
• Importation de données access améliorée.
• Nouvelles fonctions :
•Fonctions de gestion du planificateur (fonctions PlanificateurXXX).
•Fonctions de gestion des champs Zone Répétée (fonctions ZoneRépétéeXXX).
•Fonctions de chronométrage (fonctions ChronoXXX).
•Fonctions de manipulation des annuaires LDAP (fonctions LDAPXXX).
•Fonctions de gravage de CD-ROM
•Fonctions de gestion des ports USB (fonctions USBXXX)
•Fonctions de gestion des données attachées aux photos numériques.
•Fonctions de gestion des couleurs TSL.
•...
WinDev 10 version "Express"

Introduction
Attention : Certaines fonctionnalités présentées ou citées dans ce cours d’auto-formation peuvent

ne pas fonctionner dans cette version d’évaluation.

PARTIE 1
A la découverte de WinDev
29
AVANT DE COMMENCER ...

Ce que vous allez découvrir ...
• WinDev : à quoi ça sert ?
• Survol des fonctionnalités de WinDev.
Durée estimée : 1h
Partie 1 : A la découverte de WinDev

30
WinDev : à quoi ça sert ?

WinDev 10 permet de gérer, étape par étape, de la conception à la finalisation, le cycle complet du
développement d’une application.
WinDev permet à vos équipes de réaliser toutes les applications dont vous rêvez.
L’environnement de WinDev se présente de la manière suivante :
WinDev 10 permet de créer des applications qui gèrent des données. Les applications WinDev
accèdent à toutes les bases de données, relationnelles ou non du marché. Toutes les bases de
données sont supportées. WinDev 10 est livré en standard avec :
• Hyper File Classic, une puissante base de données relationnelle, déjà utilisée sur des millions de
sites !
• Hyper File Client / Serveur, une puissante base de données relationnelle Client/Serveur.
WinDev 10 propose certainement l’environnement de travail le plus puissant, le plus facile et le

plus intégré du marché ! Vos équipes créeront facilement de superbes applications.
L’éditeur de fenêtres de WinDev 10 est 100% WYSIWYG ("Ce que vous voyez est ce que vous
aurez"). Il permet de réaliser facilement de superbes fenêtres reliées aux données.

31
Survol de WinDev
Pour cette leçon, vous allez effectuer vos premières manipulations (simples, rassurez-vous !) sous
l’environnement de WinDev 10.
4 •Lancez WinDev 10 :
soit en cliquant sur l’icone du bureau :
• soit en sélectionnant le menu "Démarrer .. Programmes .. WinDev 10 .. WinDev 10 ".

WinDev est lancé.
S’il s’agit de sa première exécution, WinDev vous propose de personnaliser l’environnement de tra-
vail. Personnalisez votre environnement et répondez aux questions posées.
Cette fenêtre s’affiche alors :
4 1.
Sélectionnez l’option "Ouvrir un projet exemple".
Sélectionnez le répertoire "Exemples didactiques\WD Requetes".
2. Sélectionnez ensuite le fichier "WD Requetes.wdp".

32
3. Validez en cliquant sur le bouton "Ouvrir". L’application "WD Requetes" s’ouvre sous WinDev.
L’environnement de WinDev
L’environnement de travail WYSIWYG ("Ce que vous voyez est ce que vous aurez") de WinDev 10
apporte un confort à la productivité.
L’éditeur de projet permet de visualiser de manière graphique les enchaînements

entre les différents éléments du projet. Il permet également de manipuler les perso-
dossiers (dossiers regroupant certains éléments du projet)
La barre des documents donne la possibilité de ré-afficher les éléments précédem-
ment ouverts en un seul clic.
Ensemble de volets regroupés horizontalement. Chaque volet propose un ensemble

d’éléments : composants (éléments facilement ré-utilisables dans tous vos projets),
champs pré-définis, exemples, ... Un gain de temps inestimable !
Le navigateur donne une vision globale du graphe actuellement affiché, et indique
la partie actuellement visible à l’écran.
Le volet "Projet" donne une vision globale du projet : un double-clic (ou un "Drag and
Drop") sur un élément ouvre cet élément directement dans l’éditeur approprié.
Le contenu peut être affiché sous forme de liste ou de "TreeView" (notre exemple).
L’environnement de WinDev 10 est très intuitif. Les différents volets peuvent être affichés à tout
moment grâce à l’option "Affichage .. Barre d’outils".

33
4 1.
Vous allez ouvrir une fenêtre de l’exemple "WD Requetes". Pour cela :
Cliquez sur le bouton "WD Requetes" présent dans la barre de documents ouverts.
2. Dans le graphe du projet affiché, tapez rapidement le nom de la fenêtre à ouvrir : "Menu".
Cette fenêtre est la première fenêtre du projet : c’est la première fenêtre qui sera affichée lors
du démarrage de l’application. Cette fenêtre apparaît sur un fond orange dans le graphe du pro-
jet.
3. Double-cliquez sur la fenêtre sélectionnée pour l’ouvrir.
En réalisant cette manipulation vous avez pu constater qu’une information est apparue en haut à
droite du graphe du projet. Lors du survol de cette information, l’ADD (Aide Au Développement)
vous indique une autre possibilité pour ouvrir rapidement vos éléments du projet.
Vous pouvez tester cette astuce : la recherche d’éléments par la combinaison de touches
[CTRL]+[E]. Il suffit de saisir les lettres contenues dans l’élément recherché pour que la liste des
éléments correspondants s’affiche :

34
L’éditeur de fenêtres
L’éditeur de fenêtres de WinDev permet de réaliser simplement de superbes fenêtres reliées aux
données. La fenêtre que vous venez d’ouvrir s’est affichée sous l’éditeur de fenêtres de WinDev.
Vous pouvez observer différents champs dans cette fenêtre.
4 Positionnez votre souris dans la fenêtre, au-dessus d’un texte ou d’une image. Cliquez avec le
bouton gauche de la souris.
Le champ est alors sélectionné.
Vous pouvez constater que des informations concernant le champ sont affichées dans la barre de
messages.
Ces informations correspondent au nom du champ sélectionné, à sa position, sa taille ainsi que le
zoom d’affichage actuel sous l’éditeur de fenêtres.

35
Grâce à un double-clic sur le champ, vous pouvez accéder à toutes les caractéristiques du champ :
nom, libellé, liaison avec un fichier de données, ...
Pour fermer la fenêtre de description, il suffit de valider avec le bouton "OK".

4 Sélectionnez
Pour cela :
maintenant le bouton "Code SQL" afin de visualiser le code qui lui est associé.
1. Cliquez sur le champ "Code SQL". Ce champ se nomme "CODESQL".

2. Appuyez sur la touche [F2] de votre clavier. Le code associé à ce champ s’affiche dans l’édi-
teur de code.
L’éditeur de code
Le langage intégré de WinDev, le W-Langage, permet de décrire tous les traitements désirés. Le W-
Langage est un L5G (Langage de 5ème Génération) qui simplifie énormément la programmation de
vos applications Windows.
L’éditeur de code participe à la puissance et à la productivité de WinDev. La saisie du code est
intuitive, rapide et se fait directement dans le champ ou la fenêtre concernée.
Tous les événements sont gérés : clic, double-clic, touche pressée, survol de la souris, ...
Pour un plus grand confort et une meilleure lisibilité, chaque mot est coloré en fonction de son
type.
Par exemple, dans la fenêtre de code que vous venez d’ouvrir :
• Le mot "Ouvre" est en bleu : c’est une fonction du W-Langage.
• Le mot "FenInfo" est en cyan : c’est un élément du projet.
• La phrase "Code SQL généré" est colorée en mauve : c’est une chaîne de caractères affichée
à l’écran.
Vous disposez également d’une assistance à la saisie de code : lors de la frappe du nom d’une
fonction, le type de paramètre attendu par cette fonction est affiché dans une bulle d’aide ainsi

36
que dans la barre de messages de WinDev. La complétion sur les noms des variables ou des fonc-
tions utilisées est également proposée lors de la saisie du code.
Chaque champ, chaque éditeur et chaque fonction ou propriété du W-Langage possèdent une aide
en ligne.
4 1.
Vous allez visualiser l’aide de la fonction Ouvre. Pour cela :
Positionnez le curseur de la souris sur le nom de la fonction "Ouvre".
2. Appuyez sur la touche [F1] de votre clavier. La page d’aide associée à la fonction est alors
affichée.
Dans cette page d’aide, la documentation de la fonction est affichée pour tous les produits, les lan-
gages, les plate-formes disponibles. Pour voir la documentation concernant uniquement un produit,
un langage ou une plate-forme, il suffit de cliquer sur les icones de la barre d’outils de la fonction.
L’éditeur d’analyses
L’analyse est une phase importante de la description d’une application. L’analyse permet de
décrire la structure des données utilisées par l’application.
Grâce à WinDev, il est facile de définir les analyses, sur des données nouvelles ou existantes. Tout
cela se fait de manière très intuitive.
L’éditeur d’analyses permet de créer votre base de données, les fichiers de données et les liaisons
entre ces fichiers de données.
4 Vous allez ouvrir l’analyse de l’exemple "WD Requetes". Pour cela, sélectionnez l’option de
menu "Projet .. Charger l’analyse".

37
L’éditeur d’analyses s’ouvre.

Plusieurs fichiers de données reliés entre eux sont présents dans l’analyse.
WinDev 10 permet de créer des applications reliées à des données grâce au RAD (option de menu
"Atelier .. RAD Application Complète").
L’éditeur de requêtes
L’éditeur de requêtes permet de créer automatiquement des requêtes sur des fichiers de données,
aussi bien des requêtes simples que complexes. Cela simplifie la programmation : fenêtres, tables,
combos, états ... pourront s’appuyer sur des requêtes.
4 1.
Vous allez ouvrir une requête de l’exemple "WD Requetes". Pour cela :
Sélectionnez l’option "Fichier .. Ouvrir ...",
2. Sélectionnez le fichier "RequeteCalcul.WDR".
3. Cliquez sur "Ouvrir".

38
L’éditeur de requêtes s’affiche :

Cette requête permet d’afficher le chiffre d’affaires par société.

La source de données d’une requête peut être une base Hyper File ou une base tierce : Oracle,
MySQL, SQL Server, DB2, AS/400, Access, ...
Il suffit de choisir les rubriques à intégrer, de saisir les conditions de sélection à l’aide de l’assistant
de création de requêtes, ... et la requête est automatiquement créée sous vos yeux.
Les requêtes sont entièrement générées en langage naturel, ce qui affine la compréhension pour
des évolutions futures !
Il est inutile de connaître le SQL pour créer de puissantes requêtes : le code SQL est automatique-
ment généré par WinDev.
4 Sélectionnez l’option de menu "Requête .. Code SQL".

39
Le code SQL généré par WinDev est affiché dans l’éditeur de requêtes :
L’éditeur d’états
L’éditeur d’états permet de créer rapidement des états imprimables directement depuis vos appli-
cations. Un assistant est systématiquement proposé pour créer des états : il pose les questions
permettant de n’oublier aucun élément !
4 1.
Vous allez ouvrir un état de l’exemple "WD Requetes". Pour cela :
Sélectionnez l’option "Fichier .. Ouvrir ...".
2. Sélectionnez le fichier "EtatRequeteCalcul.WDE".

3. Cliquez sur "Ouvrir".
L’éditeur d’états s’affiche :
Il est aussi facile de créer un état que de créer une fenêtre !

40
Vous pouvez saisir du code W-Langage dans tous les éléments d’un état : vous pourrez ainsi réali-
ser les traitements les plus spécifiques, sans jamais rencontrer de blocage.
Vous pourrez également générer du HTML, du XML, du XLS, du PDF ou du RTF en un clin d’oeil ! De
plus, il n’y a pas de redevances ou de royalties à verser pour diffuser les états avec vos applications
WinDev !
L’éditeur d’aide
WinDev est livré avec un éditeur d’aide permettant de créer les fichiers d’aide associés à votre
application. Vous pouvez créer l’aide en même temps que vous développez votre application. Ainsi,
vos utilisateurs pourront consulter l’aide de votre application à tout moment.
L’éditeur d’installation
Le générateur d’installation crée des programmes d’installation sur CD ou disquettes, mais égale-
ment des fichiers auto-extractibles (utile pour proposer un programme en téléchargement sur Inter-
net). L’installation sur le poste final est plus rapide.
L’installation "Réseau" est gérée automatiquement. Vous avez ainsi la certitude que chaque poste
utilisera la dernière version de votre application.
Vous pouvez également réaliser une installation à partir d’un serveur WEB (serveur HTTP) : les utili-
sateurs pourront télécharger l’application à partir d’un site Internet.
En conclusion
Vous avez pu survoler une partie de l’environnement de WinDev 10.
Vous pourrez explorer plus en détail les principales fonctionnalités de WinDev en suivant ce cours
d’auto-formation.
Vous disposez à tout moment d’une aide en ligne accessible par la touche [F1] de votre clavier.
Vous avez également la possibilité de contacter le Support Technique Gratuit de PC SOFT et accé-
der au service "Assistance Directe®" en vous connectant sur le site Internet de PC SOFT (http://
www.pcsoft.fr).
Pensez à visiter régulièrement le site Internet de PC SOFT (http://www.pcsoft.fr) pour obtenir des
mises à jour des exemples fournis avec WinDev.

PARTIE 2
Premières applications
43
LEÇON 2.1. VOTRE 1ÈRE APPLICATION

Ce que vous allez apprendre dans cette leçon ...
• Création de votre première fenêtre.

• Manipulation des champs et des images.
• Ecriture de vos premières lignes de code.
• Création de votre premier exécutable.
• Diffusion de votre premier exécutable.
Vous trouverez dans le répertoire "\Autoformation\Corriges\Faire_Connaissance" le

projet "Faire Connaissance.WDP" contenant les illustrations de cette leçon.
Vous pouvez lancer l’exécutable correspondant directement depuis WinDev grâce à
Partie 2 : Vos premières applications

l’option "? .. Guide d’auto-formation .. Faire connaissance".

44
Présentation
Pour avoir un avant-goût de ce que vous allez réaliser, lancez WinDev 10. Sélectionnez le menu "?"
dans la barre de menu, puis l’option "Guide d’Auto-formation". Dans le menu déroulant qui s’affi-
che, sélectionnez l’option "Faire connaissance".
Remarque : Dans la suite de ce cours, l’accès aux différentes options des menus sera représenté de la
manière suivante : "Menu Principal .. Sous Menu .. Option".
Le programme se lance. La fenêtre ci-dessous apparaît.

Parcourez les différentes fenêtres et menus du programme.

Dans cette leçon, vous étudierez comment :
• Gérer un compteur et un bouton (option "Fenêtres .. Compteur" de l’exemple)
• Saisir et afficher un texte (option "Fenêtres .. Saisie" de l’exemple)
• Faire un calcul (option "Fenêtres .. Saisie" de l’exemple)
• Afficher une image statique ou une image animée (option "Fenêtres .. Image" de l’exemple)
• Créer un menu.
Cet exemple a été volontairement limité à ces différents types de traitements. Vous vous familiari-
serez plus tard avec d’autres fonctionnalités ... Il en existe des centaines. Vous n’allez pas vous
ennuyer !
Passons maintenant aux choses sérieuses !

Nous allons voir comment réaliser ces différents traitements. Pour cela, nous allons créer un nou-
veau projet.
Qu'est-ce qu'un projet ?
Une application est constituée d’un programme exécutable ou d'un ensemble de programmes exé-
cutables qui permettent de réaliser une ou plusieurs actions sur des données (stockage de don-
nées, extraction de données, affichage de données, affichage de graphiques ...).
Un programme exécutable est composé d’éléments directement manipulables par l'utilisateur :

fenêtres, états imprimables, fichiers de données, requêtes, ...
Le projet relie entre eux les différents éléments du programme. C'est à partir de ce projet que
pourra être créé le programme exécutable.

45
Comment créer un projet ?

Pour créer notre premier projet :
4 Sélectionnez l'option "Fichier .. Nouveau". Survolez le "P", puis cliquez sur "Exe" : notre projet va
nous permettre de créer un exécutable. L’assistant de création de projet se lance.
Ce projet aura pour nom "Faire Connaissance".
4 Cliquez sur "Suivant".
4 Saisissez le nom du projet "Faire Connaissance". Le nom du projet est le nom sous lequel sera
enregistré le fichier du projet, avec l’extension "WDP".
Le répertoire du projet est initialisé par défaut "Mes Projets\Faire Connaissance".

4 Validez en cliquant sur "Suivant".
4 Ce projet ne sera pas partagé entre plusieurs développeurs. Conservez l’option "Je vais tra-
vailler seul sur le projet", et cliquez sur le bouton "Suivant".
4 Vous pouvez utiliser une "Charte de programmation" pour le développement de votre projet.
Cette fonctionnalité permet d’uniformiser les noms des différents éléments (champs, fenêtre,
variables, ...) de votre projet. Conservez l’option "Utiliser la charte de programmation ci-des-
sous", et cliquez sur le bouton "Suivant".
4 Vous allez ensuite choisir le look de votre application en sélectionnant un gabarit. Sélectionnez
le thème de gabarit "Office12".
4 Validez en cliquant sur "Suivant".
4 Vous pouvez ensuite choisir les différentes langues gérées par votre projet. Dans cet exemple
conservez l’option sélectionnée par défaut et validez en cliquant sur le bouton "Suivant".
4 Ce projet n’utilisera pas d’analyse. Sélectionnez l’option "Ne pas utiliser d’Analyse (projet sans
fichiers de données)" et validez en cliquant sur le bouton "Suivant".
4 Cliquez sur le bouton "Terminer". Le projet se crée automatiquement.
4 Sélectionnez l’option "Aller directement dans l’éditeur de WinDev".

46
Créez votre première fenêtre

Vous allez créer la fenêtre suivante :
Le compteur numérique sera incrémenté ou décrémenté avec les boutons [ + ] et [ - ].

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 Win-
Dev. De plus, cette fenêtre vous permettra de découvrir des concepts fondamentaux pour la suite
de ce cours.
4 Pour créer la fenêtre :

1. Cliquez sur le bouton dans la barre d’outils de WinDev :
2. Sélectionnez "Fenêtre". L’assistant de création de fenêtre s’affiche.

3. Sélectionnez "Vierge" et choisissez un modèle de gabarit.
WinDev propose un grand nombre de gabarits. Ils permettent de donner un "look" sympathi-
que à l’interface d’une application.
Souvent, toutes les applications réalisées pour Windows (sans les thèmes d’écran) se res-
semblent : une fenêtre rectangulaire, un fond gris, une barre de titre bleue, des boutons
gris, pas d’image, ... un peu triste tout cela et dommage, car c’est le 1er contact avec l’utili-
sateur final !
Avec WinDev, vous pouvez sélectionner le gabarit de votre choix parmi plusieurs dizaines de
modèles. Vos fenêtres, vos boutons et vos états sont "habillés" en quelques secondes !
Vous avez également la possibilité de créer vos propres gabarits. C’est une fonctionnalité
avancée de WinDev. Pour plus de détails, consultez l’aide en ligne (mot-clé : "Gabarit").
4 Sélectionnez le gabarit "Office12", et cliquez sur le bouton "OK".

Nous allons renseigner les informations de la fenêtre (nom, titre, libellé).
4 Faites un clic droit sur la fenêtre et sélectionnez l’option "Description".

47
4 Saisissez les informations suivantes :
1. Le nom "logique" de la fenêtre : "Fenêtre_compteur".

2. La description de la fenêtre : "Exemple d’un compteur".

3. Le titre de la fenêtre : "Exemple d’un compteur".
Le nom de la fenêtre est le nom sous lequel sera enregistré la fenêtre sur le disque (avec
l’extension "WDW"). Ce nom sera également utilisé en programmation pour manipuler la fenê-
tre, nous y reviendrons.
4. Validez en cliquant sur le bouton "OK". Le titre apparaît dans la barre de titre.
Créez un bouton pour sortir de la fenêtre

Dans une fenêtre, il y a toujours un bouton ou une option pour quitter la fenêtre. Bien entendu, si
vous n’ajoutez pas de bouton ou d’option, il reste toujours la possibilité de fermer la fenêtre en cli-
quant sur l’icone de la barre de titre, mais ce n’est pas très convivial.
4 Pour créer le bouton de fermeture :

1. Cliquez sur l’icone dans la barre d’outils :
2. Positionnez le curseur de la souris dans votre fenêtre, le contour du bouton apparaît.

3. Cliquez à la position où le bouton doit être créé.
4 1.
Saisissez le libellé du bouton :
Cliquez sur le bouton.
2. Saisissez directement le libellé "&Ferme".

48
Le "&" permet de définir la lettre d’appel du bouton : la lettre qui suit est automatiquement sou-
lignée et considérée comme lettre d’appel. L’utilisation de la touche [ALT] et de la lettre souli-
gnée entraîne la même action qu’un clic de la souris sur ce bouton.
3. Validez en appuyant sur la touche "Entrée".
4. Affichez la description de ce bouton (option "Description" du menu contextuel). Le nom du
bouton a été créé automatiquement en fonction :
• de la charte de programmation utilisée (dans ce cas, les boutons sont préfixés par les lettres
BTN_).
• du libellé du bouton.
5. Fermez la fenêtre de description par le bouton "OK" ou "Annuler".
Il ne reste plus qu’à associer à ce bouton le code permettant de fermer la fenêtre. Ce code est écrit
dans le langage de programmation de WinDev : le W-Langage.
4 1.
Pour saisir le code du bouton :
Faites un clic droit sur le bouton et sélectionnez l’option "Code".
2. Saisissez la ligne "Ferme()" dans le code de "Clic sur BTN_Ferme".
L’instruction W-Langage pour fermer une fenêtre est tout simplement Ferme.
C’est une instruction en français. Cependant, pour les inconditionnels de la lan-
gue de Shakespeare, vous pouvez également saisir les commandes du W-Lan-
Notes
gage en anglais (ici, Close).

Vous pouvez même convertir du code écrit en français en anglais et vice-versa
(option "Code .. Langue du code").
Vous observez des changements de couleurs lors de la saisie. En effet, l’éditeur de code colore les
différents mots en fonction de leur nature (couleur bleue pour les fonctions WinDev, ...). Vous pou-
vez personnaliser ces couleurs par l’option "Affichage .. Options d’édition de code".
4 Fermez
tions.
la fenêtre de code (option "Fichier .. Fermer") et validez l’enregistrement des modifica-
4 Confirmez également l’enregistrement de la fenêtre.

Vous pouvez facilement déplacer le bouton de fermeture : cliquez sur le bouton de fermeture avec
le bouton gauche de la souris. Tout en maintenant le bouton de la souris enfoncé, faites glisser la
souris (et le champ) à l’emplacement voulu.

49
Gestion du compteur
Pour gérer le compteur numérique, vous allez créer :
• un champ dans lequel va s’afficher la valeur numérique,
• deux boutons qui vont permettre d’ajouter 1 ou de soustraire 1 au compteur.
4 Pour créer le champ de saisie : cliquez sur l’icone et déplacez la souris vers votre fenêtre.
4 Double-cliquez sur le champ.

La fenêtre de description du champ apparaît.
Renseignez les différentes informations :

1. Saisissez le nom "SAI_Compteur" (les caractères SAI_ correspondent aux caractères utilisés
par la charte de programmation pour identifier les champs de saisie).
2. Entrez le libellé "Compteur".
3. Modifiez le type du champ pour qu’il devienne numérique.
4. Le format (masque de saisie et d’affichage) est "999 999", cela signifie que :
•le nombre peut comporter jusqu’à 6 chiffres.
•le nombre ne comporte aucune partie décimale.
•le séparateur de milliers est un espace.
Nous voulons donner une valeur initiale au compteur. Pour cela, il suffit d’initialiser le contenu du
champ avec cette valeur (onglet "Contenu").
Beaucoup de développeurs feraient cette opération par programme : il faudrait

écrire une ligne de code pour affecter une valeur dans ce champ.
Notes
Avec WinDev, pas besoin de saisir du code. Ce type d’information fait partie des
caractéristiques du champ. Le contenu du champ peut être initialisé à l’aide de
l’onglet "Contenu".

50
4Bien
Cliquez sur l’onglet "Contenu" et saisissez la valeur initiale, par exemple, "100".
entendu, comme partout dans WinDev, vous pouvez procéder de manière traditionnelle en
saisissant la ligne suivante en W-Langage dans le code d’initialisation du champ :
COMPTEUR = 100
4 Cliquez sur le bouton "OK" pour valider les informations du champ.

Sous l’éditeur, on peut voir que le champ contient maintenant la valeur 100. Ce concept se nomme
"Live Data" : vous voyez les données en temps réel ! Vous retrouverez ce concept un peu plus tard,
lors de la manipulation des fichiers de données.
4 Nous allons maintenant créer le champ "Spin" qui va nous permettre de modifier la valeur du
compteur. Pour créer le champ spin :
1. Cliquez sur l’icone .
2. Déplacez la souris vers la fenêtre pour positionner le champ.
4 Affichez le code du champ Spin (option "Code" du menu contextuel du champ). Ce champ con-
tient deux codes spécifiques :
• Le code d’incrémentation : ce code est exécuté lorsque l’utilisateur manipule le champ spin
pour augmenter une valeur.
• Le code de décrémentation : ce code est exécuté lorsque l’utilisateur manipule le champ spin
pour diminuer une valeur.
4 Dans le code d’incrémentation, saisissez le code suivant :

SAI_COMPTEUR = SAI_COMPTEUR + 1
Cette ligne de code signifie que l’on ajoute 1 à la valeur du champ SAI_COMPTEUR. Le champ
SAI_COMPTEUR est alors manipulé comme une variable.
Les adeptes du langage C peuvent saisir tout simplement :

SAI_COMPTEUR++
Notes
Pour les non initiés au langage C, "++" indique une incrémentation de 1 unité.
Vous pouvez également utiliser la syntaxe :
SAI_COMPTEUR += 1
Remarque : Dès la saisie des premiers caractères, WinDev propose tous les mots du vocabulaire
W-Langage contenant ces caractères. L’assistance au développement est poussée très loin. Vous
ne pouvez plus vous tromper en saisissant le nom d’un élément : les erreurs de syntaxes sont mini-
misées. Il suffit de sélectionner le mot désiré et de valider par la touche [Entrée]. Vous pourrez ainsi
vous concentrer sur l’algorithme.

51
De plus, le compilateur détecte en temps réel les erreurs et vous les indique :
Le principe est le même pour le code de décrémentation. Saisissez son code :

SAI_COMPTEUR = SAI_COMPTEUR - 1
Ce code signifie que l’on enlève 1 à la valeur du champ SAI_COMPTEUR.

4 Testons cette fenêtre :
1. Enregistrez les modifications en cliquant sur l’icone (ou sur l’option "Fichier .. Enregis-
trer", ou par la combinaison de touches [Ctrl]+[S]).
2. Cliquez sur l’icone "GO" (ou [F9]).
3. Testez les différents champs, et observez les changements du champ de saisie.

Tout développeur sait que tester un programme est souvent long, voire fastidieux. Avec WinDev,
en UN CLIC, vous testez la fenêtre (ou l’état) que vous êtes en train de réaliser. C’est à la fois
simple et rapide !
4 Cliquez sur le bouton "Ferme" pour fermer la fenêtre. L’éditeur de WinDev réapparaît.
Nous en avons terminé avec notre compteur !

52
Gérer la saisie d’un texte

Nous allons maintenant voir comment manipuler un champ de saisie texte.
Dans une nouvelle fenêtre, vous allez maintenant créer un champ de saisie. Ce champ sera utilisé
pour saisir un prénom. Un bouton permettra d’afficher ce prénom.
4 Pour créer une nouvelle fenêtre :

2. Sélectionnez "Fenêtre".
3. Sélectionnez "Vierge", choisissez le modèle de gabarit "Office12" et cliquez sur "OK".
4. Faites un clic droit sur la fenêtre puis sélectionnez l’option "Description".
5. Donnez à la fenêtre le nom "Exemple_Saisie" et le titre "Exemple de saisie".
6. Enregistrez la fenêtre.
4 Pour créer le champ de saisie :

1. Cliquez sur l’icone et glissez le champ dans la fenêtre.
2. Faites un clic droit sur le champ et sélectionnez l’option "Description".
3. Le champ de saisie créé :
• a pour nom : "SAI_Saisie1".
• est de type texte.
4. Modifiez le libellé par "Prénom".
Par défaut, les caractères seront saisis en majuscules ou en minuscules selon la position de la
touche [CAPSLOCK] du clavier. Ce genre de saisie peut être très gênant lors d’une recherche
par exemple.
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.
ère
4 Modifiez le format du champ de saisie (masque de saisie) et sélectionnez "1 lettre en majus-
cule" (la première lettre saisie sera en majuscule et les autres seront en minuscules). Ce mas-
que de saisie va nous être utile pour afficher le prénom saisi avec une majuscule comme
première lettre. Validez ensuite par "OK".
4 Pour créer le bouton [Afficher] :

2. Indiquez le nom du bouton : "BTN_Affiche".
3. Modifiez le libellé par "Afficher".
Pour afficher le résultat de la saisie, vous auriez peut-être envie de créer une nouvelle fenêtre et
d’afficher le résultat dans un champ "Libellé". Or, il existe en W-Langage des fonctions permettant
d’afficher un résultat dans des fenêtres système. Ces fonctions se nomment Info ou Erreur.
Pour notre exemple, nous utiliserons la fonction Info.
4 Saisissez le code suivant dans le code de clic du bouton [Afficher] :

INFO("Vous avez saisi " + SAI_SAISIE1)

53
La fonction Info affiche dans une boîte de dialogue le message passé en paramètre. Notre mes-
sage est construit à partir du texte "Vous avez saisi " et de la valeur du champ "SAI_SAISIE1". Le
signe "+" indique une opération dite de "concaténation" entre deux chaînes.
4 Enregistrez la fenêtre et testez-la (en cliquant sur l’icone puis sur ).
4 Saisissez une valeur dans le champ.
4 Cliquez sur le bouton [Afficher].
4 Validez.
Pour sortir du test et revenir sous l’éditeur de fenêtres, cliquez sur l’icone de la barre de titre.
Gérer la saisie d’un numérique pour faire un calcul

Dans la même fenêtre, nous allons maintenant :
• créer deux champs de saisie numériques.
• créer un bouton pour calculer et afficher la valeur T.T.C. du montant H.T. saisi.

• créer un bouton pour fermer la fenêtre.
Le résultat du calcul sera affiché dans le champ "TTC".
Nous allons séparer les deux parties de la fenêtre grâce à un séparateur.
4 Pour créer un séparateur :

2. Cliquez dans la fenêtre à la position où le séparateur doit être créé.
3. Dans l’assistant qui se lance, indiquez le sens du séparateur et son nom.
4. Validez par "OK".
4 Pour créer le champ de saisie :

3. Saisissez le nom du champ "SAI_PrixHT".
4. Sélectionnez le type numérique.
5. Saisissez le libellé "Prix HT".
6. Le format (masque de saisie et d’affichage) du champ est "99 999,99". Cela signifie que le
nombre peut comporter jusqu’à 5 chiffres pour la partie entière et 2 chiffres pour la partie déci-
male, le séparateur de milliers étant un espace.

54
4 Pour créer le champ dans lequel sera affiché le résultat :

1. Cliquez sur l’icone et de nouveau, glissez le champ dans la fenêtre.
2. Saisissez les informations du champ : faites un clic droit sur le champ et sélectionnez
l’option "Description".
• Indiquez le nom du champ "TTC".
• Modifiez le libellé par "Prix TTC".
• Sélectionnez le type numérique et le format "999 999,99".
• Ce champ n’a aucun code associé.
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".

Il existe également des champs de saisie "monétaires" et "monétaires + Euro" (voir “Les monétai-
res”, page 81).
4 Pour créer le bouton [Calcul TTC] :

1. Cliquez sur l’icone . Positionnez le champ et cliquez à nouveau.

2. Saisissez le nom du champ "BTN_CALCUL_TTC".
3. Saisissez le libellé "Calcul TTC".
4. Dans le code du bouton, saisissez le code suivant :
// On fige la TVA à 19.6% pour l’exemple
// cela aurait pu être une variable quelconque provenant
// d’une base de données
TTC = SAI_PRIXHT * 1.196
5. Fermez la fenêtre de code.
4 Pour créer le bouton [Ferme] :

1. Cliquez sur l’icone . Positionnez le champ et cliquez à nouveau.
2. Saisissez le nom du champ "BTN_Ferme".
3. Saisissez le libellé "Ferme".
4. Dans le code du bouton, saisissez le mot "Ferme".
4 Enregistrez la fenêtre et testez-la en cliquant sur .

Saisissez une valeur dans le champ, puis cliquez sur le bouton [Calcul TTC].

55
Mettre en forme la fenêtre

Tous les champs sont maintenant créés.
Pour avoir une présentation parfaite, il faut aligner les champs dans la fenêtre. WinDev propose

plusieurs options :
• le correcteur d’interface en temps réel.
• les règles.
• les alignements pré-définis.
• le correcteur d’interface.
Le correcteur d’interface en temps réel. Vous aurez pu remarquer qu’au fur et à mesure que vous
ajoutiez des champs, l’éditeur de fenêtres proposait des "guides" ou "barres" (magnétisme) permet-
tant d’aligner le nouveau champ avec les champs existants. La correction d’interface est donc éta-
blie en "temps réel".
Les règles permettent de positionner des marques de tabulation, de positionnement verticales ou

horizontales. Lors du déplacement des champs dans la fenêtre, les champs sont comme "attirés"
par ces marques. L’alignement est ainsi beaucoup plus facile. Pour activer les règles, il suffit de
sélectionner dans le menu de WinDev l’option "Affichage .. Règles" (ou la combinaison de touches
[CTRL]+[R]).
Les alignements pré-définis permettent d’agir sur la position, la taille ou encore l’espacement
d’une sélection de champs. Ces options sont disponibles dans le menu de WinDev, par l’option
"Champ .. Alignement".
Le correcteur d’interface réalise une étude complète de votre fenêtre et vous propose d’appliquer

56
des règles les plus courantes d’optimisation d’interface. Pour lancer le correcteur d’interface, utili-
sez l’icone de la barre d’outils d’alignement.
Création d’une fenêtre avec des images

Nous allons voir maintenant comment afficher des images dans une fenêtre.
Il est ainsi possible d’afficher les images d’un catalogue de produits, la photo d’une personne, ...
Ces images peuvent être au format BMP, JPEG, GIF, PCD, PSD, TGA, TIF, PNG, ICO (icones Windows),
EMF, WMF, CUR, OS2 (BMP sous OS/2), PCX.
Tous les modes sont supportés du mode "256 couleurs" au mode "couleurs vraies" (16 bits, 24
bits, ou 32 bits).
4 Créez une nouvelle fenêtre :

1. Cliquez sur l’icone . Double-cliquez sur "Fenêtre".
2. Sélectionnez "Vierge" et validez.
3. Donnez à la fenêtre le nom "Fenêtre_Image" et le titre "Fenêtre avec des images".
4 Pour afficher une image dans une fenêtre :

1. Créez un champ image en cliquant sur l’icone .

3. WinDev propose en standard un catalogue d’images contenant plusieurs centaines d’ima-
ges, de clipart, ... Pour utiliser une de ces images, cliquez sur le bouton "Catalogue".
Pour sélectionner un clipart, vous pouvez effectuer une recherche selon un mot-clé.
Dans la fenêtre de recherche :
• Saisissez un mot-clé (par exemple "Animaux")

57
• Cliquez sur le bouton "Rechercher". Les images se rapprochant le plus du mot-clé s'affichent
dans la fenêtre.
• Indiquez le format à générer (l’option "pas de conversion" conserve le format original de
l’image)
• Choisissez l’image que vous préférez en cliquant dessus (par exemple un poisson).
• Indiquez le nombre d’images souhaitées : cette option est utile pour les images de boutons.
Dans notre cas, nous utiliserons une seule image.
• Le nom de l’image sélectionnée s'affiche alors dans la fenêtre de description de l’image et le
fichier de l'image (au format voulu) est copié dans le répertoire du projet.
4. Il est également possible de sélectionner une image existante grâce au bouton .

5. Le mode d’affichage est 100%. Cela signifie que l’image sera affichée à sa taille réelle.
6. Validez. L’image s’affiche dans le champ.
Le mode d’affichage "Homothétique" permet de garder les proportions de l’image

Astuce
qui est affichée. Nous vous conseillons d’utiliser ce mode d’affichage pour des
images de type Photo, Carte, Schéma, ... Vous n’apprécieriez pas de voir votre
photo toute déformée !
Il existe d’autres modes d’affichage pour une image :

Mode d’affichage Exemple Description
100 % L’image s’affiche avec sa taille initiale. La taille du

champ peut être modifiée mais cela n’a aucune inci-
dence sur l’image.
Centré L’image est centrée dans le champ image. La taille du

champ peut être modifiée. Si l’image est plus petite (en
hauteur ou en largeur) que le champ, des bandes appa-
raissent sur les cotés.
Etiré L’image est déformée pour occuper toute la surface du
champ. La taille de l’image s’adapte à celle du champ.

58
Répété L’image dans sa taille initiale est répétée autant de fois

que possible pour occuper toute la surface du champ
image.
Homothétique L'image est agrandie proportionnellement pour être affi-

chée entièrement dans le champ image. L’image est
cadrée en haut à gauche.
Homothétique L'image est agrandie proportionnellement pour que le

étendu plus petit coté de l'image soit affiché entièrement dans
le champ image
Homothétique L’image est agrandie ou réduite (selon le cas) en conser-

centré vant les proportions hauteur/largeur pour occuper la
plus grande surface possible du champ. L’image n’est
pas déformée.
Homothétique L'image est agrandie proportionnellement pour que le

centré étendu plus petit coté de l'image soit affiché entièrement dans
le champ image, et centrée dans le champ image.
L'option "Affichage Haute Qualité" permet en mode homothétique d'améliorer la qualité de l'image
lorsque celle-ci est réduite par rapport à sa taille initiale.
WinDev gère des images avec un fond transparent. Dans ce cas, il faut :
• soit créer une image avec une couleur de fond "Magenta Clair" (couleur RVB : 255, 0, 255).
Le magenta est automatiquement considéré comme la couleur de transparence.
• soit créer une image dont la couleur du pixel (point) en haut à gauche est la couleur de réfé-
rence pour la transparence. Vous êtes maître de la couleur "transparente".
Attention !
La couleur "transparente" est analysée dans la totalité de l’image. Il peut donc y

avoir des zones transparentes en plein centre de l’image. Cela peut donner des
effets d’affichage, vérifiez les images !
Comment animer une image ?

Maintenant que vous savez comment afficher une image "statique", vous aimeriez dans certains
cas que l’image s’anime un peu. Par exemple, l’image peut s’afficher par la gauche, en tournant,
puis virer à droite, disparaître, réapparaître dans le coin en haut à droite, clignoter, se figer, ... en
somme, de l’animation !
Avec d’autres outils que WinDev, pour réaliser ce genre de traitement d’image, il faut acquérir des
librairies, des composants ActiveX, ...
Avec WinDev, rien n’est plus facile !
Voyons comment réaliser ceci.

59
Nous allons créer deux nouveaux champs image pour afficher les différents types d’animation pos-
sibles :
• Image animée automatiquement (au format GIF par exemple)
• Image animée par WinDev
4 Créez un champ image pour afficher une image au format GIF animée.
3. Cliquez sur le bouton "Catalogue".
4. Dans l’onglet "Goodies", sélectionnez l’option "Animations". Choisissez votre animation
parmi celles proposées (par exemple la terre qui tourne).
5. Validez.
6. Testez la fenêtre avec le bouton "GO". L’animation apparaît automatiquement, sans aucune
configuration.

4 Créez un champ image. Dans ce champ nous allons afficher une image composée de plusieurs
dessins. Cette image est fournie dans le répertoire "\Autoformation\Corriges\Faire Connais-
sance" du répertoire d’installation de WinDev.
3. Cliquez sur le bouton pour sélectionner le fichier "\Autoformation\Corriges\Faire Con-
naissance\ImprAnim.bmp". Validez.
4. Affichez le menu contextuel du champ Image (clic droit de souris) et sélectionnez l’option
"Adapter la taille". L’image apparaît dans sa totalité. Cette image est composée de 6 dessins en
largeur et de 4 dessins en hauteur.
4 1.
Nous allons copier le dernier champ image créé.
Sélectionnez le dernier champ image créé.
2. Utilisez la combinaison de touches [CTRL] + [C], puis [CTRL] + [V].
3. Cliquez dans la fenêtre à la nouvelle position du champ copié. Le champ Image est copié,
avec toutes ses caractéristiques.
5. Dans la fenêtre de description, cliquez sur l’onglet "Détail".
6. Sélectionnez l’option "Animé à la création", puis sur cliquez l’icone . La fenêtre de des-
cription des paramètres de l’animation s’affiche.
Vous pouvez saisir le nombre de dessins en largeur (6 dans notre exemple), en hauteur (4 dans
notre exemple), le type d’animation, le sens de l’animation, le nombre d’étapes ainsi que la

60
durée entre chaque étape de l’animation, ... Pour visualiser directement le résultat, cochez
l’option "Utiliser l’image du champ".
Exemple
Pour plus de détails sur l’utilisation de tous les paramètres proposés, consultez
l’exemple "WD Animated", livré en standard avec WinDev.
Les paramètres d’animation peuvent être décrits directement dans le champ,

mais peuvent aussi être modifiés par programme à l’aide des fonctions du W-
Astuce
Langage : AnimationChangeParamètre, AnimationChangeType et AnimationLit-

Paramètre. Consultez l’aide en ligne pour une utilisation approfondie de ces fonc-
tions (mots-clés : "Animation, Animer une image").
7. Testez la fenêtre avec le bouton "GO".
Utiliser une image en fond de fenêtre

L’image de fond peut être définie dans l’onglet "Image" de l’écran de description de la fenêtre. Les
paramètres d’affichage de l’image de fond de la fenêtre sont identiques à l’affichage d’une image

61
dans un champ.
4 1.
Pour configurer l’image de fond de la fenêtre :
Faites un clic droit sur le fond de la fenêtre et sélectionnez l’option "Description"
2. Dans la fenêtre de description, cliquez sur l’onglet "Image" puis sur l’icone (option
"Image de fond").
Le fond d’une fenêtre peut être aussi :

• une couleur.
Dans ce cas : la couleur de fond peut être définie dans l’onglet "Style" dans
la fenêtre de description de la fenêtre.
• défini par le gabarit associé à la fenêtre.
Notes
Le gabarit associé à la fenêtre peut être défini :

• soit lors de la création de la fenêtre.
• soit dans l’onglet "Style" dans la fenêtre de description de la fenêtre.
Nous traiterons plus loin dans ce cours l’utilisation des gabarits.
Création d’une fenêtre avec un menu

Voilà, nous venons de réaliser toutes les fenêtres de notre application. Il nous reste à créer la fenê-

tre principale. Cette fenêtre contiendra le menu organisant l’accès aux différentes fenêtres de
l’application.
WinDev permet de créer des menus déroulants.

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

1. Cliquez sur l’icone pour créer une nouvelle fenêtre.
2. Sélectionnez "Fenêtre"
3. Dans l’assistant qui s’affiche, sélectionnez "Vierge" et validez.
4. Donnez un nom et un titre à cette fenêtre. Cette fenêtre a pour nom "Menu" et pour titre
"Menu principal".
6. Sélectionnez l’option de menu "Fenêtres .. Menu Principal .. Ajouter le menu principal". Un
menu s’insère dans la fenêtre sous la barre de titre. Ce menu contient par défaut une option
qui se nomme "Menu".
Remarque : Chaque option de menu est saisie directement dans le menu.
Chaque option comporte une lettre d’appel. Cette lettre d’appel permet d’accéder directement
à l’option avec la combinaison de touches [Alt]+Lettre. Le caractère ’&’ doit alors précéder la
lettre d’appel (par exemple "&Fichier").
4 Pour créer une option menu et pour la modifier, il suffit d’utiliser le menu contextuel du menu
62
ou de l’option de menu. Pour afficher le menu contextuel d’une option de menu :

1. Sélectionnez le menu.
2. Cliquez avec le bouton droit de la souris.
Plusieurs choix sont possibles. Les principales options de gestion de menu sont :
• "Description de l’option" pour modifier le libellé de l’option et la lettre d’appel.
• "Code" pour saisir le code source correspondant au traitement à exécuter lors du clic sur
cette option.
• "Ajouter après" pour ajouter une option de menu après l’option en cours.
• "Insérer une option" pour insérer une option de menu avant l’option en cours.
• "Insérer un sous-menu" pour insérer dans l’option en cours un sous-menu (arborescence).
4 Réalisez le menu suivant :
Pour le menu "Fichier .. Quitter" :

1. Affichez la description de l’option "Menu" insérée par défaut, et changez le libellé en
"Fichie&r". Validez la fenêtre de description.
Notes
Le "&" permet de définir la lettre d’appel de l’option de menu.
2. Dans le menu contextuel de l’option "Fichier", sélectionnez l’option "Insérer un sous-menu"

et saisissez "Quitter".

63
Pour le menu "Fenêtres" :

1. Sélectionnez l’option "Fichier"
2. Dans le menu contextuel de l’option "Fichier", sélectionnez l’option "Ajouter après" et saisis-
sez "&Fenêtres".
3. Dans le menu contextuel de l’option "Fenêtre", sélectionnez "Insérer un sous-menu" et saisis-
sez "&Compteur".
4. Dans le menu contextuel de l’option "Compteur", sélectionnez "Ajouter après" et saisissez
"&Saisies".
5. Dans le menu contextuel de l’option "Saisies", sélectionnez "Ajouter après" et saisissez
"&Images".
Nous allons maintenant ajouter le raccourci [ALT F4] pour l’option "Quitter".
1. Sélectionnez l’option "Quitter".
2. Affichez la description de l’option (option "Description de l’option" du menu contextuel.
3. Dans la zone "Raccourcis clavier", sélectionnez "F4" et cochez la case "Alt".
4. Validez.
Lorsque toutes les options de menu sont saisies, vous pouvez tester la fenêtre. Ce test permet de
visualiser l’aspect final du menu.
Dans vos applications, nous vous conseillons de suivre le standard des menus
Windows. Veillez en particulier aux points suivants :
• Chaque option du menu principal doit proposer au moins une sous-option.

• La première lettre de chaque option doit être en majuscule, même si ce
n’est pas la lettre d’appel. La lettre d’appel est soulignée (utilisez le carac-
Astuce
tère "&").
• Si un choix de menu appelle une fenêtre de traitement, terminez le libellé
par trois points (…).
• L’option "Quitter" doit être la dernière sous-option de la première option de
la barre de menu (exemple : "Fichier .. Quitter").
• Si une option d’aide est présente, elle doit se trouver à la fin de la première
ligne de menu (l’option la plus à droite).
Associer un code aux options de menu

Chaque option terminale de menu doit comporter un traitement associé. Classiquement, ce traite-
ment ouvre une fenêtre, mais n’importe quel type de traitement peut être exécuté.
4 Sélectionnez une option du menu, effectuez un clic droit dessus et sélectionnez l’option "Code".

64
4 Dans l’éditeur de code, saisissez le code pour chaque option de menu.
Vous l’aurez deviné : la fonction Ouvre permet d’afficher une fenêtre pour effectuer une saisie. La
fonction Ferme quant à elle, ferme la fenêtre en cours (nous l’avons déjà vu).
Si la fenêtre contenant le menu est la première fenêtre affichée par l’application, la fermeture de la
fenêtre contenant le menu (par l’option "Fichier .. Quitter l’application" dans notre exemple) équi-
vaut à quitter l’application.
4 Enregistrez et testez la fenêtre.

4 Sélectionnez une des options de menu.
4 Cliquez sur l’option "Fichier .. Quitter l’application" pour quitter le programme.
Paramétrer un menu
Plusieurs fonctions du W-Langage permettent de modifier les caractéristiques d’un menu par
programmation :
• MenuMarque, MenuDémarque pour marquer (mettre une coche) ou démarquer une option.
• MenuSelectPlus, MenuSelectMoins pour sélectionner ou désélectionner une option.
• MenuEtat, MenuMarquage pour connaître l’état d’une option.
Pour plus d’informations sur ces fonctions, consultez l’aide en ligne (mots-clés : "Menu, Fonctions
W-Langage").

65
Insertion du menu "?" automatique

WinDev propose en standard un menu d’aide adapté à vos applications. Ce menu permettra aux
utilisateurs de vos applications d’accéder directement à plusieurs fonctionnalités.
4 1.
Pour intégrer le menu "?" dans votre application :
Sélectionnez l’option "Fenêtres .. Menu principal .. Ajouter le menu "?"". L’assistant de créa-
tion du menu utilitaire se lance.
2. Cliquez sur "Suivant".
3. Sélectionnez les options que votre application va proposer :

Pour cet exemple, nous allons conserverles options "Aide des fonctionnalités automatiques" et
"Suggestions et dysfonctionnements".
4. Répondez aux diverses questions et terminez l’assistant.
5. Testez la fenêtre, et son menu "?".
• L’option "? .. Aide des fonctionnalités automatiques" ouvre un fichier PDF contenant toutes
les fonctionnalités automatiques pouvant être disponibles dans une application WinDev. Ce
fichier PDF est également présent dans le répertoire "Aide" de WinDev et peut être modifié si
nécessaire.
• L’option "? .. Suggestions, dysfonctionnements" ouvre un assistant permettant à l’utilisateur
d’envoyer un email au développeur de l’application (c’est-à-dire vous-même) pour lui signaler
tous les dysfonctionnements rencontrés et lui faire des suggestions.
Lors de la création du menu "?", l’option "? .. Suggestions et dysfonctionnements"

a ajouté automatiquement dans votre application le composant "FeedBack". Ce
Notes
composant permet à l’utilisateur d’envoyer ses retours concernant une applica-

tion. Ces retours client sont automatiquement récupérés par le centre de Suivi de
Projets et le centre de Suivi de Qualité et des Evolutions.

66
Création du programme exécutable

Votre programme est maintenant écrit. Vous avez pu le tester au fur et à mesure que vous dévelop-
piez. Mais comment créer l’exécutable ?
4 Pour créer l’exécutable depuis l’environnement de WinDev :

1. Sélectionnez l’option "Atelier .. Générer l’exécutable Windows" ou sur l’icone .
Il faut définir quelle sera la fenêtre qui devra être affichée en premier (si ce n’est déjà fait).
Cette fenêtre est appelée "Première fenêtre du projet".
2. Ici, ce sera la fenêtre "Menu". Sélectionnez cette fenêtre parmi celles proposées puis cliquez
sur le bouton "OK" pour valider. L’assistant de création d’exécutable se lance.

3. Cliquez sur le bouton "Suivant".
Par défaut, le programme exécutable va être créé avec le même nom que le projet.
4. Cliquez sur le bouton pour sélectionner l’icone associé à l’exécutable.
5. Choisissez un icone parmi ceux proposés.
6. Par défaut, une image d’introduction (appelée "Splash Screen") est proposée. Vous pouvez
choisir une autre image (personnelle ou choisie dans le catalogue d’images livré avec WinDev).
Le bouton "Personnaliser" permet de personnaliser l’image sélectionnée. Vous pouvez par
exemple écrire le texte de votre choix sur l’image affichée au démarrage de l’application.
7. Cliquez ensuite sur le bouton "Terminer" pour lancer la création de l’exécutable. Les paramè-
tres par défaut seront automatiquement pris en compte.
8. Lorsque l’exécutable est généré, l’assistant vous propose de le lancer immédiatement.
Si vous désirez avoir plus d’informations sur les autres paramètres de création de l’exécutable, con-
sultez l’aide en ligne (mot-clé : "Exécutable").
Fini les compilations en ligne de commande, les problèmes de librairie à "linker", les paramètres de
compilation, ... quelques clics et c’est tout !
Bravo, félicitations ! Vous savez maintenant créer un programme exécutable autonome. Ce pro-
gramme fonctionne en mode 32 bits et est compatible avec toutes les versions de Windows : Win-
dows 95, 98, Millenium, XP, NT, 2000 et 2003 !

67
La diffusion de l’application
WinDev 10 simplifie la diffusion de vos applications.
Un assistant vous guide dans la création de la procédure d’installation (choix de menu "Atelier ..
Créer la procédure d’installation …").
Différents supports d’installation sont disponibles :
• Disquettes d’installation,
• CD-ROM,
• Exécutable auto-extractible (très pratique pour la mise en téléchargement de votre applica-
tion),
• Répertoire découpé à la taille de disquettes,
• Répertoire unique.
L’installation peut être au choix autonome ou avec mise à jour automatique.
Installation autonome
Ce mode d’installation est à réserver pour la diffusion d’applications s’exécutant sur des postes
indépendants (postes non reliés à un réseau, application monoposte, …).
Ce mode d’installation propose 3 modèles :
• installation standard : Ce modèle est proposé par défaut
• installation compacte : Ce modèle permet de créer un programme d’installation plus léger

(taille du programme d’installation moins importante) qu’une installation standard, tout en
conservant les possibilités de personnalisation.
• installation par package MSI : Ce modèle permet d’utiliser des fonctionnalités de l’installa-
teur intégré de Windows.
De plus, pour encore réduire la taille du programme d’installation, il est également possible de ne
pas diffuser le framework WinDev (les DLL WinDev nécessaires au fonctionnement de votre exécu-
table). Ce framework sera automatiquement téléchargé sur un site de PC SOFT lors de l’installation.
Dans ce cas, un accès Internet doit être disponible sur le poste d’installation.

68
Installation avec mise à jour automatique

Ce mode d’installation simplifie énormément la maintenance de votre application à travers un
réseau local ou distant (serveur WEB).
Une installation de référence est effectuée sur un serveur. A chaque lancement de l’application sur
les postes utilisateur, un mécanisme vérifie automatiquement que la version installée correspond à
la version de référence.
Si besoin, une mise à jour automatique de l’application est proposée.
De nombreuses options de mise à jour sont accessibles depuis le bouton "Avancé" de l’éditeur
d’installation.
L’administration automatique des utilisateurs connectés est proposée (réseau local uniquement).
Ce mode d’installation est vivement conseillé à partir de deux postes ou plus utilisant l‘application.
Ce mode d’installation est détaillé dans l’aide en ligne (mot-clé : "Installation d’une application").
La procédure d’installation propose la création automatique de raccourcis (groupe de programmes,
bureau).
Si la structure de la base de données a évolué depuis la dernière installation, la procédure d’instal-
lation réalise la modification automatique des fichiers de données déjà utilisés.
De nombreuses options sont paramétrables (licence, lisez-moi, désinstallation, outils
optionnels, …).
Toute la description de la procédure d’installation est automatiquement sauvegardée par WinDev

et sera reprise au prochain lancement de l’assistant.
Editeur d’installations : WDINST

Si vous souhaitez personnaliser encore plus la procédure d’installation de votre application, un
puissant éditeur est livré. Il est accessible par le choix de menu "Outils .. WDINST - Editeur d’instal-
lation".
Son fonctionnement est détaillé dans l’aide en ligne (mot-clé : "WDINST").

69
LEÇON 2.2. CONCEPTS W-LANGAGE

• Déclaration et type de variables.

• Les principales instructions du W-Langage.
• Utilisation des procédures.
Vous trouverez dans le répertoire "\Autoformation\Corriges\WD Decouverte" le projet

"WD Decouverte.WDP" contenant les illustrations de cette leçon.
l’option "? .. Guide d’auto-formation .. Découverte".

70
Introduction
Le W-Langage est un langage de 5ème génération. Vous apprécierez sa clarté et sa puissance au fil
du cours d’auto-formation.
Les différents types de variables

WinDev propose une grande variété de types de variables (booléen, entier, réel, monétaire, chaîne,
date, heure, durée, dateheure, variant, tableau, structure, ...).
La syntaxe à utiliser pour déclarer une variable est la suivante :
NomVariable EST UN(e) TypeVariable
Quelques exemples :
Indice est un entier
NomFournisseur est une chaîne
TablePrix est un tableau de 10 monétaires
I, J, K sont des entiers
Compteur est un entier = 120
B1 est un booléen = Faux
Pour plus d’informations sur ces types de variables et les autres types non cités, consultez l’aide en
ligne (mot-clé: "Types de données").
La déclaration des variables

Depuis le début de ce cours, nous avons utilisé sans le préciser des variables locales et des varia-
bles globales. Nous allons maintenant étudier la différence entre ces deux types de déclarations et
dans quel cas il faut les utiliser.
Variable locale
Une "variable locale" ne peut être utilisée que dans le traitement dans lequel elle a été déclarée.
Elle est "locale" au traitement.
Par défaut, une variable est locale. Cependant, pour rendre un programme plus "lisible pour la
maintenance", il est conseillé de faire précéder la déclaration des variables locales du mot-clé
"LOCAL". Exemple :
LOCAL
MaVariableLocale est une chaîne
Variable globale
Une "variable globale" peut être utilisée dans tous les traitements appelés par le traitement dans
lequel la variable est déclarée.

71
Pour qu’une variable soit "globale", il suffit de faire précéder la déclaration des variables globales
du mot-clé "GLOBAL". Exemple :
GLOBAL
MaVariableGlobale est une chaîne
Variable globale au projet

Lors de la déclaration d’une variable globale dans le traitement "Initialisation du projet", la variable
pourra être utilisée dans TOUS les traitements du projet et des éléments du projets (fenêtres,
états, ...).
Variable globale à une fenêtre

Lors de la déclaration d’une variable globale dans le traitement "Déclarations globales de la fenê-
tre", la variable pourra être utilisée dans TOUS les traitements de la fenêtre et des éléments de la
fenêtre.
Variable d’une fenêtre accessible depuis d’autres fenêtres
Afin qu’une variable globale d’une fenêtre "A" puisse être utilisée dans les autres fenêtres "X"
ouvertes par la fenêtre "A", écrivez dans le traitement "Déclarations globales de la fenêtre" de tou-
tes les fenêtres "X" :
EXTERNE NomDeLaVariable

Dans une application importante, pensez à normaliser le nom des variables loca-
les et des variables globales, afin de les différencier plus facilement des autres
Astuce
variables ou des noms des champs, des autres objets en général.

Par exemple, faites commencer le nom des variables locales par la lettre "l".
Par exemple, faites commencer le nom des variables globales par la lettre "g".
La plupart des développeurs est tentée de déclarer toutes ses variables en "glo-
bal" dans un projet. Ce type de programmation est en effet "facile". Les variables
étant toutes globales, elles sont alors manipulables depuis n’importe quel traite-
ment.
Attention !
Mais ce type de programmation est souvent la cause d’écrasement de variables

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

72
Instructions du W-Langage
Il existe des centaines d’instructions W-Langage, nous détaillerons ici les instructions de conditions
et les instructions de boucle.
Les instructions conditionnelles

Le W-Langage permet de gérer des instructions conditionnelles du type :
• SI, SINON, FIN pour effectuer un test sur une condition.
• SELON, CAS, FIN pour exécuter une ou plusieurs actions selon les différents résultats d’un
test sur une condition.
Quelques exemples
SI Maximum > Hasard(1, 999) ALORS

Info("Bravo, vous avez gagné ! ")
SINON
Info("Dommage, vous avez perdu ! ")
FIN
SELON Jour
CAS "Lundi"
// Premier jour de la semaine

CAS "Mercredi"
// Troisième jour de la semaine
CAS "Vendredi"
// Cinquième jour de la semaine
CAS "Samedi", "Dimanche"
// C’est le week-end
AUTRES CAS
// c’est un autre jour
FIN
Les instructions de boucle

Le W-Langage propose plusieurs possibilités pour gérer des boucles :
• POUR, FIN pour un nombre d’itérations déterminé.
• TANTQUE, FIN pour un nombre d’itérations indéterminé et dont la condition de sortie de la
boucle est testée au début de la boucle.
• BOUCLE, FIN pour un nombre d’itérations indéterminé et dont la condition de sortie de la
boucle est testée dans la boucle. L’instruction SORTIR permet de sortir de cette boucle.
Quelques exemples
Ind est un entier
POUR Ind = 1 à 100
Cpt = Cpt + 1
FIN

73
Ind est un entier = 0

BOUCLE
Ind ++
SI Ind>Maximum ALORS SORTIR
FIN
Ind est un entier = 0

TANTQUE Ind<Maximum
Ind ++
FIN
Il est pratique d’utiliser la fonction Multitâche dans une boucle longue, afin de
Astuce
rendre la main aux autres programmes ou à Windows pendant que la boucle

s’exécute.
Pour tester les différents types de boucles disponibles :

4 Ouvrez le projet "WD Découverte.WDP" (option "Fichier .. Ouvrir un projet"). Ce projet se trouve
dans le sous-répertoire "AutoFormation\Corriges\WD Découverte" du répertoire d’installation

de WinDev 10.
4 Ouvrez la fenêtre "Procedure_boucle.wdw" (option "Fichier .. Ouvrir").
4 Testez cette fenêtre puis consultez le code des différents boutons.
Les commentaires
Pour saisir des commentaires dans le code, il suffit de commencer le code par // (deux caractères
/).
Exemple :
// Ceci est une ligne de commentaire
Vous pouvez mettre en commentaires plusieurs lignes de code en sélectionnant

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

Vous réalisez l’opération inverse (enlever les commentaires) en sélectionnant au
clavier (ou à la souris) les lignes à enlever des commentaires puis en appuyant sur
les touches [Ctrl] [Shift] / (du pavé numérique).
Le mot-clé MoiMême
MoiMême est un mot-clé qui retourne le nom du champ en cours. MoiMême permet de rendre un
code local (traitement d’un champ, ...) ou global (procédure globale, classe, ...) indépendant du
champ en cours.
MoiMême..Libellé = "Nouveau libellé"

74
Les procédures et les fonctions
Définition
Lorsqu’un traitement est appelé plusieurs fois dans un projet ou dans une fenêtre, il est souvent
intéressant de créer une procédure contenant ce traitement. Il suffira alors d‘appeler la procédure
ou la fonction à chaque fois que cela sera nécessaire.
WinDev permet de gérer simplement des procédures et des fonctions.
En temps normal, une fonction renvoie un résultat alors qu’une procédure sert à exécuter un traite-
ment spécifique. Sous WinDev, il n’y a pas de différence entre une procédure et une fonction. C’est
pourquoi dans la suite de ce cours, nous utiliserons uniquement le terme "procédure".
Vous avez la possibilité de créer des procédures "locales" et des procédures "globales".
Procédure locale
Une procédure "locale" est liée à une fenêtre et uniquement à cette fenêtre.
Une procédure, lorsqu’elle est locale, peut être utilisée uniquement dans les traitements de la fenê-
tre et des champs de la fenêtre dans laquelle elle a été déclarée. Elle fait partie de la fenêtre.
Procédure globale et Collection de procédures

Les procédures "globales" sont contenues dans des "collections de procédures". Chaque "collection
de procédures" est un fichier qui contient toutes les procédures globales qui lui sont associées. Ce
fichier est présent le plus souvent dans le répertoire du projet et possède l’extension ".WDG".
Chaque projet contient au moins une collection de procédures. Cette collection est créée par
défaut lors de la création du projet et a pour nom "Procédures globales de <nom_projet>".
Vous pouvez créer autant de collections de procédures que vous le désirez dans un projet.
Une collection de procédures permet de :
• partager des procédures globales entre plusieurs développeurs, pour un même projet.
• partager des procédures globales entre plusieurs projets.
Comment choisir si une procédure est globale ou locale ?

Pour choisir si une procédure doit être globale ou locale, posez-vous la question suivante : "La pro-
cédure va-t-elle être utilisée uniquement dans cette fenêtre, ou peut-elle être appelée depuis une
autre fenêtre ?"
• Si la procédure est appelée "uniquement depuis cette fenêtre", la procédure peut être
"locale".
• Si la procédure peut être appelée "depuis plusieurs fenêtres", la procédure doit être "glo-
bale".
Utilisation des procédures

4 Ouvrez le projet "WD Découverte.WDP" (option "Fichier .. Ouvrir un projet"). Ce projet se trouve
dans le sous-répertoire "AutoFormation\Corriges\WD Découverte" du répertoire d’installation
de WinDev 10.
4 Ouvrez la fenêtre "Procedure_Boucle.wdw" (option "Fichier .. Ouvrir").
75
4 Consultez la liste des différentes procédures (accessibles depuis le Kouglof). Observez le mode
de déclaration de ces procédures. Vous pouvez également tester la fenêtre pour visualiser leur
traitement.
A propos du passage des paramètres

Dans le projet "WD Découverte", vous avez pu voir qu’une procédure pouvait gérer des paramètres.
Les paramètres peuvent être obligatoires ou optionnels.
Les paramètres "obligatoires" sont toujours définis avant les paramètres "optionnels". La déclara-
tion d’un paramètre "optionnel" est effectuée en affectant une valeur par défaut lors de la déclara-
tion du paramètre.
Exemple :
PROCEDURE MaProcédure (Param1, ParamOption = "Valeur par défaut")
Une fenêtre peut également renvoyer une valeur au traitement qui l’a appelée. Pour plus de détails,
consultez l’aide en ligne sur la propriété ValeurRenvoyée.
Appel d’une procédure

Pour appeler une procédure dans un traitement, il suffit d’écrire son nom dans l’éditeur de code et
si nécessaire d’indiquer des paramètres.
WinDev sait bien évidemment gérer les appels de procédures imbriquées.

Dans l’éditeur de code, lorsque vous êtes positionné sur un nom de procédure,
Astuce
l’appui sur la touche de fonction [F2] permet de visualiser le code de cette procé-
dure. L’appui simultané sur les touches [CTRL]+[F2] permet de revenir dans le
code précédent sur le nom de la procédure.
Création d’une procédure (ou fonction)

Une procédure peut être créée directement depuis l’éditeur principal de WinDev. Il suffit d’utiliser le
volet "Code" en bas à gauche de l’éditeur.
4 Sélectionnez le volet "Code" (si nécessaire affichez ce volet par l’option "Affichage .. Barre
d’outils .. Code".
4 Sélectionnez "Procédures globales" ou "Procédures locales".
4 Cliquez avec le bouton droit dans la liste et sélectionnez l’option "Nouvelle procédure".

76
4 Saisissez le nom de la procédure et validez. Ensuite, saisissez le code de la procédure.
Quand utiliser les procédures ?

• Lorsqu’un traitement est utilisé plusieurs fois dans une même fenêtre, il est
conseillé d’utiliser une procédure locale à la fenêtre qui contiendra ce traite-
Astuce
ment.
• Lorsqu’un traitement est utilisé plusieurs fois dans un ensemble de fenêtres, il
est conseillé d’utiliser une procédure globale au projet qui contiendra ce traite-
ment.

77
LEÇON 2.3. CHAÎNES ET NUMÉRIQUES

• Manipulation de chaînes de caractères.

• Manipulation des numériques.
• Manipulation des monétaires.
Durée estimée : 20mn


78
Introduction
Si vous avez déjà développé avec ce bon vieux Basic des années 80, la manipulation des chaînes
de caractères s’effectuait avec les fonctions standard comme LEFT, RIGHT ...
Dans WinDev, la fonction ExtraitChaine complète ces fonctions.
Il existe également les fonctions Gauche, Droite, Milieu, Position qui vous permettront de traduire
de vieux algorithmes en W-Langage.
De même, pour faire plaisir aux développeurs qui aiment manipuler les pointeurs ou les octets,
vous avez la possibilité d’utiliser dans WinDev les opérateurs [[ ]].
La fenêtre "Manipulation chaînes" présente l’utilisation de ces fonctions. Elle illustre les différentes
manipulations que nous expliquerons dans cette leçon :
4 Ouvrez si nécessaire le projet "WD Découverte.WDP" (option "Fichier .. Ouvrir le projet"). Ce pro-
jet se trouve dans le sous-répertoire "AutoFormation\Corriges\WD Découverte" du répertoire
d’installation de WinDev 10.
4 Ouvrez la fenêtre "Manipulation chaînes.WDW" (option "Fichier .. Ouvrir").
4 Testez la fenêtre.
Nous allons donner ici les principales manipulations possibles sur les chaînes de caractères, les
valeurs numériques, les dates et les heures.
Toutes les fonctions ne sont pas citées. Pour plus de détails, consultez l’aide en ligne (mot-clé :
"Chaîne de caractères, Manipuler une chaîne (W-Langage)").

79
Manipuler une chaîne

Un champ de type texte (par exemple un libellé) peut être initialisé :
• soit directement avec la chaîne :
TEXT1 = "WinDev est un outil formidable"
• soit avec une variable de type chaîne :
ch est une chaîne
ch = "J’apprends à travailler avec WinDev"
TEXT2 = ch
Une chaîne peut être construite à partir de plusieurs autres chaînes. On parle alors de concaténa-
tion de chaînes.
Pour concaténer deux chaînes, il suffit d'utiliser l'opérateur "+".
// Nous utilisons ici la fonction Info pour que le résultat
// s’affiche à l’écran
Info(TEXT2 + TEXT1)
L'extraction d'une partie d'une chaîne peut être réalisée avec :

• les opérateurs [[ et ]] (attention il ne faut pas d'espace entre les crochets [[ et ]]).
Info(TEXT1[[1 à 6]]) //affiche "WinDev"

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

Info(Milieu(TEXT2,30)) //affiche "WinDev "
• la fonction Gauche, qui retourne la partie gauche d'une chaîne :

Info(Gauche(TEXT2,10)) // affiche "J'apprends"
• la fonction Droite, qui retourne la partie droite d'une chaîne :

Info(Droite(TEXT1,10)) //affiche "formidable"
La taille d'une chaîne peut être connue avec la fonction Taille :

Info(Taille(TEXT2)) //affiche 38
Une chaîne peut être transformée en majuscules avec la fonction Majuscule ou en minuscules
avec la fonction Minuscule :
Info(Majuscule(TEXT2))
Info(Minuscule(TEXT2))
Une chaîne peut être recherchée dans une autre avec la fonction Position :
ChaineRecherche est une chaîne = "WinDev"
Pos est un entier
Pos = Position(TEXT2, ChaineRecherche)

80
SI Pos=0 ALORS
Info(ChaineRecherche + " non trouvé dans le texte 2")
SINON
Info(ChaineRecherche + " trouvé dans texte 2")
FIN
Vous pouvez également effectuer une recherche de position d’une chaîne de

caractères dans une autre sans tenir compte de la casse. Il suffit d’indiquer à la
Astuce
fonction Position le paramètre SansCasse.

Exemple :
Pos = Position(TEXT2, ChaineRecherche, 1, SansCasse)
Manipuler un numérique
4 Ouvrez la fenêtre "Calculs Numériques.WDW". Cliquez par exemple sur son nom dans le volet
WinDev (onglet "Projet", option "Fenêtres").
4 Testez la fenêtre. Cette fenêtre présente un aperçu des manipulations sur les "numériques".
Un champ de type numérique peut être initialisé :
• soit directement avec la valeur numérique :

NUM1 = 3.14
• soit avec une variable numérique :

ent1 est un entier
ent1 = 1234
SAISIE1 = ent1
Il est possible de concaténer une chaîne et un numérique avec l'opérateur "+" :

Info("La valeur entière est " + SAISIE1, ...
"La valeur réelle est "+NUM1)
Si vous exécutez le code suivant :

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

Si vous souhaitez afficher le résultat du calcul, il faut utiliser le code suivant :
Info("Un calcul : " + (1 + 2))
La boîte de dialogue affichera "Un calcul : 3".
La partie entière d'un nombre est connue par la fonction PartieEntiere, la partie décimale par la
fonction PartieDecimale :
Info("Partie entière de "+NUM1+" : "+PartieEntiere(NUM1), ...
"Partie décimale de "+NUM1+" : "+PartieDecimale(NUM1))

81
La valeur absolue d'un nombre est retournée par la fonction Abs :

Info("Valeur absolue de "+SAISIE2+" : "+Abs(SAISIE2))
La valeur arrondie d'un nombre est retournée par la fonction Arrondi :

Info("Arrondi de "+SAISIE2 +" : " + Arrondi(SAISIE2,1))
La fonction Racine permet de calculer la racine Nième d'un nombre :

NUMRAC = Racine(NUMPUIS, 2)
La fonction Puissance permet d'élever un nombre à la puissance N :

NUMPUIS = Puissance(NUMRAC, 2)
A propos du type des champs numériques

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

SAISIE1 = Val1
Val1 = SAISIE1 //récupération du champ
Les monétaires
4 Ouvrez la fenêtre "Réels_Monetaires.wdw". Cliquez par exemple sur son nom dans le volet Win-
Dev (onglet "Projet", option "Fenêtres").
Cette fenêtre présente un aperçu des manipulations possibles sur les "Monétaires".
Le type "Monétaire" est un réel codé sur 10 octets. Il permet de donner la solution à deux problè-
mes non résolus par les réels :
• avoir plus de 15 chiffres significatifs (les réels doubles gèrent 15 chiffres significatifs maximum),
le type "Monétaire" gère 23 chiffres significatifs.
• éviter une erreur induite par le codage binaire des réels :
• Un réel gère jusqu'à 15 chiffres significatifs. Or, en réalité, le codage binaire des réels ne per-
met pas de coder tous les réels de 15 chiffres significatifs.
• Le type "Monétaire" a un codage différent des réels qui n'induit pas d'erreur d'arrondi. En
effet, le code suivant donne un résultat faux :
// Avec une variable de type Réel, le calcul est faux
x est un Réel
x = 18.6 - 8.6 - 10
Erreur ("18.6-8.6-10="+x)

82
Par contre avec le programme suivant, le calcul est correct :

x est un Monétaire
x = 18.6-8.6-10
Info(x)
Pour effectuer des divisions sur des monétaires, il est conseillé de passer par des variables inter-
médiaires de type "Monétaire".
x, y sont des Monétaires
x = 12345678901234567.123456
y = 12345678901234567.123456
x = x/y
Info ("21345678901234567.123456", ...
"/","12345678901234567.123456","= "+x)
Mélange de chaînes et de numériques

Les numériques et les chaînes font bon ménage. WinDev est très souple dans les affectations de
variables. Ainsi il est possible d'affecter une chaîne de chiffres dans une variable numérique et
inversement.
Par exemple :
i est un entier
c est une chaîne
i = 123
c = i //la variable c contient la chaîne "123"
c = "456"
i = c //la variable i contient la valeur 456
Si vous voulez transformer un nombre en une chaîne de caractères en respectant un format bien
précis, il suffit d’utiliser la fonction NumériqueVersChaine.
4 Ouvrez la fenêtre "FenetreVersChaine.wdw". Cliquez par exemple sur son nom dans le volet
WinDev (onglet "Projet", option "Fenêtres").
A chaque fois que vous devez utiliser la fonction NumeriqueVersChaine et que vous ne savez
pas exactement quels paramètres utiliser, vous pouvez exécuter cette fenêtre : elle vous don-
nera la syntaxe à utiliser en fonction du résultat souhaité.
Notes
La fonction "inverse" de NumeriqueVersChaîne, est la fonction Val. Cette fonction

permet de convertir une chaîne en un numérique.

83
LEÇON 2.4. DATES ET HEURES

• Manipulation des fonctions Date.

• Manipulation des fonctions Heure.


84
Présentation
Une fois l’an 2000 passé, tout le monde s’est dit : "Ouf ! On n’a plus à se soucier du format des
dates !". Effectivement, on peut s’estimer tranquille ... pour quelques centaines d’années !
Cependant, il est toujours bon de savoir gérer correctement le format des dates et des heures dans
vos programmes.
Pour gérer simplement les dates et les heures dans vos applications, WinDev met à votre disposi-
tion :
• un champ de saisie de type Date ou Heure. Avec ce champ, plus aucun problème pour saisir une
date ou une heure valide.
• des variables de type Date, Heure, DateHeure et Durée. Ces variables simplifient la manipulation
des dates et des heures par programmation et permettent de multiples calculs.
Manipuler les dates et les heures
4 Ouvrez si nécessaire le projet "WD Découverte.WDP" (option "Fichier .. Ouvrir le projet"). Ce pro-
jet se trouve dans le sous-répertoire "AutoFormation\Corriges\WD Découverte" du répertoire
4 Ouvrez la fenêtre "DATEHEURE.WDW". Cette fenêtre illustre les explications données dans la
suite de cette leçon.
Les dates et les heures sont des chaînes qui ont un format prédéfini.
Dans un champ de type "Date" ou de type "Heure", il faut distinguer le masque de saisie de la
valeur retournée (mémorisée) :
• Le masque de saisie est le format avec lequel la date et l’heure seront affichées.
• La valeur retournée est la valeur retournée par le champ vers le programme.

85
Par exemple, pour un champ de type "Date" :

• le masque de saisie sera "JJ/MM/AAAA"
• la valeur retournée sera par défaut "AAAAMMJJ" (Exemple : "23/04/2002" retournera
"20020423").
Il existe la possibilité de choisir une valeur de retour de type "Date système". Dans ce cas, le format
de la valeur de retour sera celui défini dans les "Paramètres régionaux du panneau de configura-
tion de Windows" de la machine en cours d’exécution.
4 Si"AAAAMMJJ"
le masque de saisie d'un champ date est "JJ/MM/AA" et la valeur retournée est
:
DATEJ="19981225" //affiche la date sous la forme "25/12/98"
DATEJ="981225" //affiche la date sous une forme incorrecte
4 Si"AAMMJJ"
le masque de saisie d'un champ date est "MM/JJ/AAAA" et la valeur retournée est
:
DATEJ="981225" //affiche la date sous la forme "12/25/1998"
DATEJ="19981225" //affiche la date sous une forme incorrecte
Il faut donc faire attention au format de la valeur retournée dans un champ de type date ou heure.
Les fonctions du W-Langage qui manipulent :
• des dates utilisent le format "AAAAMMJJ".

• des heures utilisent le format "HHMMSSCC" (certaines utilisent le format
"HHMMSSCCMMM", pour la gestion des millisecondes).
Les dates
Quel jour sommes-nous?
Pour connaître la date du jour, il suffit d'utiliser la fonction DateDuJour (ou DateSys). La fonction
DateDuJour retourne la date système de votre ordinateur sous la forme d'une chaîne de caractères
au format "AAAAMMJJ".
Exemple :
Info("Nous sommes le " + DateDuJour()) // ou DateSys()
Comme vous pouvez le constater, la date affichée est au format "AAAAMMJJ".

Nous voulons maintenant afficher la date sous un format plus explicite. Il suffit d'utiliser la fonction
DateVersChaine :
Info("Nous sommes le " + DateVersChaine(DateDuJour()))

86
La fonction DateVersChaine transforme une chaîne au format "AAAAMMJJ" en chaîne au format

"JJ/MM/AAAA" (à la norme française et beaucoup plus lisible !).
Quel jour sommes-nous, mais avec le jour et le mois en lettres ?

On complique un peu les choses ? Pas du tout ! Avec WinDev, rien de plus facile !
4 Pour afficher la date en toute lettre, il faut utiliser les fonctions EntierVersJourEnLettre et
EntierVersMoisEnLettre :
Date, DateJ sont des Chaînes
DateJ = DateDuJour()
Date = EntierVersJourEnLettre(DateVersEntier(DateJ))+ " " + ...
DateJ[[7 à]] + " " + ...
EntierVersMoisEnLettre(DateVersEntier(DateJ))
Info("Nous sommes le "+Date)
Les fonctions EntierVersJourEnLettre et EntierVersMoisEnLettre donnent en toutes lettres le jour et

le mois correspondant à la date passée en paramètre.
Les fonctions EntierVersJourEnLettre et EntierVersMoisEnLettre attendent un entier. Il faut donc
utiliser la fonction DateVersEntier pour convertir une date "chaîne" en un entier.
Quel est le nombre de jours entre 2 dates ?

Vous voulez savoir combien de jours se sont écoulés entre deux dates ? C’est très simple : il suffit
d’utiliser la fonction DateDifférence :
NombreJour est un entier
NombreJour = DateDifférence(DateSys(), "20100101")
Info("Le nombre de jour entre", "le " + ...
DateVersChaine(DateSys()) +" et le 01/01/2010 est " + ...
NombreJour)
Astuce
Selon le même principe, on peut calculer l'âge d'une personne. Il suffit de diviser
le nombre de jours obtenus par 365.

87
Quel est le jour de la semaine d’une date donnée ?

Toujours aussi simplement, vous pouvez connaître le jour de n'importe quelle date avec la fonction
EntierVersJourEnLettre :
J est une chaîne
J = EntierVersJourEnLettre(DateVersEntier("17890714"))
Info("Le 14 juillet 1789 était un " + J)
Les heures
Quelle heure est-il ?
Pour connaître l'heure, il suffit d'utiliser la fonction Maintenant (ou HeureSys). La fonction Mainte-
nant retourne l'heure actuelle de votre système sous la forme d'une chaîne de caractères au format
"HHMMSSCC" :
Info("Il est " + HeureSys()) // ou Maintenant()
4 Vous souhaitez afficher l'heure au format standard "HH:MM:SS:CC" ? Le code devient alors :
Info("Il est " + HeureVersChaine(HeureSys()))
HeureVersChaine transforme une heure au format "HHMMSSCC" en une chaîne au format

"HH:MM:SS:CC".
4 Pour ne pas afficher les centièmes de seconde, le code est :

Heure est une chaîne = Gauche(HeureVersChaine(HeureSys()),8)
Info("Il est "+Heure)
La fonction Gauche retourne les n premiers caractères d'une chaîne (8 dans notre exemple).
Combien de temps s'est écoulé entre deux heures ?

Il est 17h25. Combien de temps s'est écoulé depuis 12h15 ? Le code est le suivant :
// Affiche le temps écoulé depuis 12h15
Diff est un entier = HeureDifférence("1215", HeureSys())
Signe_temps est une chaîne
Résultat est une chaîne = EntierVersHeure(Abs(Diff))
SI Diff < 0 ALORS Signe_temps = "-"

Info("Temps écoulé : " + Signe_Temps + Gauche(Résultat, 2) + ...
"heures"+ Milieu(Résultat, 3, 2) + "minutes"+...
Milieu(Résultat, 5, 2) + "secondes"+...
Milieu(Résultat, 7, 2) + "centièmes de seconde")
La fonction EntierVersHeure transforme un entier (qui correspond au nombre de centièmes de

secondes écoulées depuis minuit (ou 00h00)) vers une heure sous la forme "HHMMSSCC".

88
La fonction HeureVersEntier effectue l’opération inverse.

Attention !
• Ne mettez pas de ":" dans l'heure passée en paramètre à la fonction HeureVer-

sEntier, cela fausserait le résultat.
• Pour calculer des durées de plus de 24 heures, utilisez les types Date, Heure, ....
Variable de type Date, Heure, DateHeure, Durée

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

Le W-Langage possède de très nombreuses fonctions pour gérer les dates et les heures et effec-
tuer différents calculs.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Date, Fonctions W-Langage").

PARTIE 3
Fenêtres et champs
91
LEÇON 3.1. INTRODUCTION

• L’environnement général de WinDev.
Partie 3 : Fenêtres et champs d’une fenêtre

92
Présentation
Au tout début de ce guide, vous avez découvert l’environnement de WinDev. Vous avez peut être
constaté que cet environnement était constitué de plusieurs éditeurs (éditeur de fenêtres, d’analy-
ses, d’états, ...).
Pour chaque éditeur, des barres de menus, des barres d’outils, des volets (flottants ou fixés) sont
disponibles.
1. La barre de menu
2. Les barres d’outils
3. Documents ouverts
4. Volets fixés à droite (explorateur de projet dans cet exemple)
5. Volets fixés en bas (volet "Code" affiché dans cet exemple)

93
Les barres d’outils

Les barres d’outils proposent des icones permettant d’accéder rapidement aux principales
fonctionnalités de WinDev. Pour faire apparaître ou disparaître une barre d’outils, il suffit de sélec-
tionner son nom dans le menu contextuel des barres d’outils (clic droit dans la zone des barres
d’outils).
WinDev propose :
• une barre d’outils standard. Cette barre d’outils est commune à tous les éditeurs.
• des barres d’outils spécifiques à chacun des éditeurs de WinDev.
Les bulles d’aide permettent d’identifier l’action de chaque icone des barres d’outils.
Ces barres d’outils sont déplaçables et personnalisables.
4 1.
Pour déplacer une barre d’outils :
Sélectionnez la barre d'outils :
•Si la barre d’outils est ancrée, cliquez sur l'extrémité gauche de la barre.
•Si la barre d’outils est flottante, cliquez sur la barre de titre.
2. Maintenez le bouton gauche de la souris enfoncé pendant le déplacement : une ombre per-

met de visualiser la position finale de la barre d’outils.
Remarque : Pour empêcher l’effet d'attraction des bords de l’éditeur, maintenez la touche [Ctrl]
enfoncée pendant le déplacement.
Le contenu de chaque barre d'outils est entièrement personnalisable.
4 1.
Pour ajouter un icone dans une barre d'outils :
Ouvrez la fenêtre de personnalisation des barres d'outils (option "Affichage .. Barre d’outils ..
Personnaliser les barres d’outils").
2. Effectuez un "glisser/déplacer" ("Drag and Drop") d’un icone de la fenêtre de personnalisa-
tion vers l'emplacement désiré dans la barre d'outils.
4 1.
Pour supprimer un icone d'une barre d'outils :
Ouvrez la fenêtre de personnalisation des barres d'outils (option "Affichage .. Barre d’outils ..
Personnaliser les barres d’outils").
2. Effectuez un "glisser/déplacer" ("Drag and Drop") de l'icone de la barre d'outils vers la fenê-
tre de personnalisation.
Les volets
WinDev propose différents volets affichables à tout moment. Ces volets peuvent être affichés ou
non, regroupés dans l’ordre de votre choix. Vous pouvez ainsi définir la configuration qui corres-
pond le mieux à votre environnement et la rappeler à tout moment.
4 1.
Pour afficher des volets :
Sélectionnez l’option "Affichage .. Barres d’outils .. "
2. Sélectionnez le volet à afficher ou à rendre invisible (une coche est présente devant le nom
des volets actuellement affichés sous l’éditeur).

94
Chaque volet présent dans l’interface peut être :

• flottant : le volet peut être redimensionné et déplacé indépendamment. Les volets flottants sont
par exemple utiles si vous utilisez deux écrans.
• regroupé avec d’autres volets : il suffit de déplacer un volet vers un autre volet. Lorsque l’icone
représentant des onglets apparaît ( ), il suffit de positionner le volet sur cette icone et de
relâcher la souris.
• ancré à un des bords de l’interface : il suffit de déplacer un volet vers un des bords de l’interface.
Lorsque l’icone représentant un des bords de l’interface apparaît ( ), il suffit de positionner
le volet sur cette icone et de relâcher la souris.
• invisible : Si le volet est flottant, il suffit de cliquer sur la croix (x) de fermeture. Si le volet est
regroupé, il suffit de faire un clic droit sur l’onglet correspondant et de sélectionner "Fermer
l’onglet".
La configuration de vos volets vous convient ? Vous voulez la mémoriser ? Rien de plus simple :
vous pouvez sauvegarder jusqu’à 4 configurations grâce aux touches CTRL ALT 1, CTRL ALT 2, ... Et
pour afficher la configuration voulue, il suffit d’utiliser la touche ALT suivie du numéro de configura-
tion voulue.
Barre des documents ouverts

Cette partie affiche un bouton pour chaque document ouvert sous l'éditeur. Pour afficher l'élément,
il suffit de cliquer sur le bouton correspondant.
La combinaison de touches [CTRL]+[W] permet de faire apparaître ou disparaître

Astuce
les volets regroupés et ancrés.

Il est ainsi possible d’avoir rapidement un espace de travail plus étendu.

95
LEÇON 3.2. MANIPULATIONS DES CHAMPS

• Sélection, déplacement, suppression de champs dans l’éditeur de fenêtres.

• Superposition de champs et visualisation en 3 dimensions.
• Modification des caractéristiques d’un champ.
Vous trouverez dans le répertoire "\Autoformation\Corriges\Fenêtres et champs" le

projet "Fenêtres et champs.WDP" contenant les illustrations de cette leçon.
l’option "? .. Fenêtres et champs".

96
Introduction
Nous commencerons par exécuter un projet exemple. Nous détaillerons son fonctionnement au fur
et à mesure des leçons suivantes et nous verrons ensemble comment réaliser les différents traite-
ments qui le composent.
4 Dans le menu de WinDev, sélectionnez l’option "? .. Guide d’Auto
champs". Vous pouvez parcourir les différentes options du menu.
formation .. Fenêtres et
Dans cette partie, vous découvrirez :

• Comment manipuler et créer des fenêtres dans l’éditeur de WinDev.
• Quels sont les différents types de champs.
• Comment manipuler les champs.
4 1.
Pour cette partie, nous allons ouvrir un projet existant.
Sélectionnez l’option "Fichier .. Ouvrir un projet".
2. Sélectionnez le sous-répertoire "AutoFormation\Corriges\Fenêtres et Champs" du répertoire
3. Sélectionnez le fichier "Fenêtres et Champs.WDP".
Le projet se charge.
Ce chapitre présente les manipulations les plus fréquentes effectuées sur les champs d’une fenê-
tre. Ces manipulations peuvent également être effectuées dans l’éditeur d’états.
4 Ouvrez la fenêtre "Manip.WDW" présente dans le répertoire du projet. Pour celà, utilisez le rac-
courci CTRL + E et saisissez "Manip". Sélectionnez la fenêtre et ouvrez-là.
Cette fenêtre va vous permettre d'apprendre les principales manipulations à effectuer.
Sélectionner plusieurs champs

Pour sélectionner plusieurs champs vous pouvez utiliser une des deux méthodes suivantes :
Méthode 1. Cliquez avec la souris à côté d'un des champs à sélectionner, maintenez le bouton
de la souris enfoncé et déplacez la souris pour sélectionner les autres champs. Lorsque vous
relâchez le bouton de la souris, les champs sélectionnés apparaissent avec des poignées blan-
ches.
Méthode 2. Cliquez sur chaque champ en maintenant la touche [CTRL] enfoncée. Au fur et à
mesure de la sélection, les champs apparaissent avec des poignées blanches.
Remarque : Quelle que soit la méthode utilisée, le premier champ sélectionné apparaît avec des poi-
gnées grises.

97
Déplacer un ou plusieurs champs dans la fenêtre

Pour déplacer des champs :
1. Sélectionnez le ou les champs à déplacer.
2. Maintenez le bouton gauche de la souris enfoncé et déplacez les champs avec la souris. Le
correcteur d'interface en temps réel permet d'aligner les champs déplacés.
Le déplacement des champs sélectionnés peut également s'effectuer avec les flèches du cla-
vier. Pour accélérer le déplacement avec les flèches, il faut appuyer sur la touche [Ctrl] en
même temps que la flèche.
Pour un placement plus précis, vous pouvez activer les règles ("Affichage .. Règles"). Pour plus de
détails, consultez l’aide en ligne.
Pour un placement "magnétique" (vos champs respectent un certain espacement, ...), vous pouvez
afficher la grille ("Affichage .. Grille").
En appuyant sur la touche [SHIFT] pendant le déplacement des champs avec la souris, vous dépla-
cez vos champs librement, sans utiliser les règles ou le magnétisme. Vous pouvez ainsi placer vos
champs sans utiliser la grille magnétique de l’éditeur.

Supprimer un champ
Pour supprimer un ou plusieurs champs :
1. Sélectionnez le ou les champs à supprimer.
2. Appuyez sur la touche [Suppr] (ou sélectionnez l'option "Supprimer" du menu contextuel).
Les champs sont supprimés de la fenêtre.
Copier des champs

L'éditeur de fenêtres propose plusieurs possibilités pour copier les champs :
• Copie d’un champ dans une même fenêtre
• Copie d’un champ d’une fenêtre vers une autre
4 1.
Pour copier un champ :
Cliquez avec le bouton droit sur le champ à copier.
2. Sélectionnez l'option "Copier" dans le menu contextuel ([CTRL]+[C] au clavier).
3. Positionnez-vous si nécessaire dans la fenêtre où le champ doit être copié.
4. Sélectionnez l’option "Coller" dans le menu contextuel ([CTRL]+[V] au clavier).
Remarque : il est également possible d’utiliser les icones suivantes : pour copier et pour
coller.

98
Superposer des champs et visualiser l’altitude des champs

Pour obtenir des effets particuliers, il est possible de superposer plusieurs champs. Ainsi il est par
exemple possible de superposer un libellé sur une image. Pour que le libellé apparaisse "au-des-
sus" de l’image, il suffit d’indiquer l’altitude du champ (option "Champ .. Monter" par exemple).
Pour gérer l'altitude de vos champs, WinDev permet de visualiser vos fenêtres en 3 dimensions. En
effet, l’affichage en deux dimensions devient vite limité pour ce genre d'opération.
L'altitude des différents champs de la fenêtre apparaît alors immédiatement. Un champ sélec-
tionné dans ce mode d'affichage reste sélectionné lors du passage à l'affichage en deux dimen-
sions.
4 1.
Pour afficher une vue en 3 dimensions de vos fenêtres :
Affichez la fenêtre sous l'éditeur.
2. Sélectionnez l'option "Affichage .. Visualiser la fenêtre en 3D".
3. La fenêtre apparaît en 3 dimensions. Pour changer le point de vue, vous pouvez utiliser la
souris ou le clavier.
Vous pouvez choisir simplement le meilleur angle de vision grâce à la souris et aux touches du cla-
vier.
Attention : pour utiliser cette fonctionnalité, une configuration spécifique est nécessaire. Pour plus
de détails, consultez l’aide en ligne (mot-clé : "3 Dimensions").

99
Modifier les caractéristiques d’un ou plusieurs champs

Vous l'avez déjà constaté, les caractéristiques d'un champ sont regroupées dans une fenêtre de
description à plusieurs onglets (informations générales, informations de détail, IHM, code, fichier
associé, notes, aide, style).
4 1.
Pour accéder directement à un onglet donné :
Cliquez sur le champ avec le bouton droit de la souris : le menu contextuel s'affiche.
2. Sélectionnez l’option "Description".
3. Sélectionnez l'onglet à afficher.
Remarque (utilisation avancée) : pour modifier un champ, vous
pouvez également utiliser le modifieur.
4 Pour afficher le modifieur,
Barre d'outils .. Modifieur".
sélectionnez l'option "Affichage ..
Le modifieur affiche les caractéristiques du champ sélec-

tionné. Si plusieurs champs sont sélectionnés, seules les
caractéristiques communes sont affichées.

Pour visualiser les caractéristiques de plusieurs champs dans une
seule fenêtre, utilisez la touche [F12].

100
LEÇON 3.3. ÉDITEURS DE FENÊTRES ET

DE CODE
• Manipulation d’une fenêtre sous l’éditeur de fenêtres.

• Découverte des options de l’éditeur de code.


101
L'éditeur de fenêtres
Pour créer une fenêtre, il suffit de cliquer sur l’icone et de sélectionner le type de fenêtre à
créer.
4 1.
Pour copier une fenêtre sous un autre nom :
Ouvrez la fenêtre à copier.
2. Sélectionnez l'option "Fichier .. Enregistrer sous ".
3. Saisissez le nouveau nom de la fenêtre.
4 1.
Pour changer la position d’affichage d’une fenêtre :
Vérifiez que l’option "Relatif à l’écran" est sélectionnée dans l’onglet "IHM" de la fenêtre de
description.
2. Affichez la fenêtre d’aperçu position (option "Affichage .. Barre d’outils .. Aperçu Position
Fenêtres").
3. Dans la fenêtre d’aperçu position, déplacez la fenêtre à la position voulue.
Vous pouvez également saisir les coordonnées de la position dans l’onglet "IHM" de la fenêtre

de description.
4 1.
Pour agrandir une fenêtre :
Cliquez sur un des bords de la fenêtre sans relâcher le bouton de la souris (le curseur se
transforme alors en double flèche).
2. Déplacez la souris de façon à obtenir la taille souhaitée, puis relâchez le bouton de la souris,
quand la fenêtre est à la dimension voulue.
Vous pouvez également saisir la largeur et la hauteur de la fenêtre dans l’onglet "IHM" de la
fenêtre de description.
Astuce
Dans l’onglet "IHM" de la fenêtre de description de la fenêtre, il existe des tailles

de fenêtres prédéfinies.
4 Pour accéder aux caractéristiques de la fenêtre, vous pouvez par exemple utiliser le menu con-
textuel de la fenêtre. Cliquez dans la fenêtre (sans cliquer sur un champ) avec le bouton droit
de la souris. Un menu contextuel s'affiche. Il permet d'accéder :
• à la description de la fenêtre (option "Description").
• au code de la fenêtre (option "Code").
Vous commencez maintenant à maîtriser les manipulations sous l'éditeur.

Nous découvrirons au fur et à mesure les différentes options de l’éditeur.
L'éditeur de fenêtres propose également d’autres possibilités intéressantes :

• le paramétrage de l’éditeur (option "Outils .. Options de WinDev")
• l’affichage de l’aide contextuelle.
• la création de fenêtres avec assistant.

102
Paramétrage de l’éditeur
Le paramétrage de l'éditeur est regroupé dans une seule fenêtre. Cette fenêtre est accessible par
l'option "Outils .. Options de WinDev".
Les options permettent de choisir :
• le mot de passe de l'utilisateur
• les options de sauvegarde
• les options de traduction
• les options sur les répertoires
• les options d'affichage
Aide contextuelle de l'éditeur de fenêtres
Toutes les fenêtres de l'éditeur (ou presque) proposent une aide en ligne et / ou une aide contex-
tuelle.
L’aide contextuelle (accessible par le bouton ) détaille les informations attendues par l’écran en
cours.
Assistant de création de fenêtres
WinDev permet de créer des fenêtres à l'aide d'assistants.

Divers types d’assistants sont disponibles :
• assistants pour créer les fenêtres associées à des fichiers de données avec code (RAD) ou
sans code (RID). Cet onglet peut être grisé si aucune analyse (description de fichiers de don-
nées) n’est associée au projet en cours.
• assistants pour créer des fenêtres standard (boîtes de dialogue, ...)
• assistants pour créer des fenêtres prédéfinies telles que "sélecteur de répertoires", ...
• assistant pour créer des fenêtres internes
• assistant pour importer une fenêtre actuellement ouverte sur le poste en cours.
Les assistants de création de fenêtre sont accessibles lors de la création d'une nouvelle fenêtre.
Des dizaines de fenêtres types, prêtes à l’emploi, sont disponibles :

103
L’éditeur de code
L'éditeur de code propose d’autres possibilités intéressantes :
• Assistance à la saisie de code source.
• Recherche des déclarations de variables.
• "Time stamp" et nom de l’auteur de chaque ligne de code source (touche F6).
• Complétion du code.
• Documentation automatique du code.
• Refactoring.
• Enroulé de code
Vous pourrez retrouver dans ce cours d’auto-formation, plusieurs fonctionnalités concernant l’édi-
teur de code :
• Programmation des timers, threads, procédures automatiques (voir page 346)
• Préfixage automatique des variables (voir page 45)
Assistance à la saisie du code

Lors de la frappe d'une fonction, la syntaxe de la fonction s'affiche :
• dans une bulle d’aide au-dessous de la ligne en cours de saisie. Pour chaque paramètre (y
compris le résultat de la fonction), une bulle explicative est affichée.
Si plusieurs syntaxes sont disponibles, il est possible de passer d’une syntaxe à l’autre grâce
aux touches [ALT] + flèche droite ou flèche gauche.
• dans la barre de message de l'éditeur.
Dans l’aide affichée, les paramètres entourés par [ et ] sont optionnels.

104
Pour les fonctions utilisant des noms de fichiers, de champs, de fenêtres, ou d'états, la saisie assis-
té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 W-Langage ont une aide associée. Cette aide est directe-
ment accessible depuis l'éditeur en appuyant sur le bouton [F1] sur le nom de la fonction ou de la
propriété voulue.
Glossaire de fonctions
Le glossaire de fonctions proposé par WinDev permet d’associer un raccourci aux fonctions du W-
Langage le plus souvent utilisées. Il suffit ensuite de saisir ce raccourci sous l’éditeur de code.
Par exemple au lieu de taper "EcranVersFichier", il suffit de taper le code abrégé "EVF".
4 •Pour utiliser le glossaire, il suffit de :

taper les trois lettres identifiant la fonction,
• appuyer sur la touche [F5], le nom de la fonction est automatiquement inscrit.
Le contenu du glossaire peut être modifié, par exemple pour ajouter le nom des variables que vous
utilisez fréquemment.
4 Pour modifier le contenu du glossaire, appuyez sur les touches [SHIFT]+[F5].
Time stamp
L'appui de la touche [F6] permet d'afficher les informations (nom, date et heure de la création/
modification) de chaque ligne de code.

105
Point d’arrêt
L’appui simultané des touches [CTRL]+[B] pose ou enlève un point d’arrêt (icone ). En test, le
débogueur sera activé dès l’exécution de la (ou les) ligne(s) contenant un point d’arrêt. La touche
[F7] permet alors d’exécuter le code pas à pas, tandis que la touche [F5] continue l’exécution nor-
male (voir aide en ligne, mot-clé : "Débogueur").
Pose de marques dans le code

L'appui simultané des touches [CTRL]+[F7] pose ou enlève une marque sur la ligne en cours.
Plusieurs marques peuvent être placées dans le code. Cela permet ainsi de se déplacer rapide-
ment d'une marque à une autre ([F7] pour aller à la marque suivante, [SHIFT]+[F7] pour aller à la
marque précédente).
Documentation automatique du code

L’éditeur de code propose une documentation automatique des procédures de votre projet. Cette
documentation peut être activée soit par les touches [ALT]+[/] soit par l’icone .
Cette documentation peut être plus ou moins détaillée. La configuration des différentes paramè-

tres pris en compte est réalisée dans les options de l’éditeur de code (option "Affichage .. Options
d’édition du code", onglet "Documentation automatique").
Vérification du code
Lors de la sauvegarde des traitements (option "Fichier .. Enregistrer"), une compilation et une vérifi-
cation des identificateurs est automatiquement effectuée pour les lignes ajoutées ou modifiées.
Base des identificateurs

Les noms (identificateurs) des variables globales, des champs, des rubriques de
Notes
fichier Hyper File, des procédures (internes et globales), des membres et des
méthodes de classes, ... sont stockés dans une "base" au fur et à mesure de la
compilation. Cette base est appelée "Base des identificateurs".
Dès qu'un identificateur est utilisé (et non pas déclaré) dans un traitement, il est recherché dans la
base des noms : s'il n'est pas trouvé, un message de "Warning" s'affiche dans le kouglof (onglet
"Code", option "Erreurs de compilation"). Un clic droit sur l’erreur ou le warning permet d’identifier la
cause et d’y apporter plus facilement une solution.

106
Quelques combinaisons de touches utiles

• [CTRL]+[L] supprime la ligne en cours.
• [CTRL]+[D] duplique la ligne en cours sur la ligne du dessous.
• [TAB] et [SHIFT]+[TAB] permettent de gérer l'indentation de l'ensemble des lignes sélectionnées.
• [CTRL]+[/] met en commentaires les lignes sélectionnées, [CTRL]+[SHIFT]+[/] enlève les com-
mentaires (Attention touche [/] du pavé numérique).
• [F2] sur le nom d'un champ, d'une méthode, d'une classe, d'une procédure ou d'un bloc d'état
affiche le traitement de cet objet.
• [CTRL]+[F2] permet de revenir au traitement initial.
Il est possible par l'appui répété sur la touche [F2] de se déplacer d'un traitement à un autre.
Pour revenir sur le traitement initial, il suffit d'appuyer autant de fois sur les touches [CTRL]+[F2].
Refactoring (propagation des modifications)

Lors d’un changement de nom d’une variable, d’un champ dans une fenêtre, ... il est souvent utile
de reporter ces modifications dans tout le projet.
WinDev 10 propose de réaliser automatiquement ce report lors du renommage d’un élément.
Lors de l’enregistrement du code contenant la variable renommée, des erreurs de compilation

apparaissent dans le volet "Code" et un icone apparaît à droite de l’espace de travail. Cliquez sur
cet icone. Le renommage est automatiquement réalisé dans tout le projet.
Enroulé de code
L’éditeur de code offre également la possibilité d’enrouler ou de dérouler le code W-Langage. Cette
fonctionnalité est très utile si vos traitements utilisent de nombreuses instructions structurées
(boucles, condition, parcours, ...).
4 Pour replier un code, sélectionnez l’option de menu "Code .. Code repliable .. 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 "+" permettent d’enrouler ou de dérouler uniquement la partie de
code correspondante.

107
LEÇON 3.4. LES CHAMPS

• Présentation et utilisation des différents types de champs disponibles dans Win-

Dev.
• Manipulation des caractéristiques des champs dans l’éditeur de fenêtres.
Vous trouverez dans le répertoire "\Autoformation\Corriges\Fenêtres et champs" le

projet "Fenêtres et champs.WDP" contenant les illustrations de cette leçon.
l’option "? .. Guide d’auto-formation .. Fenêtres et champs".

108
Introduction
Les champs sont des éléments permettant de saisir ou de visualiser des valeurs. Les valeurs affi-
chées peuvent provenir d’un calcul effectué par programmation, d’un fichier d’une base de don-
nées ou d’une affectation.
Les valeurs que l’on saisit peuvent servir à faire des calculs, à être enregistrées dans un fichier
d’une base de données ou à être affectées dans d’autres champs.
Nous allons tout d’abord voir quelques exemples d’utilisation de certains types de champs. Vous
avez déjà utilisé des champs de saisie, boutons et images dans les leçons précédentes. Nous ver-
rons en détail comment les créer et quelles sont leurs caractéristiques.
Dans le menu de WinDev, sélectionnez l’option "? .. Guide d’Auto formation .. Fenêtres et champs".

Pour tester ce que vous allez apprendre dans cette leçon, parcourez les différentes options du
menu "Champ".
Pour apprendre à utiliser ces différents types de champs, nous allons utiliser un projet exemple pré-
paré à cet effet. Pour ouvrir ce projet sous WinDev :
1. Sélectionnez l’option "Fichier .. Ouvrir un projet".
2. Sélectionnez le sous-répertoire "AutoFormation\Corriges\Fenêtres et champs" du répertoire
3. Sélectionnez le fichier "Fenetres et champs.WDP". Le projet se charge.

109
Avant de commencer, voyons tout d’abord les principaux événements associés

aux champs et aux fenêtres :
• initialisation du champ : ce traitement est exécuté à l'ouverture de la fenê-
tre. Ce traitement permet de donner les valeurs initiales aux champs.
• entrée dans le champ : ce traitement est exécuté à chaque fois que le cur-
seur se positionne sur le champ (à chaque fois que le champ devient en
cours de saisie)
• sortie du champ : ce traitement est exécuté à chaque fois que l'on quitte le
champ pour aller sur un autre champ. Il contient généralement un contrôle
Notes
sur la valeur saisie.

• à chaque modification : ce traitement est exécuté à chaque fois que le con-
tenu du champ est modifié par l’utilisateur
• clic : ce traitement est exécuté à chaque fois qu’un clic de souris est effec-
tué sur le champ.
• ouverture, fermeture (pour les fenêtres) : traitements respectivement asso-
ciés à l’ouverture et à la fermeture d’une fenêtre.

Il existe également d’autres traitements (sélection, survol, ...).
Consultez l’aide en ligne pour plus de détails (mot-clé : le type du champ) ou la
leçon “Les Evénements Windows”, page 349.
Voyons maintenant les principaux types de champs disponibles avec WinDev.
Type de champ : Libellé
Résumé
Les libellés permettent d’afficher du texte statique. Ils ne peuvent pas être saisis en exécution mais
leur contenu peut être sélectionné pour effectuer des "copier/coller". Ils peuvent être modifiés par
programmation (comme tous les champs).
Les libellés sont utilisés pour afficher une information, par exemple un titre en gros caractères. Le
contenu d’un libellé peut être défini sous l’éditeur lors de la description du libellé ainsi que par pro-
grammation.
Les libellés permettent également d’afficher un texte en fonction de la langue utilisée dans le pro-
jet, sans programmation particulière. Pour plus de détails, reportez-vous à la leçon sur la gestion
des langues dans un projet (Leçon “Applications multilingues”, page 159).
En détail
4 Ouvrez la fenêtre "ChampLibelle.WDW" et testez cette fenêtre.
Cette fenêtre présente :
- les différents types de libellés pouvant être utilisés.
- les différentes manipulations pouvant être effectuées sur un libellé.

110
4 Testez les différentes manipulations des libellés.

Le libellé est affiché en vert.
Le bouton "Couleur" change la couleur du libellé.
Le bouton "Récupère" récupère le libellé affiché.
Les boutons "Change" et "Construit" modifient le libellé affiché.
4 Retournez sous l'éditeur.
WinDev propose plusieurs options afin de créer le libellé qui vous convient :
• les libellés au format RTF : ce type de libellé permet de gérer toutes les caractéristiques du
format RTF (Gras, italique, souligné, couleurs, ...). Pour qu’un libellé soit au format RTF, il suf-
fit de cocher l’option "Texte avec mise en forme (R.T.F)" dans l’onglet "Détail" de la description
du champ.
• les libellés animés : Faire clignoter ou défiler un libellé est un jeu d’enfant. Il suffit de choisir
le mode d’animation et de configurer les paramètres correspondants dans l’onglet "Détail"
de la description du champ.
• les libellés avec ombre floue : une ombre floue apparaît derrière le libellé afin de créer un
effet de relief. La configuration de l’ombre floue est réalisée dans l’onglet "Style" de la des-
cription du champ.
4 Etudiez le code des boutons.

Pour construire le libellé LIBELLE1, il faut adopter la syntaxe suivante (dans cet exemple la chaîne
est construite à partir de chaînes et du résultat de la fonction DateSys qui retourne la date sys-
tème).
LIBELLE1="Coucou" + RC + "Nous sommes le " + ...
DateVersChaine(DateSys())
Pour récupérer le libellé de LIBELLE1, la syntaxe est :

Ch est une Chaîne
Ch = "Le libellé est "+ RC + LIBELLE1
// ou
// Info("Le libellé est "+ RC + LIBELLE1)
Il est même possible de changer la couleur du texte du libellé avec la propriété Couleur.
LIBELLE1..Couleur = iBleuClair
iBleuClair est une constante W-Langage correspondant à la couleur Bleu Clair.
Les propriétés permettent de modifier par programmation certaines caractéristi-

ques des champs. Nous ne citerons pas toutes les propriétés. Nous découvrirons
quelques unes des principales propriétés au fur et à mesure de cette partie.
Toutes les propriétés sont relatives à un champ donné. Leur syntaxe d'utilisation
Notes
est :
Nom_Champ..Nom_Propriété
La liste des propriétés disponibles sur les champs est présente dans l’aide en
ligne de WinDev, mot-clé : "Propriétés, Propriétés sur les fenêtres et leurs
champs".

111
Type de champ : Champ de saisie
Résumé
Les champs de saisie sont les premiers champs que vous avez manipulés. Ils permettent de saisir
ou d'afficher des données provenant de variables, de calculs ou de fichiers.
Ils permettent par exemple de saisir un mot de passe, une quantité à commander, le nom d’un
client, une adresse, …
Ces champs sont très importants, c'est pourquoi nous allons les détailler.
En détail
4 Ouvrez la fenêtre "CHAMPSAISIE.WDW".
Un champ de saisie peut être de différents types :
• texte,
• numérique,
• heure,

• date,
• monétaire,
• monétaire+Euro.
A chaque type de champ correspondent plusieurs masques de saisie (ou d'affichage). Nous avons
précédemment vu l'intérêt du masque, nous n'y reviendrons pas.
Précisons toutefois que les champs numériques ne sont pas typés. C'est le masque sélectionné
pour le champ qui va définir si le champ est un réel, réel double, entier, ...
La fenêtre "Champsaisie.wdw" présente la gestion des champs de type texte et des champs numé-
riques.
4 Saisissez dans les champs qui ont le libellé "en saisie". Dans les autres champs, il n'est pas
possible de saisir. En effet, ils ont été décrits en affichage. Cliquez sur les différents boutons et
observez ce qu'il se passe.
4 Revenez sous l'éditeur et étudiez le code des boutons.
Pour afficher et récupérer une valeur dans un champ de saisie une simple affectation suffit et ce
quel que soit le type du champ de saisie.
Pour un champ de saisie de type Texte :
• Exemple à saisir dans le code d’initialisation du champ de saisie :
SAISIE2= "Coucou" //affiche Coucou dans le champ texte
• Exemple à saisir dans le code de clic d’un bouton :

Ch est une Chaîne
Ch = SAISIE2 //Récupère le contenu du champ texte

112
Pour un champ de saisie de type numérique :

• Exemple à saisir dans le code d’initialisation du champ de saisie :
SAISIE3 = 20.6 //affiche la valeur 20.6 dans le champ numérique
• Exemple à saisir dans le code de clic d’un bouton :
Valeur est un Réel
Valeur = SAISIE3 //Récupère le contenu du champ numérique
Dans la zone de saisie, la couleur du texte et la couleur du fond sont modifiables par programma-
tion avec les propriétés Couleur et CouleurFond.
SAISIE1..Couleur = iVertFonce //change la couleur du texte
SAISIE1..CouleurFond = iJauneClair //change la couleur du fond
4 Revenons sur les caractéristiques d'un champ de saisie.

L'état initial du champ peut être :
• En saisie : le champ est actif, il sera en saisie dans la fenêtre.
• Affichage seul : le champ est inactif, aucune saisie ne sera possible. Ce champ se compor-
tera comme un champ de type libellé. Il sera cependant possible de sélectionner le contenu
du champ à l’aide de la souris, si l’option "Avec sélection en affichage" est cochée.
• Grisé : le champ est inactif et il apparaît en grisé. Cet état est très pratique pour indiquer à
l'utilisateur que ce champ existe, mais qu'il n'est actuellement pas accessible.
• Visible : Comme son nom l’indique, le champ "existe" dans la fenêtre. Ce champ peut être
visible ou non. Cet état est souvent utile en programmation lorsqu'un champ doit apparaître
à certains moments et disparaître à d'autres !
Cette option est indépendante des 3 options précédentes. Vous pouvez rendre ainsi le
champ visible ou non tout en conservant les paramètres d’affichage.
L'état initial d'un champ est choisi lors de sa création (onglet "IHM" de la fenêtre de description du
champ). Il peut être modifié par programme en utilisant la propriété Etat pour les options "Saisie",
"Affichage seul" et "Grisé", et la propriété Visible pour l’option "Visible".
Comme pour la plupart des champs, vous pouvez choisir le cadrage du contenu du champ. Selon le
type du champ, un cadrage est proposé par défaut.
Dans l’onglet "Général" de la fenêtre de description du champ, il est possible de définir les para-
mètres suivants :
• Texte avec mise en forme (R.T.F) : Permet d’avoir des mots en Italique, en Gras, en couleur,
de tailles et de polices différentes, ... Les initiales de RTF signifient : "Rich Text Format".
Un superchamp livré en standard avec WinDev, permet d’illustrer le format

Notes
RTF en proposant une barre d’outils RTF (accessible depuis le Kouglof de

WinDev).
• Mot de passe : pour les champs de type texte, cette option doit être cochée s'il s'agit d'un mot
de passe. Dans ce cas, les caractères frappés sont remplacés par des "*" uniquement à l’affi-

113
chage.
Astuce
Ce type d’option est idéale pour la saisie du mot de passe d’un utilisateur
dans une fenêtre de login.
• Texte multi-lignes : permet de saisir un texte sur plusieurs lignes. On peut ainsi insérer des
RC dans le texte.
Ce type d’option est idéal pour saisir un commentaire ou une observation.

Astuce
L'utilisation de ce paramètre est fondamentale pour l'utilisation des

champs "Mémo" (étudiés plus loin).
Dans le cas d'une saisie multi-lignes, il est possible de sélectionner le mode de défilement
des informations dans le champ (onglet "Détail" de la fenêtre de description).
- si le champ est en "Défilement Vertical" (seulement), les mots sont chassés à la ligne
suivante s'ils "débordent" de la ligne en cours. Le nombre de lignes visibles que vous
indiquez correspond au nombre de lignes présentes dans la fenêtre, mais bien évi-

demment, il peut y avoir beaucoup plus de lignes.
- Si le champ est en "Défilement Horizontal" (seulement), lorsque les caractères saisis
occupent tout le champ, les caractères se décalent vers la gauche pour permettre de
saisir d'autres caractères. Cela permet par exemple de saisir un texte de 150 caractè-
res dans un champ ayant 3 caractères de large !
- Si le champ est en "Défilement Horizontal ET Vertical", le passage à la ligne suivante
s'effectue par la combinaison de touches [CTRL] + [ENTREE] (standard Windows) ou
[ENTREE].
Le saviez-vous ? La taille maximale d’une variable texte est de 2 Go. En

Notes
tapant 3 lettres par seconde, il faudrait ... plus de 22 ans pour remplir le
champ !
Pour les champs de type numérique, il est possible de saisir une valeur minimale et maximum
(dans l’onglet "Détail" de la fenêtre de description du champ).
Lors de la saisie dans ce champ, WinDev contrôlera automatiquement que ces valeurs sont respec-
tées.
Dans l’onglet "IHM" de la fenêtre de description du champ, il est possible de définir les paramètres
suivants :
• Gestion de la touche TAB :
WinDev propose plusieurs modes de gestion de la touche TAB :
- Aucune : Le champ ne gère pas la touche TAB
- Champ accessible par TAB : la touche [TAB] du clavier permet alors de se positionner sur ce
champ.
Attention !
Ce comportement par défaut de [TAB] est un standard de Windows. Cela

peut perturber l’utilisateur s’il était habitué à taper sur la touche [Entrée]
pour passer au champ suivant sous d’autres systèmes.

114
- Accepter les TAB en saisie : la touche [TAB] utilisée dans le champ permet de créer des
tabulations dans le texte.
• Le bouton "Groupes" permet de "regrouper" plusieurs champs pour modifier l'état de ces
champs (par programmation) en une seule opération.
Nous allons revenir sur la notion de plan et d'onglets plus loin.
• La "lettre d'appel" permet à l'utilisateur de se positionner directement sur le champ, en
tapant simplement une combinaison de touches du clavier (par exemple [ALT] + [Lettre]).
Dans le libellé d'un champ de saisie, si une lettre est précédée de "&", elle devient automati-
quement "lettre d'appel".
Par exemple : "&Nom du client" décrit [ALT]+[N] comme lettre d'appel.
• Le traitement du "clic droit" (de la souris) permet d'associer une action au clic droit de la sou-
ris. Le traitement est par exemple "validation des informations saisies", "appel de l'aide", ...
Le traitement est choisi parmi ceux des boutons (texte et graphique) présents dans la fenê-
tre.
Parfois il est plus utile d’utiliser les lettres d’appel plutôt que les actions de souris.
WinDev permet de réaliser facilement des interfaces (IHM) où l’utilisation de la
Notes
souris n’est pas nécessaire. Par exemple, pour des applications de points de
vente (la place manque sur les comptoirs !) ou dans le domaine industriel : bornes
interactives, machine outils, ...
Dans l’onglet "Détail" de la fenêtre de description du champ, il est possible de définir les paramè-
tres suivants :
• Saisie obligatoire : si la saisie de ce champ est obligatoire, il ne sera possible de se position-
ner sur un autre champ que si une valeur a été saisie.
• Saisie assistée : si le champ est lié à une rubrique clé, la valeur trouvée dans le fichier et cor-
respondant aux premières lettres saisie est automatiquement proposée.
• Mémoriser la valeur : permet de mémoriser la dernière valeur saisie dans le champ avant la
fermeture de la fenêtre. Cette valeur sera automatiquement proposée à la prochaine ouver-
ture de la fenêtre.
• Historique des saisies : permet de proposer les dernières valeurs saisies par l’utilisateur pour
ce champ.
• Fin de saisie automatique : arrivé en fin de saisie (nombre de caractères total du champ
saisi), le programme passe directement au champ suivant, sans attendre la frappe de la tou-
che [TAB] ou l'usage de la souris.
• Effacement automatique : le texte affiché est sélectionné en totalité et s'efface lors de la
frappe du premier caractère.
• Avec sélection en affichage : permet de sélectionner le contenu du champ même si celui-ci
est en "Affichage seul".
• Pour les champs de type numérique, il est possible de saisir une valeur minimale et maxi-
male.
Lors de la saisie dans ce champ, WinDev contrôlera automatiquement que ces valeurs sont
respectées.
• Mise à blanc si zéro : pour les champs de type numérique, si la valeur prise par le champ est
nulle, le contenu du champ est vidé automatiquement.
• NULL si vide : retourne la valeur NULL si le champ n’a pas de valeur (Attention ! Ni 0, ni

115
chaîne vide !).
La valeur NULL est très utile pour gérer le passage de paramètres à une
Astuce
requête et rendre les conditions optionnelles pour des recherches multi-

critères. Nous aborderons cela plus tard lors de la leçon sur l’éditeur de
requêtes.
• Mode ellipse : Permet de tronquer le contenu du champ si nécessaire. Si le champ est tron-
qué "en fin", les caractères "..." remplaceront la fin du texte à l’affichage.
• Glisser / déplacer : Le champ peut être source ou cible du glisser/déplacer ("drag and drop").
Type de champ : Bouton
Résumé
Les boutons sont utilisés pour lancer des traitements. On les appelle égale-
ment "Contrôles". Le traitement associé au bouton s'exécutera lorsque le bou-

ton sera activé (lorsque l'utilisateur clique sur le bouton).
Les boutons peuvent contenir un texte simple et/ou une image.
Vous avez déjà créé plusieurs boutons.

Revenons sur les types de boutons proposés par WinDev.
En détail
Un bouton peut être de 5 types (informations à renseigner dans la fenêtre de description, onglet
"IHM") :
1. Normal
2. Validation
3. Interruption
4. Abandon
5. Aide
4 Pour mieux comprendre la différence entre chaque type de bouton, ouvrez et testez la fenêtre
"champbouton.wdw".
1. Un bouton de type Normal est un bouton comme ceux que vous avez déjà créés.
Ce type de bouton n'a pas d'action prédéfinie particulière. Le code de sortie du champ qui était
en cours lors de la validation du bouton est exécuté avant le traitement du bouton.
4 Pour le vérifier, cliquez sur le bouton "Normal". Le message "Code de sortie du champ NOM"
s'affiche et ensuite le message "Clic sur le bouton NORMAL" s’affiche.
Astuce
On utilisera plutôt un bouton de type "Normal" dans des barres d’outils ou des bar-
res d’icones ou dans des fenêtres sans champs de saisie.

116
2. Un bouton en Interruption signifie que lorsque le bouton est activé, le code de sortie du
champ qui était en cours n'est pas exécuté. Le code du bouton s'exécute, puis le curseur est
repositionné sur le champ.
4 Pour le vérifier, repositionnez vous sur le champ "Nom" puis cliquez sur le bouton "Interruption".
Seul le code du bouton s'exécute, le code de sortie du champ ne s'exécute pas.
Pour afficher une page d'aide, il faut créer un bouton en interruption et non pas un bouton de
type aide.
On utilisera plutôt un bouton de type interruption pour appeler une fenêtre (afin
Astuce
d’interrompre la saisie en cours sans valider) puis revenir pour continuer la saisie.
C’est généralement le type utilisé pour les boutons "Aide".
3. Lorsqu'un bouton est en Validation, la frappe de la touche [RC] ou [Entrée] exécute le traite-
ment du bouton, le code de sortie du champ qui était en cours est exécuté.
4 Pour le vérifier, repositionnez vous sur le champ "Nom" puis cliquez sur le bouton "Validation".
On utilisera un bouton de type Validation pour effectuer la validation de la saisie

Astuce
d’une fenêtre. On retrouvera donc un bouton de ce type dans chaque fenêtre où il

y a une saisie. C’est généralement le type utilisé pour les boutons "OK".
4. Lorsqu'un bouton est en Abandon, la frappe de la touche [ESC] ou [Echap] exécute le traite-
ment du bouton, le code de sortie du champ qui était en cours n'est pas exécuté.
On utilisera un bouton de type Abandon pour "sortir" de la fenêtre en cours de sai-

Astuce
sie sans effectuer aucune validation. On retrouvera donc aussi un bouton de ce

type dans chaque fenêtre où il y a une saisie. C’est généralement le type utilisé
pour les boutons "Annuler".
4 Pour le vérifier, repositionnez vous sur le champ "Nom" puis cliquez sur le bouton "Abandon".
La "croix" qui se trouve en haut à droite dans la barre de titre d’une fenêtre n’est
pas du tout identique à un bouton de type Abandon. Lors du clic sur la "croix", la
fenêtre est fermée sans passer par un des boutons Validation ou Abandon de la
Attention !
fenêtre. Seul le code de fermeture de la fenêtre est appelé. L’équivalent de cliquer

sur la "croix" est d’appuyer sur la combinaison de touches [Alt]+[ F4].
Pour obliger l’utilisateur à passer par un de vos boutons pour valider ou abandon-
ner la saisie, désactivez la "croix" ! Il suffit de décocher la case "Menu système"
dans l’onglet "Style" de la fenêtre de description de la fenêtre.
5. Lorsqu'un bouton est de type Aide, la validation du bouton affiche automatiquement l'aide
associée au champ en cours (activée normalement par [F1]) sans exécuter les codes de sortie
et d'entrée du champ en cours.

117
Caractéristiques
Un bouton peut être associé à :
• une lettre d'appel.
• une touche de fonction.
• une touche de déplacement.
• une combinaison de touches.
La lettre d'appel ou la touche de fonction associée au bouton est indiquée dans les informations
concernant l’IHM du champ. Le bouton doit être de type "Normal" ou "Interruption".
Cela permet par exemple d'exécuter un traitement, d'ouvrir une fenêtre, ... sous l'action d'une tou-
che.
4 Dans notre fenêtre, appuyez sur [F2], une fenêtre de type "Info" s'affiche.
L'image du bouton peut être :
• une image que vous avez créée
• choisie parmi celles proposées dans le catalogue de WinDev (dans les "clipart" ou les "goo-
dies"). Nous avons déjà vu le fonctionnement du catalogue d’images dans la première partie
de ce cours. Pout plus de détails, consultez “Création d’une fenêtre avec des images”,

page 56
Il est aussi possible d’utiliser pour le bouton une image avec un fond transparent. Dans ce cas,
vous pouvez :
• soit créer une image dont la couleur de fond est "Magenta clair"
• soit définir que la couleur du point (pixel) en haut à gauche de l’image est la couleur transpa-
rente.
Nous vous conseillons de :

• ne pas donner de libellé à un bouton graphique dont l'image comporte un
Astuce
libellé, sinon le bouton comportera deux libellés.

• ne pas mélanger dans une même fenêtre, les boutons graphiques et les
boutons texte.
Le libellé d'un bouton texte ou d'un bouton graphique peut être modifié par programmation avec la
propriété Libelle. Si le libellé contient le caractère "&", la lettre qui suit sera soulignée et deviendra
la lettre d'appel du bouton :
BOUTON_TXT..Libelle = "Nouveau &libellé"
De la même façon, l'image d'un bouton graphique peut être modifiée par programmation :
BOUTON_IMG..Libelle = "SORTIE2.BMP"

118
La propriété Libelle reconnaît automatiquement si c'est le libellé ou l'image qui doit être modifié.
Dans certaines applications, pour éviter l’utilisation de la souris, les traitements

sont déclenchés par les touches de fonctions.
Astuce
Pour cela, il suffit de créer les boutons hors écran et de leur associer une lettre
d’appel.
Pour créer un bouton hors écran, il suffit de placer ce bouton dans la fenêtre
d’accueil de la fenêtre sous l’éditeur.
Type de champ : Image
Résumé
Les champs images permettent d'afficher des images.
Les champs images peuvent également servir de zones de clicage, consultez l’exemple "WD Zone
de clicage".
Nous nous sommes déjà attardés sur ce type de champ (dans la leçon “Votre 1ère application”,
page 43), nous n’y reviendrons donc pas. D’autres options sont également disponibles sur un
champ image, consultez l’aide en ligne (mot-clé : "Image").
Type de champ : Sélecteur
Résumé
Les sélecteurs d'options sont également appelés "case d'options". Ils
permettent de sélectionner une option et une seule, parmi celles propo-
sées.
Le libellé des options proposées doit être saisi lors de la description du

sélecteur sous l'éditeur. Ils sont modifiables par programmation.
En détail
4 Ouvrez la fenêtre "champselecteur.wdw".
4 Testez la fenêtre et cliquez sur les différents boutons, modifiez le sélecteur. Constatez ce qu'il
se passe.
4 Retournez sous l'éditeur et étudiez le code des boutons.
A chaque option d'un sélecteur est associé un entier (qui peut prendre une valeur de 1 à N, N étant
le nombre total d’options du sélecteur). La première option a le numéro 1, la deuxième le numéro
2, ... Les options sont numérotées de haut en bas et de gauche à droite.
Dans notre fenêtre : "SELECT_CIV=1" signifie que "Monsieur" est sélectionné, "SELECT_CIV=2"
signifie que "Madame" est sélectionné et "SELECT_CIV=3" signifie que "Mademoiselle" est sélec-
tionné.

119
Pour initialiser une case d'options, il suffit d'affecter une valeur entière au champ :
SELECT_CIV = 2 //sélectionne "Madame"
Pour connaître l'option sélectionnée, il suffit de récupérer la valeur entière du champ :

Choix = SELECT_CIV //récupère la valeur sélectionnée
Type de champ : Interrupteur
Résumé
Les interrupteurs sont également appelés "cases à cocher". Ils permet-
tent de choisir si la valeur de chaque option proposée est "vraie" ("Oui")
ou "fausse" ("Non").
Le libellé des options proposées doit être saisi lors de la description de

l'interrupteur sous l'éditeur. Il peut être modifié par programme.

En détail
4 Ouvrez la fenêtre "champselecteur.wdw" (si ce n’est déjà fait).
Chaque option d'un interrupteur est "repérée" par un indice (qui peut prendre une valeur de 1 à N,
N étant le nombre total d’options de l’interrupteur) La première option a le numéro 1, la deuxième
le numéro 2, ... Les options sont numérotées de haut en bas et de gauche à droite.
• "INTERR[3]=Vrai" signifie : "Danser" est cochée
• "INTERR[2]=Faux" signifie : "Ecrire" n'est pas cochée
Lorsqu’il y a plusieurs options, l’interrupteur se comporte comme un tableau d’options.

Pour accéder à une option, il suffit de passer l'indice de l'option en utilisant la syntaxe avec les cro-
chets [ ].
Pour initialiser une case à cocher, il faut initialiser le choix correspondant avec la valeur "Vrai" ou
"Faux" selon le cas.
INTERR[2] = Vrai //pour cocher l'option 2 "Ecrire"
Pour connaître la valeur d'une option, il suffit de récupérer la valeur du champ ("vrai" ou "faux").
SI INTERR[2]=vrai ALORS
//option cochée
SINON
//option non cochée
FIN

120
Les programmeurs habitués à manipuler des expressions booléennes peuvent

omettre le test avec la valeur "Vrai" ou "Faux" :
SI INTERR[2] ALORS
Astuce
//option cochée
SINON
//option non cochée
FIN
Il est possible de modifier le libellé d'un interrupteur ou d'un sélecteur avec la propriété Libellé.
Cependant, il n'est pas possible d'ajouter des options par programmation. Par exemple :
INTERR..Libelle ="Vous aimez plutôt" //change le libellé
//Change la première option
INTERR[1]..Libellé = "Lire un livre"
Type de champ : Liste
Résumé
Les listes sont toujours déroulées. C’est pourquoi on les nomme éga-
lement "listes déroulées". Elles permettent de visualiser plusieurs
éléments et d'en sélectionner un ou plusieurs.
Lors de la création d’un champ "Liste", un assistant démarre et pro-

pose de créer :
• une liste dont le contenu est lié à un fichier ou une requête.
• une liste dont vous définissez le contenu dans l’éditeur ou par
programmation.
Règles à appliquer pour connaître le type de liste à créer :

• Utilisez une liste liée à un fichier ou à une requête lorsque vous souhaitez propo-
ser à l’utilisateur une liste de valeurs qui sont contenues dans un fichier. Si la
liste est liée à un fichier, c’est tout le contenu du fichier qui est proposé directe-
Attention !
ment. Si la liste est liée à une requête, la liste contiendra une sélection d’enre-
gistrements du fichier.
• Utilisez une liste dont le contenu est défini dans l’éditeur si les valeurs sont
"STATIQUES". Elles ne changent pas durant le déroulement du programme.
• Utilisez une liste remplie par programmation lorsque le contenu de la liste est
issu de calculs ou si la sélection des éléments à intégrer à la liste ne peut être
réalisée par une requête.
En détail
Les listes peuvent contenir du texte et/ou du graphisme.
4 Ouvrez la fenêtre "champliste.wdw".

121
4 Lancez le test de cette fenêtre.

•La liste du haut est mono sélection.
•Les deux listes du bas sont multi-sélections.
4 Cliquez sur les différents boutons et observez ce qu'il se passe.
En exécution, dans une liste multi-sélections (selon le standard Windows) :
• pour sélectionner plusieurs éléments un par un, appuyez sur la touche [CTRL] tout en sélec-
tionnant les éléments avec la souris.
• pour sélectionner plusieurs éléments en même temps, utilisez le "lasso". Cliquez sur la sou-
ris, gardez le bouton enfoncé, déplacez la souris pour sélectionner les éléments, relâchez le
bouton de la souris.
• pour sélectionner plusieurs éléments consécutifs en même temps, cliquez sur le premier élé-
ment, appuyez sur la touche [Shift], maintenez cette touche enfoncée et cliquez sur le dernier
élément de la sélection.
4 Revenez sous l'éditeur et étudiez les traitements des boutons.
Remplissage d’une liste dans l’éditeur
Dans l’éditeur, vous pouvez saisir directement les valeurs contenues dans la liste à partir de la

fenêtre de description du champ (onglet "Général", section "Contenu Initial"). Vous pouvez bien
entendu saisir plusieurs valeurs. Pour aller à la ligne suivante, appuyez sur la touche [Entrée].
Remarques :
• Pour sélectionner plusieurs éléments dans une liste, l’option "multi-sélections" doit être cochée
dans la fenêtre de description de la liste (onglet "Détail").
• Les éléments de la liste peuvent être triés. Dans ce cas, l'option "Liste triée" doit être cochée
Remplissage d’une liste à partir d’un fichier ou d’une requête

Lors de la création d’un champ liste remplie à partir d’un fichier ou d’une requête, vous devez indi-
quer le fichier de l’analyse ou la requête qui servira de source de données pour le remplissage.
Si la requête n’existe pas lors de la création du champ, il est possible de créer la

Notes
requête en même temps que le champ. La requête sera alors intégrée à la fenêtre
qui contient le champ.
Ce fichier ou cette requête sera lu(e) automatiquement sans avoir à écrire une seule ligne de code.
De plus, lors de la sélection d’un élément de la liste, la valeur récupérée pourra être :
• soit l’indice de la ligne sélectionnée
• soit une valeur du fichier
Généralement, on choisit comme valeur récupérée une rubrique du fichier. Il s’agit le plus souvent
de la clé unique.
La clé de parcours que vous sélectionnez sert de tri pour le remplissage de la liste et donc indique
l’ordre dans lequel seront visualisées les valeurs.

122
Lorsque la liste est créée, ses caractéristiques sont modifiables directement dans la fenêtre de
description du champ (option "Description" du menu contextuel).
Vous retrouverez tous les caractéristiques indiquées dans l’assistant.
Programmation
Remplissage d’une liste

Pour remplir une liste par programmation, il faut utiliser la fonction ListeAjoute. Par exemple :
ListeAjoute(LISTE1,"Lundi") //ajoute Lundi dans la liste LISTE1
//remplir la liste avec le contenu d'un tableau

i est un entier
//Jour est un tableau de 7 chaînes
Pour i=1 à 7
ListeAjoute(Liste1, Jour[i])
Fin
Modification d’une liste

Pour modifier un élément dans une liste, il faut utiliser la fonction ListeModifie ou l'affectation
directe en utilisant l'indice de l'élément à modifier.
ListeModifie(LISTE1,"LUNDI") //modifie l'élément en cours
ListeModifie(LISTE1,"LUNDI",1) //modifie l'élément 1
LISTE1[1] = "LUNDI" //modifie l'élément 1
Pour accéder à un élément d'une liste, il faut préciser son indice. Le premier élément d'une liste a
l'indice "1".
Récupération de l’élément sélectionné

Dans une liste mono-sélection, pour récupérer l'élément sélectionné, il suffit de connaître l'indice
de l'élément sélectionné. La fonction ListeSelect retourne l’indice de l’élément sélectionné. Si
aucun élément n’est sélectionné, la fonction ListeSelect retourne la valeur "–1".
Jour est une chaîne
Indice= ListeSelect(LISTE1)
Jour=LISTE1[Indice] // Récupérer l'élément sélectionné
//Ou bien
Jour=LISTE1[LISTE1] // Récupérer l'élément sélectionné
Dans le cas d’une liste multi-sélections, pour récupérer toutes les options sélectionnées, il faut uti-
liser la fonction ListeSelect.
Tant que la fonction ListeSelect ne renvoie pas la valeur "-1", cette fonction retourne l'indice de
l'option sélectionnée.
Indice est un entier = 0
Rang est un entier = 1 //rang de la sélection
//Choix est un tableau de chaîne contenant les sélections

123
Boucle
Indice = ListeSelect(LISTE1,Rang)
Si Indice=-1 ALORS SORTIR
Choix[Rang] = LISTE1[Indice]
Rang=Rang+1
Fin
Pour connaître le nombre d’éléments sélectionnés, il faut utiliser la fonction ListeSelectOccur-

rence.
Pour connaître le nombre d'éléments dans la liste, il faut utiliser la propriété Occurrence ou la fonc-
tion ListeOccurrence :
Si Liste1..Occurrence = 0 alors //liste vide
Suppression
Pour supprimer une valeur, il faut utiliser la fonction ListeSupprime.
Pour supprimer toutes les valeurs de la liste, il faut utiliser la fonction ListeSupprimeTout.

//Supprimer l'élément sélectionné
ListeSupprime(LISTE1)
Recherche
Pour chercher un élément dans une liste, il faut utiliser la fonction ListeCherche.
Si ListeCherche(LISTE2,Valeur) = -1 alors
//n'existe pas
sinon
//existe déjà
Fin
Type de champ : Liste Image
Résumé
Une liste image est une liste permettant d’afficher à la fois du texte et des images. Un élément
d’une liste image est composé de :
• un libellé
• une miniature (ou image)
Une liste image peut être affichée selon deux modes :

• mode liste image : chaque élément de la liste est composé d’un libellé et d’une image.
• mode classique : seul le libellé est affiché dans la liste image.
Comme pour une liste, lors de la création d’un champ "Liste image", vous pouvez créer :
• une liste image dont le contenu est lié à un fichier ou une requête
• une liste image dont vous définissez le contenu par programmation
On appliquera les même règles que pour les listes pour choisir la méthode de remplissage.

124
En détail
4 Ouvrez la fenêtre "ChampListeImage.wdw".
4 Lancez le test de cette fenêtre.
Pour sélectionner plusieurs éléments dans une liste, l’option "multi-sélections" doit être cochée
Les éléments de la liste peuvent être triés. Dans ce cas, l'option "Liste triée" doit être cochée dans
la fenêtre de description de la liste (onglet "Détail").
Pour accéder à un élément d'une liste, il faut préciser son indice. Le premier élément d'une liste a
l'indice "1".
Remplir une liste image à partir d’un fichier ou d’une requête

Lors de la création d’un champ liste image remplie à partir d’un fichier ou d’une requête, vous
devez indiquer le fichier de l’analyse ou la requête qui servira de source de données pour le rem-
plissage. Ce fichier (ou cette requête) doit contenir :
• une rubrique qui correspondra au libellé de l’élément affiché dans la liste image
• une rubrique qui correspondra à l’image de l’élément affiché dans la liste image.

Notes
Ce fichier ou cette requête sera lu(e) automatiquement sans avoir à écrire une seule ligne de code.
De plus, lors de la sélection d’un élément de la liste, la valeur récupérée pourra être :
• soit l’indice de la ligne sélectionnée
• soit une valeur du fichier

125
Généralement, on choisit comme valeur récupérée une rubrique du fichier. Il s’agit le plus souvent
de la clé unique.
La clé de parcours que vous sélectionnez sert de tri pour le remplissage de la liste et donc indique
Lorsque la liste est créée, ses caractéristiques sont modifiables directement dans la fenêtre de
description du champ (option "Description" du menu contextuel).
Vous retrouverez tous les caractéristiques indiquées dans l’assistant.
Programmation
Remplir une liste image

Pour remplir une liste par programmation, il faut utiliser la fonction ListeAjoute. Par exemple :
ListeAjoute(ListeImage1,"image abandon.ico","abandon.ico")
//ajoute l’image "abandon.ico" et le libellé "Image abandon.ico"
// dans la liste image ListeImage1

Modifier une liste image par programmation
Pour modifier un élément dans une liste, il faut utiliser :
• soit la fonction ListeModifie
• soit les propriétés Valeur et Miniature sur l’élément à modifier.
//modifie l'élément en cours
ListeModifie(ListeImage1,"image abandon.ico","abandon.ico")
//modifie l'élément 1
ListeModifie(ListeImage1,"image abandon.ico","abandon.ico", 1)
// Modifie l’élément 2
LISTEImage1[2]..Valeur = "Image Aide.ico"
LISTEImage1[2]..Miniature = "Aide.ico"
Récupérer la valeur d’une liste image

Dans une liste image, il est possible de récupérer :
• le libellé de l’élément grâce à la propriété Valeur.
• l’image associée à l’élément, grâce à la propriété Miniature.

126
Type de champ : Combo
Résumé
Une combo est également appelée "combo box" ou encore "liste dérou-
lante". Comme pour une liste, lors de la création d’un champ "Combo",
vous pouvez créer :
• une combo dont le contenu est lié à un fichier ou une requête
• une combo dont vous définissez le contenu dans l’éditeur ou par
programmation
On appliquera les même règles que pour les listes pour choisir la
méthode de remplissage.
Caractéristiques d’une combo

La combo se déroule lorsque le champ est sélectionné. Il existe 2 types de combos :
• les combos dans lesquelles un élément peut être sélectionné dans la liste. Ces combos sont
appelées "combo sans saisie".

L'utilisateur déroule la liste pour sélectionner un élément.
• les combos dans lesquelles un élément peut être sélectionné dans la liste ou directement
saisi dans le champ de la combo. Ces combos sont appelées "combo avec saisie".
L'utilisateur peut au choix saisir une valeur ou bien dérouler la liste pour sélectionner un élé-
ment.
Le type de la combo se définit dans la fenêtre de description de la combo.
Attention !
Au contraire des listes, les combos ne sont pas multi-sélections : un seul élément
peut être sélectionné dans la combo.
Les éléments de la combo peuvent être triés. Dans ce cas, il faut cocher l'option "Contenu trié"
dans les paramètres de la fenêtre de détails.
Les combos peuvent contenir du texte et du graphisme. De plus, la partie déroulée de la combo
peut être sous la forme :
• d’une seule colonne.
• d’une table à plusieurs colonnes.
Remarque : Vous avez la possibilité de modifier la largeur et la hauteur de la combo une fois
déroulée !
En détail
4 Ouvrez la fenêtre "champliste.wdw".
4 Lancez le test de cette fenêtre. La combo du haut est sans saisie et triée, celle du bas est avec
saisie et triée.
127
Remplir une combo dans l’éditeur

La méthode de remplissage d’une combo dans l’éditeur est strictement identique à la méthode de
remplissage d’une liste.
Remplir une combo à partir d’un fichier ou d’une requête

La méthode de remplissage d’une combo à partir d’un fichier ou d’une requête est strictement
identique à la méthode de remplissage d’une liste.
Programmation
Remplir une combo

La programmation des combos est strictement identique à la programmation des listes mono-
sélection.
Pour remplir une combo, il faut utiliser la fonction ListeAjoute :
ListeAjoute(COMBO1,"Marie") //ajoute Marie dans la combo

Vous pouvez également utiliser un tableau :
//remplir la combo avec le contenu d'un tableau
i est un entier
//Prénom est un tableau de NbElem chaînes
Pour i=1 à NbElem
ListeAjoute(COMBO1, Prénom[i])
Fin
De même que pour les listes, les fonctions ListeAjoute, ListeInsere, ListeSupprime, ListeSupprime-
Tout, ... permettent d'ajouter, d'insérer ou de supprimer des éléments dans la combo.
Toutefois, la programmation est différente si la combo est définie "avec saisie" ou "sans saisie".
Cas d’une combo avec saisie

Pour affecter ou récupérer le champ d'une combo avec saisie, la syntaxe est la même que pour
affecter ou récupérer un champ de saisie :
//affecter la sélection de la combo
COMBO1 = "Marie"
//Récupérer la sélection de la combo

Ch est une Chaîne
Ch = COMBO1
Il n'est pas possible de récupérer l'indice de l'élément sélectionné dans une combo avec saisie. On
ne peut récupérer que la valeur de l’élément en cours de sélection dans la combo.
Cas d’une combo sans saisie

Pour récupérer l’élément sélectionné dans la combo, la méthode est similaire à une liste. Il faut uti-
liser la fonction ListeSelect pour récupérer l’indice de l’élément sélectionné. Ensuite, il faut utiliser

128
cet indice pour récupérer la valeur.

//Récupérer l'élément sélectionné
Ch est une chaîne
Indice = ListeSelect(COMBO1)
Ch = COMBO1[Indice]
//Récupérer le 3ème élément de la liste
Ch est une Chaîne
Ch = COMBO1[3]
Pour sélectionner un élément, il faut utiliser la fonction ListeSelectPlus.
Type de champ : Table
Résumé
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 (visualisation 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 (ou d’une table).
Ouf !
Les tables WinDev permettent de visualiser ou de modifier des données :

• en mémoire : on parle alors de table mémoire ou table remplie par programmation.
• provenant de fichiers : on parle alors de table reliée à un fichier ou à une requête.
L'avantage des tables est de pouvoir visualiser plusieurs données dans une seule fenêtre.
En détail
4 Pour savoir comment gérer une table mémoire, ouvrez la fenêtre "champtable.wdw".
La gestion des tables est différente selon s’il s’agit d’une table mémoire ou d’une table reliée à un
fichier ou une requête.
Nous allons détailler les deux types de champs table.
Table mémoire (remplie par programmation)

Le comportement d’une table mémoire est très proche d’un champ liste. Cependant, à la diffé-
rence d’un champ liste, une table peut être constituée de plusieurs colonnes.
Dans une table mémoire, chaque ligne de la table est identifiée par un indice.
Pour la ligne comme pour la colonne, il faut préciser l'indice. Si l'indice n'est pas précisé, c'est la
ligne sélectionnée qui est concernée.
• Une table peut être manipulée ligne par ligne ou colonne par colonne.
• Une table peut être en saisie ou en affichage.
• Une table peut être en mono-sélection ou en multi-sélections.

129
Pour ajouter une ligne dans une table, il faut utiliser la fonction TableAjouteLigne. Cette fonction
admet en paramètre le nom de la table et le contenu de la ligne. Dans la ligne, chaque valeur de
colonne est séparée par "une virgule".
//ajout d'une ligne dans sa totalité
TableAjouteLigne("TABLE1","Lundi","Œuf meurette",...
"Blanquette", "Glace vanille")
//ajout d'une ligne colonne par colonne
TableAjouteLigne("TABLE1")//ajoute la ligne vide
JOUR = "Lundi "
ENTREE = "Œuf meurette"
PLAT = "Blanquette"
DESSERT = "Glace"
La fonction TableModifieLigne modifie une ligne de la table (soit la ligne en cours, soit la ligne dont
le numéro d'indice est précisé).
La fonction TableSelect retourne l'indice de la ligne en cours (sélectionnée) ou l’indice d’une des
lignes sélectionnées dans le cas d’une table multi-sélections.

La fonction TableSelectPlus permet de sélectionner par programmation une ligne de table en fonc-
tion de son indice et/ou de sélectionner plusieurs lignes.
Une ligne de table est supprimée avec la fonction TableSupprime. La fonction TableSupprimeTout
vide toute la table mémoire.
Une table peut être :

• en affichage : aucune colonne n'est en saisie.
• en saisie : au moins une colonne est en saisie.
Ces options sont définissables au niveau de chaque colonne (onglet "Détail" de chaque
colonne dans la fenêtre de description de la table).
L'état d'une table ou de chaque colonne de la table est défini sous l'éditeur, il peut être modifié par
programmation avec la propriété Etat.
Table reliée à un fichier ou une requête
Lors de la création d’un champ table, dans le cas où vous sélectionnez dans l’assistant une table
remplie à partir d’un fichier ou d’une requête, vous devez indiquer le fichier de l’analyse ou la
requête qui servira de source de données pour le remplissage.

Notes
Ce fichier ou cette requête sera lu automatiquement sans avoir à écrire aucune ligne de code.
De plus lors de la sélection d’une ligne de la table, la valeur récupérée pourra être :
• soit une rubrique de la table,
• soit une rubrique du fichier même si elle n’est pas affichée.

130
Généralement, on choisit la valeur récupérée correspondant à une rubrique du fichier. Il s’agit le

plus souvent de la clé unique du fichier.
La clé de parcours que vous sélectionnez sert de tri pour le remplissage de la table et indique donc
Par exemple, vous pourrez visualiser dans une table les produits et le libellé des produits à com-
mander.
Lorsque la table a été créée, ses caractéristiques sont modifiables directement dans la fenêtre de
description de la table (option "Description" du menu contextuel, onglet "Contenu").
Vous retrouverez toutes les options indiquées dans l’assistant.

Une table reliée à un fichier ou a une requête peut être mono-sélection ou multi-sélections.
Dans les titres de colonnes, une loupe peut apparaître. Cette loupe permet de faire une recher-
che dans le fichier à partir de la valeur qui est saisie.
Il s’agit plus précisément d’un positionnement dans le fichier. Si vous décidez de "scroller", vous
parcourez la totalité du fichier.
De plus, des flèches peuvent également apparaître dans le titre des colonnes, cette flèche indique
que l’on peut trier la table sur la colonne.
Il faut noter que la loupe ou la flèche de tri sont visibles sur toutes les colonnes de
Notes
la table si celle-ci est remplie par programmation (table mémoire) ; par contre, la
loupe et la flèche ne sont visibles que sur les colonnes liées à une clé (index) pour
les tables reliées à un fichier ou une requête.
Caractéristiques des tables (fichier ou mémoire)

4 Testez la fenêtre "champtable.wdw".
Et si vous effectuez un clic droit sur la table, le menu contextuel par défaut s’affiche :
Les options "Graphique" et "Calculs automatiques" sont disponibles uniquement si le clic droit a été
effectué sur une colonne de type numérique
Voici quelques astuces pour optimiser le look de vos tables :

131
• Pour utiliser un titre de colonne multi-lignes, il suffit de cocher l’option "Titre de colonne
multi-lignes" dans l’onglet "Détail" de la fenêtre de description du champ Table.
• Pour utiliser une couleur de fond dégradée, affichez l’onglet "Style " de la fenêtre de descrip-
tion du champ. Sélectionnez l’élément "Cadre extérieur", puis sélectionnez le cadre de type
"Dégradé".
Pour plus de détails sur le fonctionnement d’une table fichier ou mémoire, consultez l’aide en ligne
(mot-clé : "Table").
Type de champ : Arbre
Résumé
Aussi appelé champ "Liste arborescente" ou champ "Treeview", un champ Arbre est comparable à
une liste dont le contenu est classé hiérarchiquement. Plus simplement, les données sont classées
comme lorsque vous utilisez l’explorateur de fichiers de Windows.
En détail

Le champ Arbre est géré par programmation. Les fonctions du W-Langage qui permettent de pro-
grammer un arbre commencent par Arbre... .
Ces fonctions sont comparables aux fonctions de gestion des tables remplies par programmation.
Par exemple, ArbreAjoute, ArbreSupprimeTout, ArbreSupprime, ArbreSelect, …
Il est également possible de manipuler le champ Arbre ligne par ligne pour modifier les propriétés
d’une ligne. Il est par exemple possible d’utiliser :
• la propriété Couleur pour modifier la couleur d’une ligne,
• la propriété CouleurFond pour modifier la couleur de fond d’une ligne,
• la propriété Police pour modifier les caractéristiques de la police d’une ligne,
• ...
Nous ne détaillerons pas les fonctions de manipulation des arbres. Pour plus de détails, consultez
l’aide en ligne (mot-clé : "Arbre, Manipuler un arbre par programmation").
Type de champ : Jauge
Résumé
Les jauges permettent de représenter la progression d’un traitement. La valeur de la jauge peut
être modifiée par programme. La jauge peut être horizontale ou verticale. Les couleurs et le décor
sont entièrement paramétrables.

132
En détail
4 Ouvrez et testez la fenêtre "champjauge.wdw".
4 Pour affecter le champ jauge avec une valeur, il suffit de faire une affectation, comme pour un
champ numérique.
JAUGE = 75
4 Pour définir les bornes minimales et maximales d’une jauge, utilisez les propriétés BorneMin et
BorneMax :
JAUGE..BorneMin = 0
JAUGE..BorneMax = 100
Voici le code du bouton "Exécution" qui permet de faire évoluer les jauges.
I est un entier
POUR I = 1 A 100
JaugeHorizontale1 = I
JaugeHorizontale2 = I
JaugeVerticale = I
JaugeImage = I
Multitache(1) // pour rafraîchir l’affichage
FIN
JaugeHorizontale1 = 0
JaugeHorizontale2 = 0
JaugeVerticale = 0
Type de champ : Ascenseur
Résumé
Dans les listes, dans les tables, ... des ascenseurs sont automatiquement affichés si nécessaires.
Dans certains traitements particuliers, il peut être intéressant de créer des champs de type "Ascen-
seur".
Le principe de gestion des ascenseurs est le suivant :
• la valeur de la cage de l'ascenseur (le petit carré qui bouge !) est récupérée dans une variable
• une valeur peut être affectée à cette cage.
Pour déplacer l'ascenseur, l'utilisateur peut cliquer sur un des boutons fléchés, ou déplacer directe-
ment la cage elle-même. L'utilisateur peut même cliquer entre la cage et les flèches pour avoir une
avance rapide.
En détail
Par défaut, l’ascenseur varie entre les valeurs 1 et 100. Chaque clic sur un des boutons fléchés
déplace de 1 la cage et chaque clic entre la cage et le bouton déplace de 10. Ces valeurs peuvent
être modifiées dans la fenêtre d'informations de l'ascenseur ou en programmation grâce aux pro-
priétés BorneMin, BorneMax et AvanceRapide.

133
4 Ouvrez et testez la fenêtre "champascenseur.wdw".

Les ascenseurs permettent de déplacer l'image dans la fenêtre.
Type de champ : Potentiomètre
Résumé
Un champ Potentiomètre correspond à un objet graphique circulaire ou
linéaire permettant de faire varier une valeur. La valeur en cours du poten-
tiomètre peut être récupérée dans le programme dans une variable et être
ainsi exploitée dans des calculs.
En détail
4 Pour affecter le champ potentiomètre avec une valeur, il suffit de faire
une affectation, comme pour un champ numérique.
POTAR = 75

4 Pour définir les bornes minimales et maximales d’un potentiomètre, utilisez les propriétés Bor-
neMin et BorneMax :
POTAR..BorneMin = 0
POTAR..BorneMax = 100
Type de champ : Spin
Résumé
Un champ Spin permet de gérer l’incrémentation et la décrémenta-
tion d’une valeur. Un Spin est constitué de 2 boutons collés.
Contrairement à un bouton, si l’on clique sur le champ Spin et que
l’on garde le bouton de la souris enfoncé, l’événement de clic est
répété automatiquement.
Type de champ : Onglet
Résumé
WinDev permet également de créer des fenêtres avec des onglets.
Dans ce cours, vous avez déjà vu l’intérêt des onglets. En effet, toutes les fenêtres de description
des champs et des fenêtres dans WinDev sont des fenêtres avec onglets. Un onglet permet de sai-
sir des informations regroupées par thèmes (Général, Détail, ...). On nomme ces thèmes des
"volets".

134
Un onglet permet de répartir les champs d’une fenêtre dans plusieurs volets afin de ne pas alourdir
la fenêtre. L’utilisateur ne voit les informations que par volet. Les champs sont classés suivant des
thèmes (un thème correspond à un volet d’un onglet).
Dans un onglet, les champs sont associés au volet auquel ils appartiennent.
Pour accéder aux champs d'un volet d’onglet, il suffit de cliquer sur le volet d’onglet correspondant.
Les champs sont actifs lorsque le volet est actif. A un instant donné, seul un volet d'un "onglet" est
visible dans son intégralité. Seul le titre des autres volets est visible.
En détail
Création d’un onglet
4 Créez une fenêtre vierge, donnez-lui le nom "ONGLET1". Cette fenêtre va vous permettre de
manipuler les onglets.
4 Pour créer les onglets, cliquez sur l'icone puis cliquez dans la fenêtre à l’emplacement où
l'onglet doit être créé. Un onglet à deux volets est créé par défaut.
4 Pour modifier la description de l'onglet, affichez le menu contextuel de l’onglet (clic droit de la
souris) et sélectionnez l'option "Description". La fenêtre de description de l'onglet s'affiche.

Les boutons "Nouveau" et "Insérer" permettent de créer de nouveaux volets.
Pour chaque volet, vous pouvez modifier les paramètres en cliquant dans la combo
"Catégorie" :
• "Général" pour modifier le libellé
• "Détails" pour modifier l'état d'affichage et l'image
• "Aide" pour modifier le message d'aide
Les onglets sont créés dans la fenêtre. Il reste à associer les champs à chaque onglet.
Créer les champs associés aux onglets
4 Créez un champ de saisie de type texte. Laissez le nom proposé par défaut.
4 1.
Pour associer le champ à un onglet, deux solutions :
En déplaçant le champ :
•Cliquez sur l’onglet souhaité pour rendre un des volets actifs.
•Cliquez sur le champ à associer et déplacez-le vers le volet actif.
Le champ est alors directement associé à l’onglet et au volet d’onglet.
2. En utilisant le menu contextuel :
•Déplacez si nécessaire le champ à associer sur votre onglet.
•Cliquez avec le bouton droit de la souris sur le champ à associer, et choisissez l’option
"Associer à un onglet ..." du menu contextuel.
•Sélectionnez l’onglet et le volet d’onglet souhaité et validez.
Le champ est automatiquement associé à l'onglet et au volet d’onglet spécifié.
Un champ ne peut être associé qu'à un seul volet d’onglet. Le champ sera actif et visible lorsque le
volet d’onglet sera activé.
Créer les champs "hors onglets"

Un champ peut également être hors onglet. Le champ sera toujours actif, quel que soit l'onglet en

135
cours.
Par défaut lorsque vous créez un champ, celui-ci est associé à un onglet si et seulement s’il est
créé sur un onglet.
Pour qu'un champ soit "hors" onglet :
1. Faites un clic droit sur le champ, puis sélectionnez "Associer à un onglet ..." dans le menu
contextuel qui apparaît.
2. Choisissez "Aucun", puis validez.
Type de champ : Web caméra
Résumé
Un champ Web caméra permet de visualiser une source vidéo provenant d’une caméra extérieure
reliée à l’ordinateur.
Exemple
L’exemple "WD Webcam" livré avec WinDev montre l’utilisation d’un champ Web

caméra dans une fenêtre.
En détail
Les fonctions permettant de gérer le champ Web caméra commencent par VidéoXXX :
// Sauvegarde de la vidéo retransmise dans le champ Web
// Caméra "CAMCUISINE" sous forme d'un fichier AVI de 60 secondes
Res est un booléen = VidéoCapture(CAMCUISINE,...
"C:\Temp\MaVideo.AVI",...
viCaptureVidéo,60)
SI Res = Vrai ALORS
Info("Vidéo correctement sauvegardée")
SINON
Erreur("Impossible d’enregistrer la vidéo")
FIN
Notes
Seule la séquence vidéo actuellement retransmise peut être visualisée dans un

champ Web caméra.
Pour visualiser :
• une image capturée avec la fonction VidéoCapture, utilisez un champ Image.
• une séquence vidéo capturée avec la fonction VidéoCapture, utilisez un champ ActiveX per-
mettant de lire une vidéo.
4 Pour
che.
afficher en direct la vidéo en provenance de la Web caméra, utilisez la fonction VidéoAffi-
4 Pour comprendre le fonctionnement du champ Web caméra, vous allez simplement charger
136
une fenêtre exemple et l’exécuter.

4 Ouvrez et testez la fenêtre "CHAMPWEBCAMERA.WDW".
Attention : Une Web Caméra doit être accessible depuis le poste en cours.
Pour plus de détails sur les fonctionnalités des champs Web caméra et la syntaxe des fonctions
évoquées ici, consultez l’aide en ligne (mot-clé : "WEB, Champ Web Caméra").
Type de champ : OLE, ActiveX
Champ ActiveX
Résumé
Le champ ActiveX permet de gérer simplement les contrôles ActiveX. Les contrôles ActiveX sont des
composants réutilisables utilisant la technologie ActiveX et pouvant être intégrés dans une fenêtre.
En détail
Un ActiveX est associé à des propriétés et des méthodes. Ces propriétés et méthodes peuvent être
utilisées en W-Langage pour manipuler directement le champ ActiveX. Il suffit d'utiliser la syntaxe
Automation du W-Langage.
Par exemple :
// LecteurAVI est un champ ActiveX
LecteurAVI>>Zoom = 12 // Affectation d'une propriété
LecteurAVI>>Pause(10) // Appel de méthode
Pour connaître les propriétés et méthodes associées à un ActiveX, vous pouvez :

• soit consulter directement la documentation du contrôle ActiveX.
• soit utiliser l'utilitaire WDXVIEW livré avec WinDev.
Exemple
L’exemple "WD Navigateur" livré avec WinDev illustre l’utilisation d’un champ
ActiveX dans une fenêtre.
Champ OLE
Résumé
Le Champ OLE permet de manipuler un objet OLE.
Rappel : OLE est un protocole d'échange de données et de commandes dont le principe consiste à
imbriquer et lier des objets. Dès que l'objet incorporé est ouvert, la connexion client/serveur est
ouverte.
Un objet OLE est un fichier qui contient :

• la référence du Serveur OLE qui a créé l'objet.
• l'objet lui-même (image, document feuille ...).

137
En détail
Plus techniquement, un objet OLE correspond à des données encapsulées contenant des données
diverses telles que des textes, des images, des sons, ... L'encapsulation de données dans des
objets OLE permet d'incorporer ces objets sans avoir besoin de connaître leur structure.
WinDev est un client OLE. Les applications développées avec WinDev demandent des données,
affichent et stockent les objets OLE.
Les serveurs OLE mettent à disposition des objets aux clients qui en font la demande. Ce sont par
exemple Paint Brush, Excel, WinWord, ...
En tant que client, WinDev sait gérer des objets OLE. Il permet de :
• dessiner un objet dans un champ OLE. Un objet peut être par exemple une feuille Excel, une
image de Paint Brush ...
• éditer un objet OLE dans un champ OLE. L'objet OLE peut être :
- choisi sous l'éditeur ou par programmation.
- défini en fonction d'un serveur ou d'un fichier.
Remarques :
• En programmation, un champ OLE est manipulé par des fonctions spécifiques. Une applica-

tion WinDev ne peut pas être serveur OLE.
• OLE version 1 et OLE version 2 sont gérés (les versions supérieures ne sont pas gérées).
• Un objet OLE ne peut pas être imprimé avec WinDev. La mise à jour de l'objet s'effectue à la
demande.
• Un champ OLE ne peut contenir qu'un seul objet OLE.
Nous n’allons pas détailler le fonctionnement de ces deux types de champ.

Pour plus de détails, consultez l’aide en ligne (mots-clés : "OLE", "Champ OLE", "ActiveX (champ)").
Type de champ : Forme
Résumé
Les formes permettent de dessiner des éléments aux formes géométriques (cercle, ellipse, rectan-
gle, carré, ligne ou flèche). Un assistant de création de champs forme permet de définir toutes les
caractéristiques d’un champ forme :
• couleurs.
• formes, dimensions, ...
En détail
4 Pour obtenir un aperçu de ces champs, ouvrez et testez la fenêtre "champforme.wdw".
Type de champ : Champ Code-Barres
Résumé
Le champ Code-Barres permet d’afficher simplement des code-barres dans vos fenêtres. Il est ainsi
possible de visualiser directement le code-barres associé à un produit à l’écran.
Ainsi, il est possible par exemple de lire le code-barres d’un produit à l’aide d’un appareil spécialisé,
d’afficher le code-barres à l’écran, et d’enregistrer sa valeur dans un fichier de données.

138
Rappel : Il est également possible d’imprimer un code-barres :

• soit avec l’éditeur d’états qui propose un champ Code-barres
• soit par programmation (avec la fonction iImprimeCodeBarre).
Pour plus de détails, consultez l’aide en ligne.
Type de champ : HTML
Résumé
Un champ HTML permet d’intégrer une page HTML dans une fenêtre WinDev.
Type de champ : Bouton "Etat sur Table"
Résumé
Un champ "bouton état sur table" permet de créer automatiquement un état dont le contenu sera
celui d’une table de la fenêtre en cours.

Vous utiliserez ce type de champ lorsque vous souhaiterez tout simplement imprimer le contenu
d’un champ table d’une fenêtre.
L’état est créé automatiquement. Cet état a la même structure que le champ table (même colon-
nes et mêmes données)
Il faut bien évidemment un champ Table pour pouvoir utiliser le bouton "Etat sur table".
En détail
La méthode pour utiliser ce type de bouton est la suivante :
1. Ouvrez ou créez une fenêtre avec un champ Table.
2. Sélectionnez le champ Table en cliquant dessus.
3. Cliquez dans la barre d’outils des champs sur puis déplacez la souris dans la fenêtre
contenant la table (l’ombre du bouton est visible).
4. Cliquez dans la fenêtre pour insérer le bouton. L’état est créé automatiquement.
5. Validez le nom de l’état et enregistrez l’état.
6. Revenez sur la fenêtre et testez.
L’état est bien entendu modifiable. Il est possible de changer les styles, les polices, les titres. Nous
consacrerons plus loin dans ce guide un chapitre sur les états.
Type de champ : Superchamp
Résumé
Un superchamp est un type de champ avancé. Un superchamp regroupe un ensemble de champs
dans un but précis. Ces champs sont indépendants des traitements de la fenêtre les accueillant.
Avantage des superchamps : les superchamps sont des éléments indépendants et facilement réu-
tilisables quelle que soit la fenêtre où ils sont utilisés. Intégrables dans un dictionnaire, ils peuvent
être facilement transférés d'un projet à un autre (consultez la leçon “Dictionnaire”, page 419).

139
En détail
Exemple : Ces trois champs constituent un superchamp. Dans cet exemple, le bouton permet de
calculer automatiquement la date de fin, en fonction de la période choisie dans le menu contextuel
du bouton.
Un superchamp peut être composé de :

• tous les types de champs, avec toutes leurs caractéristiques (menu contextuel par exemple).
• procédures spécifiques. Ces procédures sont locales au superchamp et utilisables par tous
les traitements associés au superchamp ou à un de ses éléments.
• variables locales au superchamp et utilisables par tous les traitements associés au super-
champ ou à un de ses éléments.

WinDev propose des superchamps prédéfinis. Ces superchamps sont accessibles dans le Kouglof
après avoir sélectionné l’onglet avec "la baguette magique".
Type de champ : Champ Fenêtre interne
Résumé
Le champ Fenêtre interne permet d’inclure une fenêtre (et son code) dans une autre fenêtre.
A l’exécution, la fenêtre à fusionner sera dynamiquement fusionnée à la fenêtre de réception.
Ce champ permet de partager dynamiquement une même partie d’interface au sein d’une ou de
plusieurs applications.
La fenêtre à fusionner peut être issue d’un composant.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Fenêtre Interne").
Détail
Une fenêtre interne est une fenêtre spécifique (pas de barre de titre pas de menu, ...). Dans cette
fenêtre, vous pouvez mettre tout type de champs. Une fois enregistrée, cette fenêtre interne pourra
être utilisée dans n’importe quelle fenêtre de votre application par le biais du champ fenêtre

140
interne.
4 Ouvrez la fenêtre "fnListeOptions". Cette fenêtre utilise deux fenêtres internes : Fl_Param_Ini et
Fl_Param_Persist.
Ces deux fenêtres internes sont rendues visibles ou invisible selon la sélection réalisée dans le
champ arbre.
Pour créer une fenêtre interne, utilisez l’option "Fichier .. Nouveau .. Fenêtre", et sélectionnez
l’onglet "Fenêtre interne".
Pour utiliser une fenêtre interne dans une autre fenêtre, créer un champ fenêtre interne (option
"Insertion .. Spécial .. Champ Fenêtre Interne").
Type de champ : Barre d’outils
Résumé
Le champ Barre d'outils est un type de champ avancé, lié à une fenêtre. Une barre d'outils contient
plusieurs champs (bouton, champ de saisie, combo, ...) permettant à l'utilisateur de lancer rapide-
ment certaines fonctionnalités de son application. Une barre d'outils peut être :
• Ancrée : la barre d'outils est "collée" à un des bords de la fenêtre.
• Flottante : la barre d'outils est une fenêtre indépendante.
L'utilisateur peut changer la position de la barre d'outils en utilisant la souris.

En détail
Pour associer des champs existants à la barre d'outils :
Méthode 1 : Réalisez un "Drag and Drop" du champ vers la barre d'outils.
Méthode 2 : Dans la description de la barre d’outils (onglet "Général"), cliquez sur le bouton
"Ajouter" et sélectionnez le champ à ajouter à la barre d'outils. Appliquez les modifications, le
champ sélectionné est automatiquement positionné dans la barre d'outils.
Pour associer des nouveaux champs à la barre d'outils :
Méthode 1 : Réalisez un "Drag and Drop" du champ vers le champ "Barre d'outils".
Méthode 2 : Dans la description de la barre d’outils (onglet "Général"), cliquez sur le bouton
"Créer" et sélectionnez le type de champ à ajouter à la barre d'outils. Le champ sélectionné est
automatiquement créé dans la barre d'outils. Pour le modifier, utilisez le bouton "Editer" : la des-
cription du nouveau champ apparaît.
Remarque : L'espace entre les champs de la barre d'outils peut être configuré dans l'écran "Détail"
de la description de la barre d'outils.

141
Type de champ : Champ au format RTF
Résumé
Le format RTF (Rich Text Format) permet de coder d'une manière spécifique le texte et les graphi-
ques afin de faciliter leur transfert d'une application à une autre.
Le format RTF est un format dit "à balises". En effet, des balises spécifiques permettent de spéci-
fier le style de chaque mot, groupe de mots ou phrases présents dans le texte au format RTF.
WinDev permet de manipuler du texte au format RTF grâce à l'option "Texte avec mise en forme"
des champs de saisie et des libellés.
• Si le texte au format RTF est affiché dans un champ ne reconnaissant pas le format RTF, les
balises seront affichées.
• Si le texte au format RTF est affiché dans un champ reconnaissant le format RTF, les balises
seront automatiquement interprétées et le texte sera mis en forme.
Le champ de saisie RTF permet aussi bien d'afficher un texte au format RTF que de saisir un texte
au format RTF. Lors de la saisie d'un texte dans un champ RTF, ce texte est au format RTF. Ce texte

contient toutes les balises permettant de formater le RTF.
Remarques :
• Si vous saisissez un même texte dans un champ de saisie classique et dans un champ de
saisie RTF, la taille de la chaîne de caractères présente dans le champ sera supérieure pour
le champ de saisie RTF (car les balises RTF sont ajoutées).
• Le champ de saisie RTF permet de gérer un format RTF basique, permettant une utilisation
quelle que soit la plate-forme. Les caractères spécifiques tels que les sauts de page, les
notes ... ne sont pas gérés.
Type de champ : Champ Séparateur
Résumé
Le champ Séparateur permet de découper une fenêtre en plusieurs zones distinctes. Ces zones
sont redimensionnables par l’utilisateur lors de l’exécution de la fenêtre.
Pour que les champs suivent automatiquement le redimmensionnement de la zone, aucune pro-
grammation n’est nécessaire : il suffit de définir l’ancrage des champs de chaque zone (option
"Ancrage" du menu contextuel du champ).
En détail
4 Pour obtenir un aperçu du champ séparateur, ouvrez et testez la fenêtre "ChampSépara-
teur.wdw".

142
Type de champ : Champ Graphe
Résumé
Le champ Graphe permet d’inclure simplement un graphique dans une fenêtre. La source de don-
nées de ce champ peut être :
• définie par programmation
• un fichier ou une requête
• une colonne de table
• un champ Liste
• un tableau W-Langage
Il est possible de réaliser plusieurs types de graphes en 2 ou 3 dimensions :

• Secteurs,
• Histogramme,
• Boursier
• Courbe,
• Nuage de points.
Pour chacun des types de graphes, des options d'affichage permettent d'avoir des rendus diffé-
rents.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Champ Graphe").
Détail
4 Ouvrez la fenêtre "ChampGraphe". Cette fenêtre utilise un champ Graphe. Les données de ce
graphe sont définies par programmation grâce à la fonction grAjouteDonnées.
La fenêtre de description du champ Graphe permet de définir les principaux paramètres du
champ.
Type de champ : Zone répétée
Résumé
Les zones répétées permettent de répéter "n" fois un ensemble de champs. Lors de cette répéti-
tion, les champs de la zone répétée peuvent afficher des informations différentes. Il est ainsi possi-
ble d’afficher, à chaque répétition, des enregistrements d’une base de données.
Les zones répétées peuvent être de deux types :
• Zone répétée mémoire : la zone répétée est remplie par programmation.
• Zone répétée fichier : la zone répétée est remplie à partir d’un fichier de données ou d’une
requête, automatiquement, sans une seule ligne de code.
Pour chaque champ de la zone répétée, plusieurs caractéristiques peuvent être modifiées lors de
la répétition : valeur, libellé, couleur du texte, état, ...

143
La zone répétée peut être déplacée comme un champ. Lors de son déplacement, tous les champs
associés à la zone répétée se déplacent en même temps.
Lors de la création d’une zone répétée, il est possible de définir le nombre de colonnes qui seront
affichées. Cette option permet d’obtenir une répétition horizontale dans la limite du nombre de
colonnes indiqué. Lorsque le nombre de colonnes est atteint, une nouvelle répétition verticale est
ajoutée.
En détail
La gestion des zones répétées est différente s’il s’agit :

• d’une zone répétée mémoire,
• d’une zone répétée reliée à un fichier ou une requête.
Nous allons détailler les deux types de zones répétées existant.
Zone répétée mémoire

Une zone répétée peut contenir plusieurs champs (libellé, champ de saisie, image, ...). Chacun des

champs de la zone répétée peut être associé à un attribut.
Cet attribut permet de modifier une propriété du champ associé (sa valeur, son libellé, sa couleur,
sa visibilité, ...). Il est également possible de créer un attribut dans la zone répétée sans que celui
ne soit associé à un champ : on parle alors d’attribut libre (cet attribut peut contenir la valeur d’un
compteur par exemple).
Le comportement d’une zone répétée mémoire est très proche d’un champ Table.
Dans une zone répétée mémoire, chaque ligne de la zone répétée est identifiée par un indice.
Pour ajouter une ligne dans une zone répétée (code serveur), il faut utiliser la fonction ZoneRépé-
téeAjouteLigne. Cette fonction attend en paramètre :
• le nom de la zone répétée,
• les valeurs des attributs (dans l’ordre) séparées par des virgules :
//Ajout d’une ligne dans la zone répétée
//La zone répétée contient 4 attributs, associés respectivement
//aux champs : LIBMAQUETTE, IMGMAQUETTE, QUANTITE, PRIXUNI
ZoneRépétéeAjouteLigne(ZoneRépétée1, ...
"Maquette n°1", "IMAGE_MAQUETTE1.JPG", 10, 45.65)
La fonction ZoneRépétéeModifieLigne modifie une ligne de la zone répétée (code serveur).

Une ligne de zone répétée est supprimée avec la fonction ZoneRépétéeSupprime (code serveur).
Zone répétée reliée à un fichier ou une requête

Lors de la création d’un champ zone répétée fichier vous devez indiquer le fichier de l’analyse ou la
requête qui servira de source de données pour le remplissage.
Ce fichier ou cette requête sera lu automatiquement sans avoir à écrire aucune ligne de code.
La clé de parcours sélectionnée sert de tri pour le remplissage de la zone répétée et indique donc

144
Par exemple, vous pourrez visualiser dans une zone répétée :

• la photographie d’un produit
• la description du produit
• le prix du produit
• ...
Les caractéristiques d’une zone répétée sont disponibles dans la fenêtre de description de la zone
répétée (menu contextuel, option "Description").
Pour plus de détails sur le fonctionnement d’une zone répétée fichier ou mémoire, consultez l’aide
en ligne (mot-clé : "Zone répétée").

145
LEÇON 3.5. OPTIMISEZ VOS INTERFACES

• Mise en place des champs sous l’éditeur de fenêtres.

• Styles, look de vos interfaces.

146
Manipulations sous l’éditeur de fenêtres

Ordre de saisie des champs (ou ordre de navigation)
L'ordre de saisie des champs est l'ordre dans lequel l’utilisateur pourra saisir 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 être modifié :
• soit en donnant un ordre de saisie automatique : le premier champ en saisie 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.
4 Pour définir un ordre de navigation automatique, sélectionnez l'option "Fenêtres .. Ordre de

navigation .. Définir en automatique".
4 Pour éditer l’ordre de saisie des champs, sélectionnez l’option "Fenêtres .. Ordre de
navigation .. Editer" :
4 1.
Pour définir un ordre de saisie par sélection :
Sélectionnez les champs dans l'ordre de saisie que vous souhaitez tout en maintenant la
touche [CTRL] enfoncée.
2. Sélectionnez l'option "Fenêtres .. Ordre de navigation .. Définir par la sélection".
Vous pouvez visualiser l'ordre de saisie des champs en maintenant appuyée la touche [F5].
Etat d’un champ

L’état d’un champ correspond à la façon dont est affiché le champ. Le champ peut être :
• en saisie
• en affichage seul
• grisé
Pour définir cet état, affichez la fenêtre de description du champ (onglet "Détail").

147
Par programmation, il est également possible de modifier l’état d’un champ. Il suffit d’écrire :
NomDuChamp..Etat = Actif //ou Grisé ou AffichageSeulement
Modification de la taille d’une fenêtre

4 1.
Pour agrandir une fenêtre :
Cliquez sur un des bords de la fenêtre sans relâcher le bouton de la souris (le curseur se
transforme en double-flèche).
2. Déplacez la souris de façon à obtenir la taille souhaitée.
3. Relâchez le bouton de la souris quand la fenêtre est à la dimension voulue.
Cette opération est réalisable sous l’éditeur et en exécution.
Ancrage des champs dans une fenêtre

L’ancrage permet de lier la taille et/ou la position des champs à la taille de la fenêtre. Si l’utilisa-
teur de l’application a la possibilité de modifier la taille (largeur et hauteur) de la fenêtre, vous pour-
rez lier certains champs de la fenêtre à ce redimensionnement.

Le champ pourra :
• se déplacer
• s’agrandir
• rester tel quel
L’ancrage peut être mis en place en faisant un clic droit sur un champ et en sélectionnant
"Ancrage" dans le menu contextuel :

148
Il ne faut pas mettre systématiquement l’ancrage sur tous les champs d’une fenê-
tre. Il faut choisir judicieusement les champs et les fenêtres sur lesquels l’ancrage
est utile.
Par exemple, dans une fenêtre contenant un champ Table, il peut être intéressant
Notes
de lier le redimensionnement de la table lorsque la fenêtre s’agrandit.

Autre cas, une image contenant une photo pourra aussi être redimensionnée si la
fenêtre est agrandie.
Par contre, on évitera de redimensionner des champs de saisie, les boutons, les
sélecteurs ou les interrupteurs.
L’ancrage est symbolisé par des flèches rouges sur les côtés du champ :
Une aide pour les champs

L'aide dans une application est très importante. Elle va permettre à l'utilisateur de se servir avec
facilité de l'application.
L'aide peut être à plusieurs niveaux :
• générale à l'application.
• associée à chaque champ.
• associée à chaque fenêtre.
L’aide peut être au format :

• WinHelp (.HLP).
• HTML (.CHM).
Nous allons nous intéresser ici à l'aide associée à chaque champ.

L'aide d'un champ peut être affichée :
• dans la barre de message de la fenêtre.
• dans une bulle.

149
L'aide associée au champ est décrite avec l'onglet "Aide" dans la fenêtre de description du champ.

Message d'aide
Pour afficher un message d'aide, la fenêtre doit comporter une barre de message (option "Barre de
message" dans l’onglet "Style" de la fenêtre de description de la fenêtre).
Le message s'affiche lors du survol ou de l’activation d’un champ s’il comporte un message d’aide.
Il reste affiché jusqu'au prochain message.
Notes
Si la barre de message de la fenêtre est multi-cases, le message d’aide s’affi-

chera dans la case spécifiée lors de la description de la barre de messages.
Il convient d’utiliser le message d’aide lorsque son texte n’excède pas une ligne. Il permet de don-
ner des informations supplémentaires sur les données en cours de saisie.
Le message d'aide d'un champ peut être modifié avec la propriété Message :
SAISIE1..Message = "Le nom ne doit pas dépasser 25 caractères"
Bulle d'aide
La bulle d'aide s'affiche lorsque le champ est survolé avec la souris. Elle reste affichée tant que le
curseur de la souris est positionné sur le champ.
Il convient d’utiliser la bulle d’aide lorsque son texte n’excède pas quelques mots. Les bulles d'aide
sont particulièrement intéressantes pour les boîtes à outils ou les barres d'icones, leurs icones
étant petits et souvent sans libellé.

150
Le texte de la bulle d'aide d'un champ peut être modifié avec la propriété Bulle :
BOUTON10..Bulle = "Quitter"
Les bulles d’aide peuvent être multi-lignes. Les bulles d'aide peuvent être désactivées ou réactivées
avec la fonction BulleActive. Il est possible de modifier la couleur de fond de la bulle grâce à la fonc-
tion BulleCouleur.
Permuter des types de champs entre eux

Certains types de champs sont très proches par leur forme et leurs fonctionnalités : il arrive donc
parfois que l’on confonde un "Interrupteur" avec un "Sélecteur", une "Liste" avec une "Combo".
Dans le menu de l’éditeur de WinDev, il est possible très simplement de permuter deux types de
champs similaires afin d’éviter de les recréer.
L’option est accessible dans le menu de l’éditeur dans l’option "Champ .. Permuter".
Le clonage de champ par programmation

On est encore loin du clonage humain mais WinDev est capable de cloner des champs !
La fonction ChampClone permet de dupliquer un champ déjà décrit dans une fenêtre ou dans un
état. Cette fonctionnalité est très utile et évite de créer des tableaux de champs dont le nombre
d’occurrences serait statique.
Exemple : créer une liste de boutons au comportement générique (avec utilisation de la P.O.O.).
Pour plus de détails, consultez l’aide en ligne (mot-clé : "ChampClone").
Eventuellement, mettez des champs "hors écran" et clonez-les dans la zone visi-
Astuce
ble de la fenêtre (en précisant leurs coordonnées dans les paramètres de Champ-
Clone).
La feuille de styles et les styles

Un style est un ensemble de paramètres (couleurs, polices, ...) concernant l'aspect des champs. A
chaque type de champ correspond une série de styles différents.
Il existe plusieurs styles pour chaque type de champs. L'ensemble de tous les styles constitue la
feuille de styles.
La feuille de styles du projet est rattachée au projet. L'ensemble de styles est sauvegardé dans un
fichier ayant pour nom "<nom_projet>.STY".
Lors de la création d'un champ, un style est proposé par défaut. Le style proposé est celui qui est
décrit dans les options du projet lors de la sélection du gabarit appliqué au projet.
Quel que soit le type du champ, un style du gabarit est proposé.
Il est bien entendu possible de modifier ensuite le style du champ. Il faut, dans ce cas, faire un clic
droit sur le champ et sélectionner dans le menu contextuel l’option "choisir un style".

151
Modifier le style d’un champ

Depuis la fenêtre de sélection d'un style, vous pouvez modifier, créer ou supprimer un style.
4 Pour modifier un style, sélectionnez le style et cliquez sur le bouton "Modifier" et modifiez les
caractéristiques du style.
4 Pour supprimer un style, sélectionnez le style et cliquez sur le bouton "Supprimer" (tous les
champs qui utilisaient ce style verront automatiquement leur style remplacé par le style "stan-
dard").
Tous les champs rattachés à ce style seront automatiquement modifiés.
4 Pour créer un style, sélectionnez un style s'approchant du style à créer et cliquez sur le bouton
"Créer".
Pensez à donner un nom au nouveau style (dans l’onglet "Général" de la fenêtre

Astuce
de description du style). Affecter ce nouveau style à un autre champ sera alors

d’autant plus facile que le nom est explicite !

Selon les options choisies, un aperçu du style créé est automatiquement mis à jour.
Validez lorsque le style vous convient.
Il est également possible de modifier la couleur, la police... d'un champ, sans modifier le style : on
dissocie alors le champ du style.
4 1.
Pour modifier le style du champ sans affecter la feuille de styles :
Sélectionnez le champ à modifier.
2. Cliquez avec le clic droit de la souris, le menu contextuel s'affiche.
3. Sélectionnez "Description" puis cliquez sur l’onglet "style".
4. Modifiez les caractéristiques du style du champ avec les options proposées.
5. Validez. Dans la fenêtre qui s’ouvre, vous pouvez dissocier le style du champ, ou ajouter le
nouveau style au projet.
Il est déconseillé de dissocier le style d’un champ. En effet, lorsque un champ est
dissocié :
Astuce
• ce champ ne sera pas lié à la feuille de styles

• les modifications de la feuille de styles n’affecteront pas ce champ
• tout changement de gabarit par programmation ne changera pas ce champ.
4 Pour rattacher le champ à un style, il suffit de sélectionner de nouveau un style pour le champ.
Lorsqu'un style d'un champ n'est pas trouvé dans la feuille de styles en cours du projet, il est possi-
ble de :
• conserver le style en le dissociant de la feuille de styles.
• intégrer ce style à la feuille de style en cours.

152
• remplacer ce style par le style standard défini pour ce champ.

Notes
Il est possible de visualiser rapidement les différents styles utilisés par les
champs d’une fenêtre grâce à l’option "Fenêtre .. Editer les styles utilisés".
Persistance des champs

La persistance des champs consiste à mémoriser la dernière valeur saisie dans un champ. Cette
valeur est automatiquement proposée à l’ouverture de la fenêtre par l’utilisateur.
Seule l’option "Mémoriser la valeur" dans l’onglet "Détail" de la fenêtre de description du champ
doit être cochée. Cette option permet de conserver la dernière valeur saisie par l’utilisateur dans
un champ, et de la proposer à la prochaine ré-ouverture de la fenêtre.
Ces valeurs sont conservées par défaut dans la base de registres, mais les fonctions W-Langage
InitParamètre, SauveParamètre, SupprimeParamètre et ChargeParamètre permettent de configu-

rer la manipulation de ces valeurs (sauvegarde dans un fichier INI, un fichier XML, ...). Pour plus de

153
LEÇON 3.6. DESCRIPTION DES FENÊTRES

• La description d’une fenêtre.
• La barre de message d’une fenêtre.
• Les plans d’une fenêtre.
• Les traitements associés à une fenêtre.

154
Introduction
Lors de la création d’une fenêtre, il est nécessaire de donner un nom à la fenêtre et un titre. Le
nom sera manipulé par programmation. Le titre sera visible dans la barre de titre lors de l’affichage
de la fenêtre en exécution.
Vous comprenez donc bien l’importance de ces deux paramètres.
Ne pas appeler les fenêtres avec le nom par défaut "Fenêtre1", ... Il est conseillé
de donner un nom explicite à la fenêtre. Ce nom peut être composé de plusieurs
mots mais SANS caractère espace. Le caractère Espace n’est pas facilement
manipulable par programmation.
Toutefois, n’exagérez pas trop sur la longueur du nom de la fenêtre même si ce
Astuce
nom est limité à 255 caractères !

Utilisez des mots simples, courts et surtout significatifs.
Par exemple, pour une fenêtre servant à faire la saisie des commandes pour un
client :
Ne pas faire : "Fenêtre de saisie des commandes du client"

Faire : "CommandeClient"
Les onglets de description d’une fenêtre

Voyons maintenant ensemble en détail les différentes caractéristiques modifiables lors de la créa-
tion d’une fenêtre.
Nous allons détailler les différents onglets relatifs à la description d’une fenêtre.
Onglet "Général"
Dans cet onglet, on indique le nom, la description, et le titre de la fenêtre. Nous avons déjà précisé
à quoi servait le nom et le titre, nous n’y reviendrons pas.
La description est purement indicative pour le développeur. Elle permet de résumer un peu plus
longuement ce à quoi sert la fenêtre. Elle sert également à décrire la fenêtre lors de l’impression
du dossier.
Onglet "IHM"
Dans cet onglet, de très nombreuses informations sont regroupées. On retrouve les caractéristi-
ques concernant :
• La taille et la position de la fenêtre
• Le menu contextuel de la fenêtre
• Le curseur de survol et l’action du clic droit sur la fenêtre, ...
Onglet "Détail"
Dans cet onglet, les paramètres spécifiques au fonctionnement de la fenêtre sont regroupés. On
retrouve les caractéristiques concernant :
• Le type de la fenêtre

155
• L’animation de la fenêtre en ouverture et / ou en fermeture

• Exécution automatique d’un bouton de la fenêtre
• Le contexte Hyper File lié à la fenêtre, ...
Onglet "Image"
Cet onglet permet de définir les différentes images utilisées par la fenêtre :
• l’image de fond de la fenêtre et des barres d’icones associées à cette fenêtre en mode MDI. Cette
image est modifiable également par programmation avec la propriété ImageFond.
• L’image de la poignée de redimensionnement de la fenêtre.
• L’icone associé à la fenêtre est visible dans le coin en haut à gauche de la fenêtre au niveau de la
barre de titre. Il personnalise la fenêtre. Si aucun icone n’est indiqué, c’est l’icone associé au pro-
jet qui sera visible.
Onglet "Langue"
Cet onglet permet d’indiquer les différentes langues à gérer dans la fenêtre (Cas des projets "multi-
langues". Pour plus de détails, consultez la leçon “Applications multilingues”, page 159).

Onglet "Note"
Cet onglet permet de saisir du texte. Ce texte est imprimé lors de l’édition du dossier. Vous pouvez
par exemple, saisir des informations concernant le fonctionnement de la fenêtre, les différentes
règles de gestion des traitements effectués.
Onglet "Aide"
Cet onglet permet d’indiquer le nom du fichier d’aide contextuelle associé à la fenêtre. Ce fichier
d’aide est utilisé lors de l’appui sur le bouton d’aide de la fenêtre pour activer une aide contextuelle
au clic sur la fenêtre.
Onglet "Style"
Cet onglet regroupe les paramètres relatifs au style de la fenêtre. On peut sélectionner :
• le gabarit
• les icones affichés (agrandissement, réduction, aide, menu système, …)
• le type de bordure
• la couleur de fond
• le thème XP
• l’opacité (permet de définir la transparence d’une fenêtre)…

156
La barre de message d’une fenêtre

Une fenêtre peut afficher une barre de message simple ou multi-cases.
4 Pour afficher une barre de message dans la fenêtre en cours, sélectionnez l’option "Fenêtres ..
Barre de message .. Avec barre de message". La barre de message est alors affichée sous l’édi-
teur.
4 1.
Pour modifier la description de la barre de message, ajouter des cases, ... :
Affichez le menu contextuel de la barre de message sous l’éditeur.
2. Sélectionnez l’option "Description". La fenêtre de description de la barre de message appa-
raît.
Il est possible d’afficher dans la barre de message d’une fenêtre :

• un message d’information lié au champ en cours.
Ce message est saisi dans l'onglet "Aide" de la fenêtre de description du champ.
Le message sera affiché dans la barre de message lorsque l'utilisateur sélectionnera le
champ.
• un message d’information spécifique. Ce message est affiché par programmation grâce à la

fonction Message.
• une jauge de progression. Cette jauge est affichée par programmation grâce à la fonction
Jauge.
Les barres de message multicases permettent d’afficher automatiquement certaines

informations :
• Date
• Heure
• Colonne et ligne du curseur de souris
• Etat de la touche [MAJ]
• Etat de la touche [INSER]
• Nom de l’utilisateur (dans le cas d’une application utilisant le groupware utilisateur
Les plans d’une fenêtre

Afin de limiter le nombre de fenêtres dans un projet, il est possible d’utiliser des plans dans une
fenêtre. Sur une même fenêtre, vous pouvez gérer différents écrans (un seul est visible à la fois)
que vous pouvez faire "défiler" en fonction des actions de l’utilisateur. Ce type de fenêtre (fenêtre
avec plans) est très souvent utilisé dans les fenêtres dites "Assistant". Des boutons "Suivant" et
"Précédent" permettent de passer d’un plan à un autre.
Exemple
L’exemple "WD Assistant" livré avec WinDev montre l’utilisation des plans dans
une fenêtre.

157
Les plans sont très faciles à manipuler. En effet, lorsque vous souhaitez décrire un nouvel écran
sans changer de fenêtre, utilisez la touche [PageSuivante] pour passer au plan suivant, et la touche
[PagePrécédente] pour passer au plan précédent. Par défaut, le premier plan d’une fenêtre est
nommé "Plan 0". Chaque plan suivant est numéroté, "Plan 1", "Plan 2", ...
Pour simplifier la manipulation des plans sous l’éditeur de fenêtres, le numéro du

Notes
plan en cours est affiché sous l’éditeur de fenêtres (dans la fenêtre d’accueil de la
fenêtre).
Par programmation, il est également possible de modifier le plan en cours d’une fenêtre :
// Code de clic du bouton PRECEDENT
MaFenêtre..Plan = MaFenêtre..Plan - 1
// Code de clic du bouton SUIVANT

MaFenêtre..Plan = MaFenêtre..Plan + 1
MaFenêtre est un mot-clé qui retourne le nom de la fenêtre qui contient le traite-

Notes
ment où est exécuté MaFenêtre. Il peut être utilisé dans les traitements des
champs de la fenêtre, les traitements de la fenêtre et également dans les procé-
dures locales de la fenêtre.
Traitements associés à une fenêtre

Plusieurs traitements sont associés à une fenêtre :
Déclarations globales
Exécuté lors de l’ouverture de la fenêtre avant que celle-ci ne soit visible. Ce traitement contient par
exemple les déclarations des variables globales, les initialisations de champs et de variables, ...
Initialisation
Exécuté lors de l’ouverture de la fenêtre avant que celle-ci ne soit visible mais APRES le traitement
d’initialisation des champs de la fenêtre.
Fermeture
Exécuté lors de la fermeture de la fenêtre. Il contient par exemple une instruction pour retourner un
résultat, ...
Prise de focus
Exécuté à chaque fois que la fenêtre passe en saisie (la fenêtre prend le focus). Lorsque la fenêtre
prend le focus, sa barre de titre devient bleue (ou d’une autre couleur selon ce qui a été choisi dans
le panneau de configuration de Windows).

158
Perte de focus
Exécuté à chaque fois que la fenêtre perd le focus. Lorsque la fenêtre perd le focus, sa barre de
titre devient grise (ou d’une autre couleur selon ce qui a été choisi dans le panneau de configura-
tion de Windows).
Modification de la taille
Exécuté à chaque fois que la taille de la fenêtre est modifiée (iconisée, maximisée, retour à sa taille
normale, ...).

159
LEÇON 3.7. APPLICATIONS MULTILINGUES

• Qu’est-ce qu’une application multilingue ?
• Etape par étape, la création d’une application multilingue.
Vous trouverez dans le répertoire "\Autoformation\Corriges\International" le projet

"International.WDP" contenant les illustrations de cette leçon.

l’option "? .. Guide d’auto-formation .. Application multiligue".

160
Qu’est-ce qu’une application multilingue ?

C’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.
Pour voir un exemple d’application Internationale, sélectionnez l’option "? .. Guide d’auto formation
.. Application multilingue". Pour changer la langue, utilisez l’option "Fichier .. Langue".
Les principales étapes d’une application multi-langue sont :

• Le choix des langues du projet.
• L’internationalisation de l’analyse.
• L’internationalisation des fenêtres et des champs.
• L’internationalisation des états.

• L’internationalisation des menus.
• L’internationalisation des messages présents dans le code.
• La programmation du changement de langue dans l’application.
Etape par étape

Choix des langues du projet
4 Ouvrez le projet "INTERNATIONAL.WDP" (dans le sous-répertoire "Autoformation\Corriges\Inter-
national" du répertoire d’installation de WinDev 10).
L’analyse associée est "STOCK". Vous pouvez vérifier cette information dans la description du
projet (option "Projet .. Description du projet .. onglet Analyse").

161
La première opération consiste à choisir les langues du projet.

4 Cliquez
cas).
sur l’onglet "Langues", puis sélectionnez le français et l’anglais (si ce n’est pas déjà le
Cet écran permet également de définir les options linguistiques utilisées par défait pour cha-
que langue du projet (séparateur de décimales, ...).

4 Validez en cliquant sur "OK".
Internationalisation de l’analyse
Par défaut, une analyse est créée dans une langue et ne peut être traduite. Cependant, certaines
informations peuvent être saisies dans plusieurs langues (notes du dossier, informations parta-
gées, ....).
Les champs créés à partir des rubriques de l’analyse ont par défaut le libellé de la rubrique spécifié
dans l’analyse. Ce libellé n’est pas multilangue. 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.
Pour gérer plusieurs langues dans une analyse :

1. Dans la description de l’analyse (option "Analyse .. Description de l’analyse"), sélectionnez
l’onglet "International".
2. Indiquez les différentes langues gérées par l’analyse, et validez.
Pour saisir les informations partagées dans plusieurs langues :

1. Affichez la description des rubriques d’un fichier (option "Structure de fichiers .. Rubriques").
2. Pour chaque rubrique, 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.

162
Internationalisation des fenêtres et des champs

4 Ouvrez la fenêtre "Fiche_CLIENT.WDW". Les libellés des champs et des boutons sont traduits en
français et en anglais.
Par exemple, le bouton "Imprimer" :

163
Si les images associées aux champs images, aux boutons, ... contiennent un texte
à traduire, il est possible de spécifier une image différente pour chaque langue du
Astuce
projet.
Si une aide est associée aux champs et/ou fenêtres, n’oubliez pas de saisir cette
aide dans toutes les langues !
Si le système d’exploitation gère plusieurs langues (Hébreux, Arabe, Grec, ...) lors
Notes
de la saisie des traductions dans ces langues, l’alphabet correspondant est auto-
matiquement utilisé.
Internationalisation des états

De même que les fenêtres, les états peuvent être multilingues.
Pour cela, il suffit de saisir tous les libellés de l’état dans les langues souhaitées.
Internationalisation du menu

La traduction des options d’un menu peut être réalisée directement à partir de l’éditeur de fenê-
tres.
Pour traduire le menu d’une fenêtre :
1. Ouvrez la fenêtre "MenuInternational.WDW".
2. Sélectionnez l’option "Affichage .. Langue affichée ..." et sélectionnez la langue à visualiser
sous l’éditeur.
Les options de menu s’affichent dans la langue sélectionnée. Si aucune traduction ne corres-
pond à la langue sélectionnée, les options de menu s’affichent en français.
3. Saisissez directement le libellé des options de menu dans la langue sélectionnée.
Traduction des messages de programmation

Tous les messages de votre programme peuvent également être saisis dans plusieurs langues.
4 Dans
ter".
la fenêtre "MENUINTERNATIONAL", affichez le code de l’option de menu "Fichier .. Quit-
A côté du libellé de la fonction OuiNon figure un icone représentant un drapeau : .

4 Cliquez sur cet icone pour accéder à l’éditeur de messages.
4 La fenêtre de traduction des messages s’affiche.
Cette fenêtre permet de saisir tous les messages de votre programme dans toutes les langues
du projet.
Un numéro est attribué à chaque message.

164
Pour accéder à cette fenêtre de traduction lors de la saisie d’un nouveau message, il suffit de :
• sélectionner le message
• choisir l’option "Traduire" du menu contextuel.
Le bouton "Traduire", présent dans le bas de la fenêtre ( ) permet de se connecter un logiciel
externe de traduction, de lui passer en paramètre le message à traduire et de récupérer la traduc-
tion automatiquement. Ce logiciel peut être paramétré dans les options de WinDev (option "Outils
... Options de WinDev ... Traduction").
Après avoir saisi toutes les traductions des différents éléments de votre application, voici comment
gérer le passage d’une langue à l’autre par programmation.
Programmation du changement de langue
Par défaut, le projet s’exécute dans la première langue définie pour le projet.
La fonction Nation permet de changer de langue.
Dans une application, le choix de la langue peut être défini selon deux méthodes :
• mémorisation de la langue dans un fichier de paramètres propre à l’application
• sélection de la langue par une option de menu.
Utilisation d’un fichier de paramètres

Dans le cas d’un fichier de paramètres, le choix de la langue est totalement transparent pour l’utili-
sateur. La langue est choisie lors de l’installation du projet et pourra être modifiée par la suite.
Le fichier de paramètre du projet "INTERNATIONAL.WDP" s’appelle "INTERNATIONAL.INI". Il est dans
notre cas très simple puisqu’il se limite à une seule ligne contenant la langue du projet.
Pour déterminer la langue dans laquelle s’exécutera l’application, il est nécessaire de lire ce fichier
de paramètres dans le traitement d’initialisation du projet. Le traitement est le suivant :
Langue est une chaîne; NomFic est une chaîne
//Lecture du fichier de paramètres

165
NomFic = "INTERNATIONAL.INI"
Langue = INILit("PARAMETRE", "LANGUE", "FRANCAIS", NomFic)
SELON Langue
CAS "FRANCAIS" : Nation(NationFrançais)
CAS "ANGLAIS" : Nation(NationAnglais)
FIN
Ce traitement nécessite quelques commentaires :

• La langue choisie est lue dans le fichier "INTERNATIONAL.INI"
• La fonction Nation permet de modifier la langue d’exécution du projet.
• La constante passée en paramètre à la fonction Nation correspond à la langue choisie.
Il est nécessaire d’utiliser la fonction Nation dans le traitement d’initialisation du projet, car le
changement de langue sera effectif dans la prochaine fenêtre qui s’ouvrira.
En effet, si la fonction Nation est appelée dans le code d’ouverture de la première fenêtre du pro-
jet, cette fenêtre sera dans la langue par défaut et le changement de langue ne sera effectif que
pour les autres fenêtres.
Par contre, si la fonction Nation est appelée dans le code d’initialisation du projet, la première fenê-

tre du projet sera dans la langue sélectionnée par la fonction Nation.
Utilisation des options de menu
Dans le menu de la fenêtre "MENUINTERNATIONAL.WDW", l’option "Fichier .. Langues" permet de
changer la langue. Le code associée à ces options est le suivant :
- - Choix menu : &Fichier..&Langue.....&Français
Nation(NationFrançais)
Utilise(MenuInternational)
- - Choix menu : &Fichier..&Langue.....&Anglais
Nation(NationAnglais)
Utilise(MenuInternational)
La fonction Utilise permet de recharger la fenêtre passée en paramètre. Le changement de langue

effectué par la fonction Nation est donc immédiatement effectif.
4 Testez le projet.
Le fichier "INTERNATION.INI" contient par exemple "ANGLAIS". Ainsi le menu s’affiche en
anglais, de même que le titre de la fenêtre.
Gestion des alphabets spécifiques

Si votre application gère des langues utilisant des alphabets spécifiques (grec, coréen, ...), changer
par programmation :
• l'alphabet utilisé par toutes les polices écran (fonction ChangeAlphabet). Cet alphabet pourra
également être utilisé pour les données enregistrées dans les fichiers Hyper File. Pour plus de
détails, consultez l’aide en ligne (mot-clé : Multilangue).
• la langue du clavier manipulé par les utilisateurs de l'application (fonction ChangeClavier).

166
Les outils WDMSG et WDINT

Par défaut, les messages d’erreur des DLL de WinDev sont en français. Il est possible de traduire
tous les messages des DLL de WinDev avec l’outil WDINT (non fourni en standard avec WinDev).
Il existe également un outil nommé WDMSG (non fourni en standard avec WinDev) qui permet
d’une part d’extraire tous les messages d’un projet (libellé des champs, message de code, titre des
fenêtres, ...) pour les traduire, et d’autre part d’intégrer les messages traduits.
Pour obtenir plus d’informations sur WDINT et WDMSG, contactez le Service Commercial de
PC SOFT.

PARTIE 4
Base de données et analyse

169

• Vocabulaire utilisé.
• Les différents modes d’accès aux bases de données.
Partie 4 : Base de données et analyses

170
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 (ou tables) contenant les données de l’applica-
tion.
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 que
seront stockées les données.
Notes
Plusieurs outils de maintenance des fichiers de données (Hyper File) sont livrés en
standard avec WinDev. Ils sont accessibles depuis le centre de contrôle Hyper File.
WinDev sait gérer différents formats de base de données (pour ne pas dire tous). Les plus couran-
tes sont :
• Hyper File, système de base de données intégrée à WinDev et livrée en standard. La base de
données Hyper File est disponible en mode Classic ou Client/Serveur.
• AS/400, Access, Sybase, ...
• Oracle, SQL Server, MySQL, xBase, …
• Toute base accessible en langage SQL sous Windows.
• Texte (fichiers ASCII).
Pour accéder aux données, il existe différentes techniques (appelées "modes d’accès") :
• Accès Natif
• Accès OLE DB
• Accès ODBC direct
• Accès ODBC via OLE DB
Les différents mode d’accès aux bases de données

Accès Natif
Un accès natif manipule directement et exclusivement un format de base de données. Ce type
d’accès optimisé est développé spécialement pour chaque format de base de données.
Dans WinDev, il existe un accès natif pour les bases de type :
• Hyper File Classic ou Client/Serveur (en standard)
• xBase (en standard)
• Access (en standard)
• XML (en standard)
• Oracle (optionnel)
• AS/400 (optionnel)
• SQL Server (optionnel)
• Sybase (optionnel)

171
• Informix (optionnel)
• DB2 (optionnel)
• Progress (optionnel)
• MySQL (optionnel et gratuit)
D’autres accès natifs seront bientôt disponibles, contactez notre service commercial !
Les fonctions W-Langage SQL* et HLit* sont utilisables avec ce type d’accès. Le code est ainsi por-
table et indépendant de la base de données.
Accès ODBC direct

Un accès via ODBC direct utilise un standard d’accès multi-bases. Vous devez installer la couche
ODBC 32 bits sur votre machine. Cette couche est en général déjà installée sur les versions récen-
tes de Windows. Vous pouvez le vérifier dans le panneau de configuration de Windows en choisis-
sant l’option "Administrateur ODBC".
Attention : toutes les bases de données ne sont pas obligatoirement accessibles via cette méthode.
Si vous souhaitez utiliser ce type d’accès, vérifiez qu’il existe un pilote ODBC.
Seules les fonctions W-Langage 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 W-Langage 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 W-Langage SQL* et HLit* sont utilisables avec ce type d’accès.
Quel accès utiliser ?

4 Pour obtenir plus d’informations sur les différents modes d’accès aux bases de données et
savoir quel type d’accès utiliser, sélectionnez l’option "? .. Aide à l’utilisation des bases de don-
nées" dans le menu de WinDev.

172
Qu'est ce qu'une application et une analyse ?

Une application est un projet ou un ensemble de projets (programme exécutable) qui peut utiliser
une base de données. Plusieurs applications peuvent utiliser la même base de données.
La base de données est l'ensemble des fichiers (ou "tables") sur lesquels vont être faites des opéra-
tions de gestion des données : stockage, extraction, mise à jour, consultation de données, ...
Pour travailler sur une base de données, il faut décrire les fichiers constituant la base. L'ensemble
de la description est appelée "analyse". L'analyse regroupe les descriptions des fichiers de don-
nées, leurs relations, les contraintes d’intégrité.
Les fichiers de données sont manipulés par une ou plusieurs applications.

Un application est créée à partir d'un projet.
Le projet est un ensemble logique d'objets et de traitements dont le but est de réaliser un objectif
donné.
Si le projet gère des fichiers de données, le projet est directement associé à l'analyse dans laquelle
sont décrits les fichiers.
Lors de la création d’un projet, trois cas peuvent se présenter :

• Projet avec création d’une analyse : l’analyse sera créée au moment de créer le projet. La
structure des fichiers sera donc créée avec le projet.
• Projet lié à une analyse déjà existante : l’analyse a déjà été créée (par exemple lors de la
création d’un précédent projet). Le nouveau projet va simplement être relié à cette analyse.
L’analyse n’est pas dupliquée. Il n’y a qu’une seule analyse commune pour plusieurs projets.
• Projet sans analyse.
Hyper File
Le format Hyper File (Classic ou Client/Serveur) est le format de base de données fourni avec Win-
Dev. Ce format de base de données est commun à WinDev, WebDev, et WinDev Mobile.
Sous WinDev Mobile, vous utilisez une base de données Hyper File Mobile.
Ce format est identique au format Hyper File Classic de WinDev standard (fichier
".WDD", fichiers de données, ...).
Cependant, la taille disponible sur un Pocket PC étant restreinte et le système
d’exploitation du Pocket PC étant limité, les fonctionnalités suivantes ne sont pas
gérées par Hyper File Mobile :
Notes
• les transactions.
• la journalisation.
• la réplication Hyper File.
• la gestion des blocages des fichiers et des enregistrements.
• la gestion des fichiers au format Hyper File 5.5.
Sous WinDev Mobile, vous pouvez également utiliser Hyper File Client / Serveur.
Vous pouvez donc partager une analyse pour une application développée en WinDev (Back Office),
en WinDev Mobile (application des commerciaux), et en WebDev (Front Office).

173
Il s’agit d’un SGBD Relationnel redistribuable gratuitement.

Notes
Hyper File a déjà été déployé sur plusieurs millions de sites dans le monde !
Rubriques d’un fichier

La description d’un fichier consiste à décrire la structure de l’enregistrement qui sera écrit dans le
fichier. Les rubriques (ou "colonnes") découpent l’enregistrement. WinDev propose différents types
de rubriques :
• Texte ou Mémo texte
• Numérique ou Monétaire
• Date ou Heure
• Interrupteur ou Sélecteur
• Liste ou Combo
• Image
• Mémo binaire
• ...
Certains de ces types de rubriques sont classiques (texte, numérique, date, heure). D’autres types

plus évolués existent également.
Par exemple, une rubrique de type "sélecteur" ou "interrupteur" est assimilée à un numérique.
Avantage de ce type de format : lors de l’ajout d’un champ lié à cette rubrique dans une fenêtre, le
champ de la fenêtre sera converti automatiquement en une case à cocher (interrupteur) ou en une
liste de valeur (sélecteur). Vous n’aurez donc pas à penser à faire cette conversion lors de la créa-
tion de la fenêtre.
Définition des clés

La notion de clé fait partie des paramètres d’une rubrique. En fait, lors de la création d’une rubri-
que, vous avez la possibilité d’indiquer si elle est :
• non clé,
• clé unique,
• clé avec doublons.
Les clés permettent d’accélérer les accès aux données ou de faciliter les parcours de fichiers.
Une clé unique est une rubrique clé dont la valeur est unique dans l’ensemble du fichier (c’est-à-
dire tous les enregistrements du fichier).
Une clé avec doublons est une rubrique clé dont la valeur peut être retrouvée plusieurs fois dans le
fichier.
Il existe un autre type de clé : la clé composée. Une clé composée est une clé qui est composée de
plusieurs rubriques du même fichier.
Ce type de clé permet de parcourir le fichier sur des critères plus complexes ou de faire des recher-
ches plus précises.

174
Définition des relations (contraintes d’intégrités)

Les relations correspondent à la description de la liaison entre les clés de deux fichiers. La relation
caractérise les contraintes sur la liaison de ces clés, représentées par les "cardinalités".
Par exemple, la relation entre les fichiers "CLIENT" et "COMMANDE" est
la suivante :
1. Le "CLIENT" passe des "COMMANDES". Le client peut ne passer
aucune commande comme il peut en passer plusieurs (contrainte
représentée par [0;n]).
2. Une "COMMANDE" est passée par un CLIENT et un seul (contrainte
représentée par [1;1]).
La clé de liaison entre les deux fichiers est "CLCLEUNIK". C’est elle qui
permet d’établir une relation entre un "CLIENT" et une "COMMANDE".
L’éditeur d’analyses permet de créer automatiquement les liaisons

entre les fichiers (option "Structure de fichiers .. Créer automatique-
ment les liaisons").
Nous détaillerons dans la leçon suivante comment créer une liaison
entre deux fichiers de données.

175
LEÇON 4.2. DÉFINITION D’UNE ANALYSE

• Création d’une analyse.

• Création de la description de fichiers de données.
Vous trouverez dans le répertoire "\Autoformation\Corriges\Catalogue produit" le pro-

jet "Catalogue produit.WDP" contenant les illustrations de cette leçon.
l’option "? .. Guide d’auto-formation .. Catalogue Produits".

176
Présentation
Dans cette leçon, afin de faire simple, nous travaillerons avec une analyse contenant deux fichiers
de données. L’application que vous allez utiliser permet de gérer un catalogue de produits.
Vous allez découvrir et maîtriser les concepts fondamentaux pour gérer des fichiers de données.
Ces concepts seront alors acquis pour la suite de ce cours.
Description du projet
Comme vous l’avez appris au tout début de ce guide, pour créer un programme, il faut décrire un
projet.
Ce projet va regrouper tous les objets constituant le programme : fenêtres, états, requêtes, ... Ce
projet va nous permettre de créer un exécutable.
4 Sélectionnez l'option "Fichier .. Nouveau", puis survolez "Projet" et cliquez sur "Exe". L’assistant
de création de projet se lance.
4 Saisissez le nom du projet "Catalogue Produit". Le répertoire du projet est initialisé par défaut
"Mes Projets\Catalogue Produit" puis validez en cliquant sur "Suivant" :
Description de l'analyse et des fichiers
4 Cliquez sur "Suivant" jusqu’à atteindre l’écran "Analyse utilisée par le projet".
4 Choisissez l'option "Créer une Analyse" : cette option signifie que l'analyse associée au projet
n'a pas encore été décrite. Nous allons le faire immédiatement après la création du projet.

177
4 Cliquez sur "Terminer".

L’assistant de création d’analyse démarre automatiquement.

Création de l’analyse
Dans l’assistant de création d’analyse :
4 Le nom de l’analyse "Catalogue Produit" est proposé par défaut.

4 Confirmez le nom et le répertoire de l’analyse en cliquant sur le bouton "Suivant". Cliquez à nou-
veau sur le bouton "Suivant".
Vous allez maintenant décrire la structure des fichiers de données de l’analyse.
Décrire un fichier
L’assistant pour créer une description de fichier démarre.
L’assistant vous propose :
• soit de créer un nouveau fichier
• soit d’ajouter un fichier prédéfini (à partir d’une sélection de fichiers disponible dans WinDev)
• soit d’importer des fichiers (provenant d’une autre base de données par exemple)

178
4 Sélectionnez "Créer une nouvelle description de fichier" :
Cliquez sur "Suivant".

4 Donnez le nom du fichier, ici "Produit" :
"Produit" est le nom que vous utiliserez pour manipuler le fichier en W-Langage.
"Un enregistrement représente" indique l’information qui sera utilisée pour décrire les liaisons
entre fichiers. Il est important de renseigner avec soin cette information !
"Le fichier possède un identifiant automatique" indique si le fichier doit posséder une clé unique,
gérée automatiquement par WinDev.

179
Pour créer l'identifiant du produit (un identifiant est une clé unique), vous pouvez
créer une rubrique numérique de type "Identifiant automatique".
Cet identifiant est automatiquement géré par WinDev. Chaque fois qu’un enregis-
trement est ajouté dans le fichier, WinDev affecte automatiquement une valeur à
Notes
l'identifiant du fichier. Cette valeur est unique.
Vous pouvez décocher ce choix si vous n'avez pas besoin d'identifiant automati-
que (si aucune clé unique n'est nécessaire, ou si une clé unique existe déjà dans
le fichier).

D'autres éléments (comme le type du fichier, l’abréviation du fichier, le répertoire) sont renseignés
par défaut, mais nous ne nous attarderons pas sur ces éléments dans cette leçon.
Dans la fenêtre qui s'ouvre vous allez décrire la structure du fichier, c’est-à-dire que vous allez défi-
nir toutes les rubriques qui constituent le fichier :
Remarquez qu'une rubrique existe déjà en première ligne de la structure du fichier : c’est l'identi-
fiant du fichier que nous avons demandé précédemment. Cette rubrique est de type "Identifiant
automatique" et est positionnée par défaut comme clé unique. Son nom est : "IDProduit". Le nom
est constitué d’une racine "ID" suivie du nom du fichier.

180
Notes
Le nom de la rubrique "Identifiant automatique" peut être modifié directement

dans le tableau des rubriques du fichier.
Notre fichier "Produit" est très simple, il est constitué de :

• l'identifiant du produit (déjà créé)
• la rubrique "Libellé" qui contient le libellé du produit sur 80 caractères
• la rubrique "PrixUnitaireHT" qui contient le prix du produit hors taxe
Le tableau permet de saisir les principales caractéristiques des rubriques du fichier : le nom, le
libellé, le type de la rubrique et sa taille.
La partie droite et la partie inférieure de la fenêtre permettent de saisir les informations concernant
la rubrique sélectionnée dans la liste.
Dans la partie droite, vous saisissez les caractéristiques spécifiques de la rubrique : les caractéris-
tiques de la clé (si la rubrique est une clé), ainsi que les informations, qui seront utilisées par les
autres modules de WinDev : RAD, dossiers, fenêtres, états ... C’est un des avantages de l’environ-
nement intégré de WinDev.
Dans la partie basse (qui apparaît en cliquant sur la double flèche), vous saisissez les informations
concernant le champ relié à la rubrique. Ces informations seront automatiquement utilisées lors de
la création des fenêtres contenant cette rubrique.
4 Placez- vous sur une nouvelle ligne du tableau (si nécessaire).

4 Saisissez "Libellé" pour le nom de la rubrique et "Désignation du produit" comme libellé. Par
défaut, le type de cette nouvelle rubrique est "Texte". Nous conservons ce type.
4 Dans le tableau, remplacez la taille proposée par défaut par "80".
4 Sélectionnez la ligne suivante du tableau.
4 Saisissez de la même façon la rubrique "PrixUnitaireHT" comme indiqué ci-après.

181
Notez que WinDev propose différents types de rubriques. Pour plus de détails sur la description de
chaque type de rubrique, consultez l’aide en ligne (mot-clé : "Rubrique, Types disponibles").
Méta-type
Un méta-type est une combinaison de caractéristiques d’une rubrique et de son
champ relié. Par exemple, un méta-type "Fax" contiendra le type et la longueur de
la rubrique, le masque de saisie, le cadrage, ...
Notes
Vous pouvez utiliser les rubriques méta-types fournies avec WinDev, ou créer vos
propres méta-types.
Pour utiliser une rubrique méta-type, il suffit de cliquer sur le bouton "Méta-types"
dans la description des rubriques de l’analyse.
4 Terminez la description de fichier en cliquant sur le bouton "OK".

4 Sélectionnez l’option "Retourner sous l’éditeur de WinDev" et validez (bouton "Terminer")
L’analyse est automatiquement validée et générée.
La génération de l'analyse consiste à rendre disponible aux autres modules du projet, les informa-
tions sur les fichiers. Ces fichiers pourront être manipulés dans les programmes.
Sans la génération, bien que la description du fichier existe, vous ne pourrez pas utiliser le fichier

dans vos programmes.
Lors de la génération de l’analyse, toutes les modifications effectuées sur l’analyse et les fichiers
de données seront automatiquement propagées dans tout le projet (fenêtres, champs reliés,
états, ...).
La génération doit être effectuée à chaque fois que vous voulez que les modifica-
tions effectuées dans l’analyse soient prises en compte dans les programmes uti-
Attention!
lisant cette analyse.

Si vous modifiez l'analyse plusieurs fois, sans programmer entre chaque modifica-
tion, il n’est pas nécessaire de générer l’analyse à chaque modification. Générez
uniquement l’analyse lorsque toutes les modifications sont faites et que vous pas-
sez à la programmation.
Lorsque la génération est terminée, la fenêtre suivante apparaît :

182
4 Sélectionnez "Aller directement dans l’éditeur de WinDev".

Remarque : l’option "RAD Application complète" sera détaillée dans le chapitre “Le RAD Projet”,
page 230.
Dans l’éditeur, l’analyse est affichée avec la représentation graphique du fichier "Produit" (ici l’ana-
lyse est très simple !).
Création d’une liaison dans l’analyse

Pour apprendre à créer une liaison dans l’analyse, nous allons tout d’abord créer un nouveau fichier
dans notre analyse.
Ce nouveau fichier est le fichier "Fournisseur". Nous pourrons donc ensuite créer une liaison entre le
fichier Produit et le fichier Fournisseur.
4 1.
Pour créer le fichier Fournisseur :
Dans l’éditeur d’analyse, sélectionnez l’option "Nouveau fichier" du menu contextuel (clic
droit sur le graphe de l’analyse).
2. Dans l’assistant de création d’un nouveau fichier, sélectionnez l’option "Sélectionner une
description parmi des fichiers prédéfinis". Cliquez sur "Suivant".
3. Sélectionnez le fichier "Fournisseur". Cliquez sur "Suivant".
4. Cliquez sur "Terminer". Le fichier "Fournisseur" est automatiquement créé dans l’analyse.
4 1.
Pour créer une liaison entre le fichier Produit et le fichier Fournisseur :
Dans l’éditeur d’analyse, sélectionnez l’option "Nouvelle liaison" du menu contextuel (clic
droit sur le graphe de l’analyse). Le curseur de la souris se transforme en crayon.
2. Cliquez sur le fichier "Fournisseur" puis sur le fichier "Produit". L’assistant de création d’une
liaison se lance.

183
3. Répondez aux questions posées par l’assistant :
•Chaque fournisseur a au moins un produit : Oui

•Chaque fournisseur peut avoir plusieurs produits : Oui
•Chaque produit a au moins un fournisseur : Non

•Chaque produit peut avoir plusieurs fournisseur : Non
4. Cliquez sur le bouton "Suivant". L’assistant propose automatiquement la clé utilisée par la
liaison. Cliquez à nouveau sur le bouton "Suivant".
5. L’assistant propose de créer une nouvelle clé dans le fichier Produit. Acceptez cette option
en cliquant sur le bouton "Suivant".
6. Validez les règles d’intégrité en cliquant sur "Suivant".
7. Cliquez sur "Terminer". La liaison est automatiquement créée dans l’éditeur d’analyse.
8. Générez l’analyse à nouveau (option "Analyse .. Génération").

Vous allez pouvoir commencer à programmer.

184
LEÇON 4.3. LES FICHIERS HYPER FILE

• Ajouts, modifications, suppressions d’enregistrements.

• Parcours simples, parcours imbriqués.
• Recherches simples, filtres de parcours.
Vous trouverez dans le répertoire "\Autoformation\Corriges\Catalogue produit" le pro-

jet "Catalogue produit.WDP" contenant les illustrations de cette leçon.
l’option "? .. Guide d’auto-formation .. Catalogue Produits".

185
Présentation
Dans la leçon précédente, nous avons décrit le fichier "Produit" et le fichier "Fournisseur".
Nous allons maintenant voir comment :
• créer physiquement le fichier de données "Produit".
• ajouter des données dans le fichier "Produit".
La gestion des données se fait simplement par l’intermédiaire des fenêtres de l’application. Win-
Dev propose plusieurs possibilités pour créer automatiquement les fenêtres associées au fichier.
Dans un but pédagogique, nous allons créer la fenêtre associée au fichier "Produit" de toute pièce.
Nous verrons dans la leçon sur le module RAD, page 230, que ce genre de fenêtres peut être auto-
matiquement créé par WinDev.
4 1.
Créez la fenêtre associée au fichier "Produit".
Créez une nouvelle fenêtre vierge (option "Fichier .. Nouveau .. Fenêtre").
2. Sélectionnez "Vierge"
3. Sélectionnez le gabarit "ActivOSX".
4. Cliquez sur "OK".
Vous allez créer les champs associés aux rubriques à l'aide du volet "Analyse".

4 Affichez si nécessaire le volet "Analyse" (option "Affichage .. Barres d’outils .. Analyse") et sélec-
tionnez l’onglet représentant l’analyse.
Vous pouvez afficher les rubriques soit sous forme de Treeview, soit sous forme de liste.
Pour plus de détails sur les volets, consultez l’aide en ligne (mot-clé : "Volet").
La liste des fichiers et des rubriques présents dans l’analyse associée au projet apparaît.
4 Sélectionnez la rubrique "Libellé" du fichier Produit dans la liste. Maintenez le bouton gauche
de la souris enfoncé et déplacez la souris vers la fenêtre vierge (cette opération est appelée un
"drag and drop"). Le champ correspondant à la rubrique est créé.
4 Répétez cette opération pour la rubrique "PrixUnitaireHT".
4 Donnez un nom et un titre à la fenêtre (par exemple "FicheProduit" et "Fiche d'un produit").
4 1.
Vérifions que chaque champ est rattaché à une rubrique du fichier.
Double-cliquez sur le champ "SAI_Libellé".
2. Cliquez sur l’onglet "Liaison". Le fichier de base est "Produit", la rubrique est bien "Libellé".

186
4 Sortez de la fenêtre en validant ou en annulant.

A quoi sert un champ lié à une rubrique ?

Un champ lié à une rubrique permet d'affecter directement le contenu du champ dans la rubrique
du fichier. Nous allons voir dans la suite de ce cours son intérêt (par exemple avec les fonctions
EcranVersFichier ou FichierVersEcran).
Création physique d’un fichier de données

Le fichier est décrit, mais il n'existe pas encore physiquement sur le disque. Il faut le créer par pro-
grammation.
• La fonction HCréation crée le fichier à vide (sans données). Mais attention, si le fichier existe
déjà, il est recréé à vide : les données existantes sont écrasées définitivement !
• La fonction HCréationSiInexistant crée le fichier à vide s'il n'existe pas ou bien ouvre le fichier
s'il existe déjà.
Notes
Généralement, la fonction HCréationSiInexistant est appelée dans le code d'initia-

lisation du projet.
Vous pouvez également spécifier un mot de passe à la création si votre fichier a été protégé lors de
sa description dans l’analyse (voir “Cryptage de données”, page 197).
4 Dans le menu, sélectionnez l’option "Projet .. Code du projet". Tous les traitements du projet
s'affichent.
Dans le traitement d'initialisation du projet, saisissez la ligne suivante.
HCréationSiInexistant(Produit, hOuvertureDifférée)

187
Notes
Le paramètre hOuvertureDifférée permet un gain de performances considérable

si vous devez créer plusieurs fichiers !
4 Fermez la fenêtre de code.

Ajouter un enregistrement
Les champs dans la fenêtre vont permettre de saisir les données. Pour enregistrer ces données
dans le fichier, nous allons ajouter un bouton.
4 Créez un bouton texte qui a par exemple le nom "BTN_AJOUTER" et le libellé "Ajouter".

4 Saisissez le code de clic de ce bouton :
EcranVersFichier()
HAjoute(Produit)
Raz()
HRaz(Produit)
Détaillons ce code :
• La fonction EcranVersFichier permet d’initialiser les rubriques avec les valeurs des champs liés.
Cette fonction est donc équivalente aux lignes suivantes :
Produit.Libellé=SAI_Libellé
Produit.PrixUnitaireHT=SAI_PrixUnitaireHT
Pour 2 champs reliés, l’intérêt est certes limité; pensez simplement aux fenêtres qui contiennent
plusieurs dizaines de champs : 1 seule ligne de code effectue toutes les affectations !
• La fonction HAjoute ajoute l’enregistrement dans le fichier. Cette fonction prend les valeurs en
mémoire et écrit le contenu des rubriques du fichier dans le fichier lui-même. Les index sont
immédiatement et automatiquement mis à jour.

188
Une valeur est automatiquement attribuée à l'identifiant automatique. Il ne faut

jamais modifier la valeur de l'identifiant dans un programme.
Lorsqu'un fichier contient une clé unique, dès qu'un enregistrement est modifié
ou ajouté, il faut vérifier que la clé n'existe pas déjà dans le fichier.
Si vous ajoutez un enregistrement et qu’il y a un doublon (2 fois la même valeur),
Attention !
une erreur est retournée.

Si la gestion automatique des erreurs est activée, une fenêtre apparaît deman-
dant à l’utilisateur de modifier la valeur saisie.
Si cette gestion n’est pas activée, il est nécessaire de tester l’erreur avec la fonc-
tion HErreurDoublon.
Dans le cas d'un identifiant automatique, l'unicité de la clé est automatiquement
vérifiée.
La fonction Raz remet à blanc tous les champs pour la prochaine saisie. Cela permet ainsi de signa-
ler à l’utilisateur que l'enregistrement a été ajouté.
La fonction HRaz remet à blanc toutes les variables de fichier (évite de conserver le buffer précé-
dent en cas d’ajout partiel de rubriques dans un enregistrement).
4 Ajoutez un bouton pour sortir de la fenêtre (bouton "BTN_Fermer", avec pour libellé "Fermer").
Saisissez le code de ce bouton (fonction Ferme). Enregistrez la fenêtre et testez-la.
4 Saisissez
vant :
des valeurs et cliquez sur le bouton "Ajouter". Saisissez par exemple le jeu d’essai sui-
Libellé Prix unitaire HT

Gomme 0,50
Stylo bille bleu 0,40
Crayon noir 0,25
Stylo "De Luxe Or massif" 158,00
4 Fermez la fenêtre pour revenir sous l'éditeur.

189
Visualiser les enregistrements saisis

Les champs permettent de saisir des données, mais aussi de visualiser les données issues du
fichier.
Nous allons saisir le code pour afficher les données.
4 Dans le menu, sélectionnez "Code .. Code de la fenêtre".

Dans le traitement d'initialisation de la fenêtre "FicheProduit", ajoutez les lignes suivantes :
HLitPremier(Produit, IDProduit)
SI HEnDehors(Produit) = Faux ALORS
FichierVersEcran()
FIN
Détaillons ce code :
• La fonction HLitPremier va lire le premier enregistrement du fichier selon la clé "IDProduit" et le
charge en mémoire.
• La fonction HEnDehors retourne "Vrai" si le fichier est vide.
• La fonction FichierVersEcran fonctionne selon le même principe que EcranVersFichier mais
effectue l'opération inverse. Cette fonction transfère le contenu des rubriques du fichier dans les
champs liés à ces rubriques.
La fonction FichierVersEcran est donc équivalente aux lignes suivantes :

SAI_Libellé = Produit.Libellé
SAI_PrixUnitaireHT = Produit.PrixUnitaireHT
Encore une fois, pour deux champs reliés, l’intérêt est certes limité; pensez simplement à une fenê-
tre qui contiendrait 40 000 rubriques et appréciez !
4 Enregistrez la fenêtre et testez-la.

L'enregistrement est lu et tous les champs sont initialisés.
Parcourir un fichier
Lorsque vous avez saisi plusieurs enregistrements (ou si plusieurs millions d’enregistrements sont
présents dans le fichier !), il faut pouvoir parcourir le fichier.
Le parcours de fichier s'effectue selon une clé, dans notre exemple selon le numéro de produit
("IDProduit").
Nous allons ajouter quatre boutons dans notre fenêtre pour :
1. Passer à l'enregistrement suivant.
L'enregistrement suivant est celui dont la valeur de la clé suit immédiatement la valeur de la clé
de l'enregistrement en cours.
2. Passer à l'enregistrement précédent.
L'enregistrement précédent est celui dont la valeur de la clé précède immédiatement la valeur
en cours.
3. Passer au premier enregistrement.
Le premier enregistrement est celui qui a la plus petite valeur de clé.
4. Passer au dernier enregistrement.
Le dernier enregistrement est celui qui a la plus grande valeur de clé.

190
Notes
Ce type de fenêtre peut être automatiquement généré par WinDev (option

"Fichier .. Nouveau .. Fenêtre", onglet "RAD" et fenêtre type "Fiche avec parcours").
4 Créez quatre boutons qui ont pour nom par exemple "BTN_PREMIER", "BTN_PRECEDENT",
"BTN_SUIVANT", et "BTN_DERNIER".
Le code de ces boutons sera :
//Bouton btn_premier : appeler le premier
HLitPremier(Produit, IDProduit)
SI HEnDehors(Produit)=Vrai ALORS
Info("Aucune fiche à visualiser")
SINON
FichierVersEcran()
FIN
//Bouton btn_précédent : appeler le précédent

HLitPrécédent(Produit, IDProduit)
SINON
FichierVersEcran()
FIN
//bouton btn_Suivant : appeler le suivant

HLitSuivant(Produit, IDProduit)
SINON
FichierVersEcran()
FIN
//Bouton btn_dernier : appeler le dernier

HLitDernier(Produit, IDProduit)
SINON
FichierVersEcran()
FIN
Nous connaissons déjà la fonction HLitPremier.

La fonction HLitDernier est basée sur le même principe, cette fonction va lire l'enregistrement qui a
la valeur de clé la plus grande.
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.
4 Enregistrez la fenêtre et testez-la. Parcourez le fichier en cliquant sur chacun des boutons.
191
Rechercher un enregistrement
Il faut également pouvoir accéder à un enregistrement donné sans avoir à parcourir tout le fichier.
La fonction HLitRecherche permet de rechercher un enregistrement selon sa valeur de clé. La
recherche est "générique" par défaut sur une rubrique de type texte (et bien évidemment à l’identi-
que pour une rubrique de type numérique).
4 Dans la fenêtre, créez un champ de saisie. Le nom de ce champ de saisie est par exemple
"SAI_Produit_recherché".
Ce champ de saisie est de type numérique et utilisera le masque de saisie "999 999".
Ce champ de saisie va permettre de saisir la valeur à rechercher.
4 Créez ensuite un bouton "Recherche" nommé par exemple "BTN_Recherche".
Ce bouton va permettre de lancer la recherche et d'afficher l'enregistrement trouvé. Le code de
ce bouton est le suivant :
HLitRecherchePremier(Produit, IDProduit, SAI_Produit_recherché)
SI HTrouve()=Vrai ALORS
FichierVersEcran()
SINON
Info("Aucun produit n’existe avec ce numéro")
FIN
Après une recherche, la fonction HTrouve retourne "Vrai" si un enregistrement correspond à la

recherche et "Faux" si rien n’a été trouvé.
Il existe également une autre fonction W-Langage permettant d’effectuer une recherche dans un
fichier de données. Cette fonction se nomme HLitRecherche.
Veillez à bien identifier le type de votre recherche avant d’utiliser les fonctions HLi-
tRecherche ou HLitRecherchePremier. En effet la différence entre ces deux fonc-
tions réside dans le fait que :
Attention!
• la fonction HLitRecherche effectue une recherche générique. Cette fonction

positionnera la variable HTrouve à "Vrai" si au moins une valeur de la clé de
recherche commence par l’élément recherché.
• la fonction HLitRecherchePremier effectue une recherche à l’identique. Cette
fonction positionnera la variable HTrouve à "Vrai" si au moins un enregistrement
est strictement identique à l’élément recherché.
Pour plus de détails sur ces fonctions, consultez l’aide en ligne (mot-clé : "Parcourir, Un fichier
Hyper File").
4 Enregistrez la fenêtre et testez-la. Saisissez une valeur de recherche (par exemple la valeur "3",
si vous avez au moins saisi trois enregistrements), puis cliquez sur le bouton "Recherche".

192
Supprimer et modifier un enregistrement

Tous les enregistrements du fichier peuvent être modifiés ou supprimés après avoir été créés.
Pour supprimer ou modifier un enregistrement, celui-ci doit être chargé en mémoire, c'est-à-dire
qu'il doit avoir été lu avec une fonction HLitRecherche, HLitSuivant, ...
4 Créez un bouton de suppression ("BTN_Supprimer") dont le code est le suivant :

// On vérifie que le fichier n’est pas vide

SI HNbEnr(Produit)=0 ALORS RETOUR
SI OuiNon("Confirmez-vous la suppression de cette fiche?") ALORS
HSupprime(Produit)
// le code suivant permet de se positionner sur
// l’enregistrement suivant si il existe
HLitSuivant(Produit, IDProduit)
SI HEnDehors(Produit) = Faux ALORS
FichierVersEcran()
SINON
// pas de suivant afficher le dernier s'il existe
HLitDernier(Produit, IDProduit)
SI HEnDehors(IDProduit) = Faux ALORS
FichierVersEcran()
SINON
// Ni suivant, ni dernier, vider les champs
RAZ()
FIN
FIN
FIN
La fonction HNbEnr permet de connaître le nombre d'enregistrements d’un fichier.

La fonction HSupprime supprime l'enregistrement en cours.
Après la suppression, il faut lire un autre enregistrement pour recharger un enregistrement en
mémoire. C’est ce que fait la fonction HLitSuivant.

193
4 Créez un bouton de modification ("BTN_Modifier") dont le code est le suivant :

SI HNbEnr(Produit)=0 ALORS RETOUR
EcranVersFichier()
HModifie(Produit)
SI ErreurDétectée ALORS
SI HErreurDoublon() ALORS
Erreur("Une erreur de doublons est survenue")
FIN
SI HErreurIntégrité() ALORS
Erreur("Une erreur d’intégrité est survenue")
FIN
SINON
Info("Modification effectuée")
FIN
La fonction HModifie modifie l'enregistrement en cours dans le fichier avec le nouveau contenu des
variables de fichier (qui ont été affectées par la fonction EcranVersFichier).
La variable ErreurDétectée permet de savoir si il n’y a eu aucun problème lors de la modification.
Dans ce cas, cette erreur peut être une erreur d’intégrité ou de doublons. Il est nécessaire de trai-
ter cette erreur, sinon une erreur W-Langage est affichée et l’application s’arrête.

Si la gestion automatique des erreurs Hyper File est activée, il n’est pas néces-
Notes
saire d’effectuer tous les tests d’erreur. En effet, le moteur Hyper File affichera
alors des fenêtres spécifiques à l’utilisateur pour lui permettre de corriger la
valeur saisie.
4 Enregistrez la fenêtre et testez-la; cliquez sur le bouton "Supprimer" :

194
Visualiser les enregistrements

Jusqu'à maintenant, nous avons visualisé les produits un par un (fiche par fiche).
Il est également intéressant de pouvoir visualiser plusieurs enregistrements dans une même fenê-
tre.
Grâce au champ Table, WinDev offre la possibilité de visualiser plusieurs enregistrements à la fois.
4 Créez une nouvelle fenêtre vierge avec le gabarit "ActivOSX", par exemple. Donnez-lui un nom et
un titre (par exemple respectivement "VisualisationProduit" et "Visualisation des produits").
4 Ajoutez un bouton pour fermer la fenêtre.
4 Cliquez sur l'icone pour créer une table. Positionnez le curseur de la souris dans la fenêtre
et cliquez à nouveau dans la fenêtre. L'assistant de création du champ Table se lance.
Notez que pour chaque icone de la barre d’outils, il existe un choix de menu cor-
Astuce
respondant.
Ici par exemple, l’option "Insertion .. Champ .. Table".
4 Nous allons remplir la table à l’aide de données provenant d’un fichier. Sélectionnez la pre-
mière option et cliquez sur "Suivant".
4 Le fichier est "Produit". Cliquez sur "Suivant".
4 On ne veut pas visualiser la clé du fichier, décochez la colonne "IDProduit" et la colonne "Num-
Fournisseur".

195

4 Positionnez la table dans la fenêtre.

Vous remarquez que tous les produits que vous avez saisis dans le fichier s'affichent dans la fenê-
tre sous l’éditeur.
Ce mécanisme se nomme le "Live data". Il vous permet dans l’éditeur, durant le développement et
la mise au point des fenêtres de visualiser en "temps réel" le contenu des fichiers de données.
Evite de nombreux tests pour visualiser les données !
4 Enregistrez et testez la fenêtre.
4 Ajoutez un bouton pour supprimer un enregistrement dans la table et dans le fichier (par exem-
ple ce bouton a pour nom "BTN_Supprimer" et pour libellé "Supprimer").
Le traitement de ce bouton contient la ligne suivante :
TableSupprime(TABLE_Produit)
"TABLE_Produit" est le nom donné au champ Table contenant la liste des produits.

196
Notre table étant un élément directement relié à un fichier, la fonction TableSupprime supprime
d’une part la ligne dans la table, et d’autre part supprime l’enregistrement correspondant dans le
fichier. Dans les tables mémoires, la fonction TableSupprime supprime uniquement la ligne dans la
table.
Attention !
Pour supprimer un enregistrement dans une table, il ne faut pas utiliser la fonc-
tion HSupprime. Vous risquerez alors d’observer des dysfonctionnements dans la
table.
La table que nous avons créée est en saisie.

Pour saisir un nouvel enregistrement ou pour modifier un produit, il suffit de faire un double-clic
dans une des cellules de la table.
Si vous faites un double-clic sur une ligne existante, vous serez en modification sur l’enregistre-
ment.
Si vous faites un double-clic sur une ligne vide (la dernière), vous serez en création d’un enregistre-
ment.
La touche "Entrée" ou le déplacement du curseur sur une autre ligne valide la saisie. La touche
"Echap" annule la saisie.
Vous savez maintenant comment gérer un fichier dans une fenêtre ou dans une table.
WDMAP (option "Outils .. WDMAP - Visionneur Hyper File") permet de visualiser,

Astuce
modifier et supprimer des enregistrements présents dans vos fichiers.

Cet outil permet de tester facilement une application avec des données réalistes.
Cet outil peut être utilisé uniquement sur le poste de développement.

197
LEÇON 4.4. CRYPTAGE DE DONNÉES

• A quoi sert le cryptage des données ?

• Utiliser le cryptage de données.

198
A quoi sert le cryptage des données ?

Une des nombreuses fonctionnalités de WinDev sur les fichiers Hyper File est de garantir la confi-
dentialité des données contenues dans les fichiers Hyper File.
Le cryptage des fichiers permet d’assurer cette confidentialité.
Le cryptage des fichiers permet d’en rendre le contenu illisible pour toute personne ne possédant
pas la clé de décryptage ("Ô Sésame, ouvres-toi !"). En effet, un fichier est crypté selon une clé
(appelée également "mot de passe").
Ce mot de passe est (et doit être) connu de vous seul.
C’est lors de la description du fichier sous l’éditeur d’analyses que vous avez la possibilité de défi-
nir si un cryptage doit être réalisé :
• sur le fichier lui-même
• sur l’index
• sur les fichiers mémos dépendants du fichier
Il existe plusieurs types de cryptage :

• cryptage 128 bits (performant)
• cryptage RC5 (128 bits, 12 boucles, moins performant mais plus sécurisé)
• cryptage RC5 (128 bits, 16 boucles, idem)
La clé (ou "mot de passe") que vous allez définir sera valable uniquement sur le fichier lui-même, et
non pas pour l’analyse en totalité. Vous avez alors la liberté de définir un cryptage sur tout ou partie
des fichiers de votre analyse.
Les données contenues dans le fichier (et/ou dans l’index et/ou dans les fichiers mémos) seront
"codées" en fonction de la clé (ou "mot de passe") que vous aurez définie lors de la génération des
fichiers.
Lors du décodage du fichier, le mot de passe pourra être :

• demandé à l’utilisateur par l’intermédiaire d’une boîte de dialogue automatiquement gérée par
WinDev. Dans ce cas, l’utilisateur devra connaître le mot de passe pour utiliser le fichier.
• présent directement dans le code du programme. Toute personne possédant le programme
pourra utiliser le fichier, mais seulement pour les traitements que vous aurez prévus. Dans ce cas
l’utilisateur n’aura pas connaissance du mot de passe.
• activé par un mode opératoire avancé : mot de passe lu dans un fichier, activé par un traitement
spécial ...
La gestion de ce mot de passe incombe totalement au développeur, c’est-à-dire ... vous ! WinDev se
charge de coder ou décoder en fonction du mot de passe que vous indiquez.

199
Comment crypter les fichiers ?

Mettre en place le cryptage des fichiers
4 1.
Pour utiliser le cryptage sur fichier :
Chargez l’analyse de votre projet avec l’éditeur d’analyses.
2. Sélectionnez le fichier que vous souhaitez crypter.
3. Dans la description du fichier (onglet "Détails") choisissez le type de cryptage pour votre
fichier, votre mémo ou votre index.

Vous avez également la possibilité d’activer la sécurité renforcée. Grâce à ce mode, le mot de
passe de cryptage devra être saisi à chaque modification automatique des données (nouvelle ins-
tallation, mise à jour, génération ...).
Lors de la génération de votre analyse, l’assistant vous propose de saisir ou de modifier (si vous
aviez déjà crypté votre fichier) le mot de passe de cryptage.

200
Vous obtiendrez alors la liste des fichiers pour lesquels vous avez demandé un cryptage. Vous avez
la possibilité de sélectionner les fichiers à crypter, et de saisir les mots de passe pour chacun des
fichiers.
Gestion du cryptage en W-Langage

Pour gérer un mot de passe de cryptage en W-Langage, vous pouvez :
• soit indiquer le mot passe avec les fonctions d’ouverture et de création des fichiers (fonctions
HCréation, HCréationSiInexistant, HOuvre).

201
Exemple d’utilisation de la fonction HCreationSiInexistant :

HCreationSiInexistant(CLIENT, "Motdepasse")
SI HErreurMotDePasse() ALORS
Erreur("Mot de passe invalide")
FIN
• soit utiliser la fonction HPasse avant la première opération de lecture ou d’écriture dans le fichier
crypté.
Exemple d’utilisation de la fonction HPasse :
// Ouverture d’un fichier avec mot de passe et contrôle d'erreur
HPasse(CLIENT, "MotDePasse")
HCréationSiInexistant(CLIENT)
Erreur("Erreur Hyper File : " + HErreurInfo())
RETOUR
FIN
Pour plus de détails sur le cryptage des données, consultez l’aide en ligne (mots-clés : "HPasse",
"CryptageFIC", "CryptageMMO", "CryptageNDX").

202
LEÇON 4.5. LES TRANSACTIONS

• Qu’est-ce qu’une transaction ?

• Comment utiliser les transactions ?


203
Qu’est-ce qu’une transaction ?

Une transaction est un ensemble d'opérations sur fichiers indissociables :
• soit toutes les opérations de la transaction sont réalisées.
• soit aucune opération n'est réalisée.
La gestion des transactions est le meilleur moyen d'assurer la cohérence d'un ensemble d'écritures
indissociables sur des fichiers Hyper File.
Les transactions sont également un moyen sûr et fiable de sécuriser vos traitements sur des
fichiers Hyper File.
Un exemple simple de la nécessité des transactions pour certains types de traite-

ments
Lors d’une opération bancaire de virement, un compte est débité pour en créditer un autre. Pen-
dant les opérations qui sont effectuées, il peut survenir à tout moment une panne sur le réseau
(panne électrique, défaillance des systèmes informatiques). C’est pourquoi il est alors indispensa-
ble de gérer ce traitement par une transaction. Si une panne survient, toutes les opérations à effec-
tuer sont alors annulées. On ne se retrouve donc pas avec un compte débité et un compte non
crédité !

204
Les transactions sur Hyper File

Chaque opération d'écriture effectuée lors d'une transaction est mémorisée dans un fichier spé-
cial. A tout moment, il est possible d'annuler la transaction : toutes les opérations effectuées
depuis le début de la transaction seront annulées.
Les transactions seront annulées dans les cas suivants :
• erreur du programme.
• fin de programme.
• panne de courant ou arrêt brusque de l’application.
Lorsque l’application sera relancée, la cohérence de la base de données pourra être rétablie
grâce :
• à l’outil WinDev "WDTRANS".
• au premier appel de la fonction HTransactionDébut.
• au premier appel de la fonction HTransactionAnnule.
Lorsque les opérations d'écriture incluses dans la transaction sont terminées, le programme peut
valider les opérations de la transaction.
Utilisation des transactions

Mettre en place la gestion des transactions
1. Si vos fichiers sont protégés par mot de passe, ouvrez tous les fichiers utilisés pendant la
transaction (fonction HOuvre) avant le début de la transaction ou spécifiez les mots de passe
avec HPasse.
Si vos fichiers ne sont pas protégés par mot de passe, les fichiers manipulés après la fonction
HTransactionDébut seront automatiquement mis en transaction.
2. Commencez la transaction avec la fonction HTransactionDébut. Cette fonction permet éven-
tuellement de définir le nom du journal des transactions.
3. Effectuez vos opérations. Toutes les opérations d'écriture sur les fichiers en transaction sont
automatiquement enregistrées dans le fichier de transaction.
Attention !
Les traitements réalisés sont relativement plus lents (puisque chaque

opération est également enregistrée dans un fichier spécifique).
4. Annulez si nécessaire les opérations réalisées pendant la transaction (fonction HTransactio-

nAnnule).
5. Spécifiez la fin de la transaction avec la fonction HTransactionFin : la transaction est validée.
Pour plus de détails sur les fonctions de gestion des transactions, consultez l’aide en ligne (mot-
clé : "Transactions Hyper File").

205
Manipuler les enregistrements lors d'une transaction : les règles à suivre

Les enregistrements modifiés pendant la transaction peuvent être lus avant ou après le début de la
transaction : ils seront toujours pris en compte dans le journal des transactions.
La gestion des transactions n'exclut pas la gestion des blocages des enregistrements en transac-
tion.
En effet, les enregistrements manipulés pendant la transaction sont automatiquement bloqués en
écriture.
Dans une application en réseau, si l'utilisateur tente de modifier un enregistrement en transaction,
un message apparaîtra lui demandant de retenter l'opération.
Il est donc nécessaire que la transaction soit la plus courte possible, pour éviter tout blocage des
utilisateurs. Pensez donc à limiter le nombre d’instructions de parcours, modification ... sur le
fichier entre les appels aux fonctions HTransactionDébut et HTransactionFin.
Que faire si une transaction a été interrompue ?

Si une panne (coupure de courant, re-démarrage du poste, ...) survient pendant une transaction,
les fichiers de données risquent d'être incohérents : la transaction n'a été ni validée, ni abandon-
née. Le fichier de transaction est toujours présent sur le poste.

Il est dans ce cas nécessaire de rétablir la cohérence de la base de données. Cette opération peut
être automatiquement réalisée :
• lors du prochain appel à la fonction HTransactionAnnule ou HTransactionDébut.
• avec WDTRANS, utilitaire de gestion des transactions livré avec WebDev.
Pour savoir si la restauration de la cohérence de la base est nécessaire, testez le résultat de la

fonction HTransactionInterrompue dans le code d'initialisation du projet par exemple.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Transactions Hyper File").
Transactions et Hyper File Client / Serveur

Notes
Les transactions sont disponibles en Hyper File Client / Serveur. Pour plus de
détails sur les spécificités des transactions en mode Client / Serveur, consultez
l’aide en ligne.

206
LEÇON 4.6. LA JOURNALISATION

• Qu’est-ce que la journalisation ?

• Utilisation de la journalisation.


207
Qu’est-ce que la journalisation ?

Cette leçon concerne uniquement la journalisation de base de données Hyper File. Pour les bases
de données externes (Oracle, ...) consultez la documentation de ces bases de données.
La journalisation pour quoi faire ?

Le journal est un fichier particulier qui vous permettra de répondre aux besoins suivants :
• remettre la base de données dans l’état où elle était tel jour à telle heure suite à un problème
physique, des erreurs de traitements ou de saisie, ...
• avoir un suivi sur les opérations effectuées sur un fichier "sensible" (qui a modifié ou consulté
le fichier ? par exemple).
• gérer la réplication (voir “La réplication de données”, page 210)
Le journal est une sécurité pour votre base de données. Il vous permettra de remettre rapidement
votre base de données dans le dernier état connu avant le problème rencontré, depuis la dernière
sauvegarde, sans avoir à tout ressaisir.
Comment mettre en place la journalisation

La mise en place de la journalisation est réellement simple avec WinDev. Pour chaque fichier voulu,
il suffit d’indiquer le type de journalisation à appliquer (onglet "Divers" de la fenêtre de description
du fichier).
Par exemple ici sur le fichier "PRODUIT" :

208
Il suffit de choisir le type de journalisation souhaitée :

• Si votre objectif est de pouvoir rapidement restaurer votre base de données suite à un pro-
blème physique ou une erreur de traitement il suffit de choisir "Journal des écritures".
• Si vous souhaitez juste conserver une trace des accès à la base vous choisissez "Historique
des accès au fichier".
La journalisation de type "Historique des accès au fichier" ne permet pas

Attention !
de restaurer votre base de données en cas de problème. Cette option sert

à effectuer des contrôles sur les accès aux fichiers "sensibles" ou tout sim-
plement pour des besoins statistiques.
Ce type de journalisation est néanmoins déconseillé.
• Si vous souhaitez combiner les deux options, choisissez "Journal des écritures + Historique
des accès au fichier".
Physiquement, comment se matérialise la journalisation ?

Tous les accès à tous les fichiers journalés d’une analyse donnée sont archivés dans un fichier
nommé "Table des opérations" (1 par analyse).
Ce fichier unique garantit la séquentialité des opérations.
Toutes les modifications sur un fichier de données sont stockées dans le fichier de journal corres-
pondant (1 par fichier journalé). Par exemple pour un fichier de données "PRODUIT", le fichier jour-
nal sera "PRODUITJNL".
Ces fichiers "journaux" sont situés par défaut dans le répertoire défini lors de la description des
fichiers de l’analyse :
• Si vous n’avez rien spécifié, ils se trouveront dans le sous-répertoire "JNL" du répertoire des
fichiers de données.
• Si vous avez spécifié un dossier, ils se trouveront dans le répertoire que vous aurez indiqué.
Le nom des répertoires est stocké dans le fichier lui-même.
Il est possible de modifier les répertoires des journaux après la mise en place de la journalisation :
• avec WDJournal, livré avec WinDev (option "Information sur un fichier")
• par programmation. Vous pouvez modifier cet emplacement en utilisant les fonctions hChan-
geRep* (consultez l’aide en ligne pour plus de détails, mot-clé : "Journalisation").
La modification des répertoires des journaux est une opération "critique".

Vous devez absolument suivre le mode opératoire ci-dessous :
1. Interdire les accès à la base (tous les fichiers).
Attention !
2. Déplacer les fichiers journaux et/ou tables des opérations dans les nou-
veaux répertoires.
3. Modifier le nom des répertoires dans TOUS les fichiers de données concer-
nés (option "Divers", dans l’écran de description des fichiers).
4. Ré-autoriser les accès à la base de données.

209
Comment réussir la mise en place de la journalisation ?

La mise en place de journaux pour une base de données est liée à la gestion des sauvegardes de
cette même base (sauvegardes des fichiers de données).
En effet, un journal ne peut être "joué" que sur un état donné de la base. L’état qui correspond à la
création ou re-création du journal.
Vous pouvez réaliser ces différentes opérations sans programmation en utilisant WDJournal, livré
avec WinDev.
Notes
WDJournal est redistribuable avec vos applications.
Nous vous conseillons également de suivre les modes opératoires suivants :
4 1.
Mise en place de la journalisation :
Sauvegarde des fichiers de données initiaux (s’ils existent).
2. Mise en place de la journalisation.

4 1.
Sauvegarde d’une application avec des fichiers journalés :
Sauvegarde des fichiers de données.
2. Sauvegarde éventuelle des fichiers journaux.
3. Ré initialisation des fichiers journaux.
4 1.
Restauration suite à un problème :
Restaurer la dernière sauvegarde.
2. Rejouer le journal en cours jusqu’à l’opération souhaitée.
3. Refaire une sauvegarde et ré initialiser les journaux.
Pour plus de détails sur la journalisation, consultez l’aide en ligne (mot-clé : "Journalisation").
Journalisation et Hyper File Client / Serveur

Notes
La journalisation est disponible en Hyper File Client / Serveur. Pour plus de détails
sur les spécificités de la journalisation en mode Client / Serveur, consultez l’aide
en ligne.

210
LEÇON 4.7. LA RÉPLICATION DE DONNÉES

• A quoi sert la réplication de données ?

• Mise en oeuvre de la réplication de données.


211
A quoi sert la réplication de données ?

La réplication de données est une fonctionnalité très puissante. La réplication est l'opération per-
mettant de maintenir à jour des bases de données distantes de structures identiques. Chacune de
ces bases de données évolue indépendamment.
Grâce à la réplication, les opérations effectuées sur chacune des bases de données sont reportées
sur toutes les autres bases de données.
WinDev permet de réaliser ces opérations très simplement.
WinDev propose deux types de réplication :

• La réplication journalée (basée sur la journalisation). Ce type de réplication permet de répliquer
uniquement des bases de données Hyper File entre elles. Ce type de réplication peut être mis en
place grâce aux fonctions W-Langage ou grâce à l’outil WDReplic.
• La réplication universelle qui permet de répliquer n’importe quel type de base de données (par
exemple une base de données Hyper File avec une base de données Oracle).
Nous ne présenterons ici que la réplication universelle.
Mise en oeuvre de la réplication de données

Le but de la réplication universelle est de conserver plusieurs bases de données synchronisées.
Ces bases de données peuvent être de types différents ou non. Il est par exemple possible de réali-
ser une réplication entre une base de données Hyper File et une base de données Oracle, ou entre
deux bases de données Hyper File.
La réplication universelle utilise un modèle centralisé : toutes les bases de données se synchroni-
sent avec une base de données maître. La base de données maître répercute ensuite les modifica-
tions vers les autres bases de données.
La réplication universelle utilise plusieurs types de fichiers :
• Fichier .RPM : fichier permettant de décrire une base maître, et les bases qui lui sont abonnées.
• Fichier .RPL : fichier décrivant une base abonnée. Pour chaque base abonnée, un fichier RPL est
créé. Ce fichier est présent sur le poste abonné.
• Fichier .RPA : fichier journal contenant les informations de réplication. Ce fichier est échangé
entre la base de données maître et la base de données abonnée.
• Fichier .SYN : fichier contenant les informations sur la situation de la base distant. Ce fichier per-
met d'optimiser la taille des fichiers de synchronisation. Ce fichier est présent sur le poste maître
et sur chaque poste abonné.
Remarque : Pour mettre en place la réplication universelle sur des base de données différentes de
Hyper File, il est obligatoire de créer une rubrique de type DateHeure dans chaque fichier. Cette
rubrique sera mise à jour par l'application lors de la modification ou lors de l'ajout d'un enregistre-
ment. Si les bases de données utilisent différents fuseaux horaires, il est conseillé d'utiliser un for-
mat universel (date et heure GMT par exemple).

212
Mise en place
1. Activation
Pour activer la réplication universelle, il suffit d'utiliser la fonction HGèreRéplication avec le para-
mètre rplRéplicationUniverselle.
Cette fonction permet de désactiver le mode de réplication standard (s'il était actif) et d'activer la
réplication universelle.
2. Déclaration de la base maître
Cette opération n'est à faire qu'une seule fois sur la base maître.
Pour déclarer la base maître, il suffit d'utiliser la fonction HCréeRéplicaMaître.
Remarque : Si le répertoire courant permet de stocker des données, la ligne de code suivante peut
être utilisée :
HCréeRéplicaMaître("")
Cette ligne de code crée le fichier RéplicaMaître.RPM sur le disque. Il ne reste plus qu'à inscrire les
abonnés dans ce fichier.
3. Déclaration des bases abonnées
Cette opération n'est à faire qu'une seule fois pour chaque base abonnée. Cette opération doit être
effectuée sur la base maître.
Pour déclarer un nouvel abonné, utilisez la fonction HCréeRéplicaAbonné. Cette fonction crée un
abonné (fichier RPL) avec le nom fourni. Cette fonction renvoie également un numéro d'abonné.
Remarque : la fonction HCréeRéplicaAbonné utilise des paramètres spécifiques pour la réplication
universelle. Pour plus de détails, consultez l'aide de la fonction.
4. Réplication
La fonction HCréeRéplicaTransportable crée un fichier journal (fichier .RPA).
Ce fichier journal est transmis et exécuté grâce à la fonction HSynchroniseRéplica.
Attention : Par défaut lors de la synchronisation (HSynchroniseRéplica), le maître est prioritaire :
dans le cas d'une réplication abonné vers maître, les données du maître ne seront pas mises à
jour. Pensez à utiliser une autre constante (rplPlusRécentPrioritaire par exemple).
Deux fonctions spécifiques peuvent également être utilisées :
HRplDéclareLiaison Permet de signaler au moteur de réplication une liaison entre deux
fichiers. Le moteur suivra alors la liaison pour obtenir la liste des
enregistrements à répliquer dans le second fichier.
HRplProcédureFiltre Permet de spécifier une procédure de filtrage spécifique lorsque un

fichier donné sera répliqué.

213
LEÇON 4.8. CLIENT / SERVEUR

• Qu’est-ce que le Client/Serveur ?

• Comment mettre en place le Client / Serveur ?

214
Présentation
WinDev permet de créer des applications accédant à des bases de données Hyper File Client / Ser-
veur.
Une application Hyper File Client / Serveur consiste à exécuter l'application sur différents postes
utilisateur (appelés machines clientes) et à déporter la ou les bases de données et les traitements
sur un poste serveur. Ce mode de fonctionnement permet des temps de réponses plus rapides et
plus fiables, ainsi qu'une maintenance de la base de données facilité.
WinDev permet de :
• créer entièrement une application Hyper File Client / Serveur.
• modifier une application WinDev existante en une application Hyper File Client / Serveur.

215
Mettre en place une application Hyper File Client/Serveur

Pour mettre en place une application Hyper File Client / Serveur, les étapes sont les suivantes :
1. Paramétrage du serveur utilisé.
2. Connexion des postes client au serveur.
3. Paramétrage des fichiers de données sur le serveur.
4. Utilisation de l'application.
Etape 1 : Paramétrage du serveur utilisé

Serveur Manta
Le serveur Manta est composé :
• du service MantaManager qui permet de communiquer avec l'application XManta (outil d'admi-
nistration à distance) et d'arrêter et/ou de lancer le ou les serveurs.
• du service Manta.
Par défaut, un seul service Manta est présent sur le poste serveur. Cependant, il est possible
d'avoir plusieurs services Manta sur le même poste serveur. Cette configuration permet par
exemple d'associer une application WinDev (ou un petit nombre d'applications WinDev) à un ser-

vice Manta. Ainsi, si une application surcharge le service Manta, seules les applications asso-
ciées à ce service seront bloquées ou ralenties.
Pour utiliser cette configuration, il est nécessaire que chaque service Manta utilise un port
réseau et un chemin de répertoire de bases de données différents.

216
Le serveur Manta peut être présent :

• soit sur le poste de développement
• soit sur le poste serveur
Le centre de contrôle Hyper File permet de :

• administrer entièrement les différents serveurs utilisés.
• gérer les utilisateurs et les groupes d'utilisateurs des bases de données.
• visualiser et/ou modifier le contenu d'une base de données.
• effectuer des recherches dans une base de données.
• exécuter des requêtes sur une base de données.
• visualiser les connexions en cours sur une base de données ou sur un fichier de données.
• arrêter, démarrer, installer et/ou désinstaller un serveur.
• ...
Lors du lancement du centre de contrôle Hyper File, le nom du dernier utilisateur connecté est auto-
matiquement proposé.
Lors du premier lancement du centre de contrôle Hyper File, l'utilisateur "admin" est proposé par
défaut. Cet utilisateur n’a pas de mot de passe. Pour utiliser un des utilisateurs définis sur le ser-
veur Manta, saisissez directement le nom de cet utilisateur ainsi que son mot de passe.
Etape 2 : Connexion des postes client au serveur

Pour que l'application WinDev puisse manipuler les fichiers de données présents sur le serveur
Hyper File, il est nécessaire de définir dans le projet la connexion qui sera utilisée par l'application.
Cette connexion peut être définie :
• soit depuis l'éditeur d'analyses.
• soit par programmation.
Remarque : Il est possible de définir plusieurs connexions dans le cas où l'application utilise plu-
sieurs bases de données ou plusieurs serveurs.
Définition des connexions depuis l’éditeur d’analyses

Pour définir une connexion depuis l'éditeur d'analyses :
1. Sélectionnez l'option "Analyse .. Connexions".
Si aucune connexion n’a été définie, l’assistant de création d’une nouvelle connexion se lance.
Si une connexion a déjà été définie, la fenêtre de connexion s’affiche. Cliquez sur l’icone "Nou-
velle connexion" pour lancer l’assistant de création d’une nouvelle connexion.
2. Conservez l'option "Hyper File Client/Serveur" et cliquez sur "Suivant".
3. Saisissez les informations demandées (nom du serveur, numéro du port réseau, nom et mot
de passe de l'utilisateur, base de données, nom et libellé de la connexion) et validez l'assistant
(bouton "Terminer").
Une boîte de dialogue s'affiche et propose d'associer des fichiers de données à cette nouvelle
connexion. Acceptez.
4.Sélectionnez les fichiers de données à associer et validez.
La nouvelle connexion apparaît dans la liste des connexions définies dans l'analyse.

217
5. Testez si nécessaire cette nouvelle connexion : cliquez sur le bouton "Tester".

6. Fermez la fenêtre des connexions définies.
En exécution, la connexion associée au fichier manipulé sera automatiquement ouverte lors du pre-
mier accès au fichier.
Les fichiers de données associés à une connexion de type "Client/Serveur" se transforment auto-
matiquement en fichiers de données de type "Hyper File Client/Serveur". Pour les reconnaître, un
pictogramme "Hyper File Client/Serveur" apparaît dans l'en-tête de ces fichiers.
Définition des connexions par programmation
Pour définir une connexion par programmation :
1. Définissez la connexion grâce à la fonction HDécritConnexion ou HOuvreConnexion.
Le paramètre <Source des données> doit correspondre au nom ou à l'adresse IP du serveur à
utiliser. Si le port réseau à utiliser est différent du port par défaut (port 4900), le paramètre
<Source des données> doit être de la forme "<NomOuAdresseIPServeur>:<NuméroPort>".
Le paramètre <Provider OLEDB ou Accès Natif> doit correspondre à la constante hAccèsHF-
ClientServeur.
Par exemple :
HDécritConnexion("MaConnexion", "Julie", "MotDePasse", ...
"MonServeurHF", "MaBaseDeDonnées", ...
hAccèsHFClientServeur, HOLecture)

ou
HOuvreConnexion("ConnexionServeur", "Stephane", "", ...
"ServeurDonnées:5400", "MesDonnées", ...
hAccèsHFClientServeur)
2. Ouvrez la connexion grâce à la fonction HOuvreConnexion.
Cette étape n'est pas nécessaire si la connexion a été définie et ouverte à l'étape précédente
grâce à la fonction HOuvreConnexion.
3.Associez la connexion aux différents fichiers de données grâce à la fonction HChangeCon-
nexion.
Par exemple :
HChangeConnexion(Client, "MaConnexion")
ou, pour associer tous les fichiers de l'analyse à la connexion :
HChangeConnexion("*", "ConnexionServeur")
Etape 3 : Paramétrage des fichiers de données sur le serveur

Si vous créez une application Hyper File Client / Serveur, aucune manipulation spécifique n'est
nécessaire. Les fichiers de données seront directement créés sur le serveur lors de l'appel de la
fonction HCréation ou HCréationSiInexistant.
Si vous modifiez une application WinDev existante en une application Hyper File Client / Serveur,
consultez l’aide en ligne pour connaître les manipulations à effectuer.

218
LEÇON 4.9. ACCÈS DISTANT

• Qu’est-ce que l’accès distant ?

• Quand utiliser l’accès distant ?


219
Qu’est-ce que l’accès distant ?

L’accès distant Hyper File permet de manipuler une base de données Hyper File via Internet/Intra-
net ou même via des liaisons téléphoniques.
La gestion de données Hyper File par accès distant permet l'utilisation du réseau Internet/Intranet
sans développement spécifique. Cette opération est complètement transparente pour les applica-
tions WinDev, il suffit d'ouvrir l'analyse sur le poste distant par la fonction HOuvreAnalyse.
De plus, la gestion de l’accès distant sur Hyper File est automatiquement réalisée par WinDev !

Quand utiliser l’accès distant sur Hyper File ?
Quand ?
Différents utilisateurs ont souvent besoin d'accéder à la même base de données. Lorsque ces utili-
sateurs sont localisés sur un seul site, ils utilisent une application réseau "classique". Pour des uti-
lisateurs délocalisés sans accès direct au réseau de leur entreprise, l’accès distant est une des
méthodes utilisables.
Dans ce dernier cas, il est véritablement pratique d’utiliser les fonctionnalités d’accès à distance.
Dès l'ouverture d'une analyse distante avec la fonction HOuvreAnalyse ou la fonction HConnec-
teAccèsDistant, tous les ordres Hyper File sont transmis à la bibliothèque Hyper File (fichier
WD100HF.DLL) du poste serveur (où se trouvent les données).
Pour réduire le nombre d'échanges via le réseau, les ordres qui n'impliquent pas directement la
base de données sont exécutés localement. La présence de la bibliothèque Hyper File et de la des-
cription de l'analyse (fichier ".WDD") sont donc nécessaires sur chaque poste client.
Les échanges de données se font en utilisant les fonctions de la bibliothèque de communication
(fichier WD100COM.DLL, présent sur le poste serveur et sur le poste client).

220
Les particularités d’utilisation de l’accès distant par rapport à un accès réseau classi-
que
Permet d'accéder à des données :
• depuis une simple adresse IP (et un n° de port) : Internet, Intranet ...
• présentes sur un disque sur lequel l’utilisateur standard n’a pas les droits d’accès (sécurité
pour l’administrateur de base de données).
Pour optimiser les performances de l’accès distant sur Hyper File, nous con-
Notes
seillons de réaliser des filtres, des vues et des requêtes. Celles-ci seront exécu-
tées par le serveur d’accès distant qui vous renverra par bloc toutes les données
que vous aurez demandées.
Un exemple simple
Un programme effectue une recherche sur 50 000 enregistrements.
Si le programme effectue une boucle de 50 000 HLitSuivant, il y aura 50 000 allers-retours de don-
nées, coûteux en temps sur une ligne téléphonique par exemple !
Par contre, si le programme effectue une vue, il n’y aura qu’un seul et unique aller-retour (si le nom-
bre d’enregistrements par bloc est fixé à 50 000 lors de l’exécution de la vue) !
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Accès distant").

Exemple
Un serveur d’accès distant Hyper File est fourni en standard avec WinDev 10 :
"WDServeurAccèsDistant".

221
LEÇON 4.10. BASES EXTERNES

• Description d’une analyse d’une base externe (Oracle, SQL Server, ...).

222
Présentation
On nommera "Base de données externe" tout système de gestion de base de données autre que
Hyper File. Tout programme réalisé avec WinDev peut accéder très facilement à une base de don-
nées autre que Hyper File.
Il faut pour cela décrire la base de données dans une analyse (comme pour Hyper File).
Les modes d’accès aux bases de données sont :

• accès natif
• accès via ODBC
• accès via OLE DB
• accès ODBC via OLE DB
La programmation sera effectuée avec les fonctions du W-Langage (HLit*) et/ou avec SQL. Consul-
tez la tableau comparatif en sélectionnant l’option "? .. Aide à l’utilisation des bases de données"
dans le menu de WinDev.
Description de l’analyse
Lors de la création d’un nouveau fichier (option "Insertion .. Fichier" de l’éditeur d’analyses), choisis-
sez l’option "Utiliser des fichiers d’une base existante" :

223
Sélectionnez ensuite le type de base de données :
Puis, définissez si les données seront converties en Hyper File Classic ou bien si elles restent dans

leur format actuel :
Les paramètres de connexion à cette base de données externe doivent être décrits (nom du ser-
veur ou service, base de données, login et mot de passe et le type d’accès (Natif, OLE DB, ODBC)).

224
En fonction du type de la base de données, la technique de programmation pour accéder aux don-
nées est différente.

La fonction HDéclareExterne permet d’utiliser par programmation un fichier d’une base externe
sans importer la structure du fichier dans l’analyse. Les fonctions Hyper File et SQL du W-Langage
seront utilisables sur ce fichier. Cette méthode est conseillée uniquement pour une utilisation
ponctuelle d’un fichier.
En effet, dans ce cas, il est nécessaire de décrire une connexion (fonction HDécritConnexion) et
tous les assistants de code, ... ne seront pas disponibles lors de la programmation de ce fichier (ce
fichier étant dynamique).
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Base de données externe").

225
LEÇON 4.11. LE RÉSEAU

• Modes de gestion d’une base de données sur un réseau.

226
Modes de gestion
La grande majorité des applications développées est conçue pour fonctionner en réseau, c’est-à-
dire pour être utilisée par plusieurs utilisateurs (jusqu’à plusieurs centaines ou milliers) en simul-
tané sur les mêmes fichiers de données.
Ces accès simultanés peuvent provoquer des conflits d’accès, par exemple si deux utilisateurs ten-
tent de modifier simultanément le même enregistrement.
Avec WinDev, la gestion des blocages est facile, très puissante et le plus souvent automatique.
Il existe deux modes de gestion :

• hMode(HModeMulti) : gestion d'un mode multi-utilisateur (réseau).
• hMode(HModeMono) : gestion d'un mode mono-utilisateur.
En mode multi-utilisateurs, la gestion des conflits est automatiquement gérée par le moteur
Hyper File. En cas d’erreur de blocage, la gestion des blocages (vérification si le fichier ou l’enregis-
trement est bloqué, traitement du blocage) est automatiquement réalisée par le moteur Hyper File.
Dans une application réseau, il est aussi possible de bloquer un enregistrement ou un fichier, pour
effectuer des opérations spécifiques par exemple.
Lorsqu'un poste client tente d'accéder à un enregistrement bloqué, une erreur de blocage apparaît
: une fenêtre apparaît indiquant à l’utilisateur que l’enregistrement ou le fichier est bloqué et lui
proposant de retenter l’opération ou de l’annuler. En cas d’annulation, l’application continue de

s’exécuter normalement.
Il est possible de prendre le contrôle sur l’erreur de blocage avec la fonction HSurErreur.
Il est également possible de demander spécifiquement le blocage d’un ou de plusieurs enregistre-

ments, en utilisant les fonctions du W-Langage du type HLitxxxBloque.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Blocage").

227
LEÇON 4.12. LES TRIGGERS

• A quoi sert un trigger ?

• Utilisation d’un trigger.

228
A quoi sert un trigger ?

Un trigger permet de déclencher une action automatiquement lors d’une opération d’ajout, de
modification et de suppression sur un fichier de données Hyper File.
Lors d’une opération (ajout, modification ou suppression) sur un fichier Hyper File, il est possible
d’exécuter une action avant ou après l’exécution de cette opération. Par exemple, lors d’une sup-
pression dans un fichier, il est possible de demander la confirmation de suppression de l’enregis-
trement.
Mise en place
Les triggers sont définis par programmation. Les fonctions du W-Langage utilisables sont :
• HDécritTrigger : Décrit le trigger. Cette fonction est généralement utilisée dans le code d’ini-
tialisation du projet. Le trigger déclenche l’appel d’une procédure. Cette procédure est asso-
ciée au trigger lors de l’utilisation de la fonction HDécritTrigger.
• HActiveTrigger : Active un trigger décrit par la fonction HDécritTrigger. Dès sa création, le trig-
ger est automatiquement activé.
• HDésactiveTrigger : Désactive un trigger décrit par la fonction HDécritTrigger.
Attention !
La fonction HDésactiveTrigger ne détruit pas le trigger. Le trigger existe toujours

mais n’est plus actif.
• HDétruitTrigger : Détruit un trigger décrit par la fonction HDécritTrigger.
Etape 1 : décrire le trigger (ici dans le code d’initialisation du projet)

Exemple :
- - code d’initialisation du projet - -
HDécritTrigger("CLIENT,FOURNISSEUR", "HSUPPRIME", ...
"ProcConfirmeSuppression", HTriggerAvant)
Dans cet exemple, le trigger va déclencher l’appel de la procédure "ProcConfirmeSuppression" lors

de la suppression d’un enregistrement dans l’un des fichiers "CLIENT" et/ou "FOURNISSEUR". Cette
suppression pourra avoir lieu n’importe où dans le projet.
Attention !
La procédure "ProcConfirmeSuppression" sera appelée AVANT (HTriggerAvant) que

la suppression ait lieu.

229
Etape 2 : créer une procédure globale liée au trigger
Exemple :
PROCEDURE PROCCONFIRMESUPPRESSION ()
// Demande la confirmation à l’utilisateur
SI OuiNon("Confirmez-vous la suppression ? ") = Non ALORS
// Initialisation de H.Afaire pour annuler l’opération
H.Afaire = "A"
FIN
Exemple
Pour plus de détails sur l’utilisation des triggers, consultez l’exemple "WD Trigger",
livré en standard avec WinDev.
Nous avons abordé simplement le fonctionnement d’un trigger. Pour obtenir plus de détails, consul-
tez l’aide en ligne (mot-clé : "HDécritTrigger")

230
LEÇON 4.13. LE RAD PROJET

• Qu’est-ce que le RAD ?

• Etape par étape, utiliser le RAD Projet.
• Etudier les éléments générés par le RAD Projet.
• Le RAD projet en mode SQL.
Vous trouverez :
• dans le répertoire "\Autoformation\Corriges\WD RAD" le projet "WD RAD.WDP" con-
tenant les illustrations de cette leçon. Vous pouvez lancer l’exécutable correspon-
dant directement depuis WinDev grâce à l’option "? .. Guide d’auto-formation .. Le
RAD Projet".
• dans le répertoire "\Autoformation\Corriges\WD RADSQL" le projet "WD
RADSQL.WDP" contenant les illustrations de cette leçon. Vous pouvez lancer l’exé-
cutable correspondant directement depuis WinDev grâce à l’option "? .. Guide
d’auto-formation .. Le RAD Projet SQL".

231
Présentation
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 manipulés dans les traitements.
Le module RAD de WinDev s’appuie sur cette analyse. Le module RAD est constitué d’un assistant
dans lequel vous pouvez détailler les différents paramètres nécessaires au développement du
projet :
• La présentation (modale ou MDI).
• Le code généré (procédural ou objet).
• Le type de programmation utilisé (Hyper File ou SQL).
Toutes les fenêtres, les états, les requêtes et le code générés sont entièrement personnalisables.
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.
Nous allons ici découvrir comment utiliser le module RAD Projet. Pour cela, nous allons ouvrir un
projet associé à une analyse.

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").
Etape par étape, utiliser le RAD

Exécution du module RAD
4 Ouvrez le projet "WD RAD.WDP" présent dans le sous-répertoire "Autoformation\Exercices\WD
RAD" du répertoire d’installation de WinDev 10.
4 Pour lancer le module RAD, sélectionnez l’option "Atelier .. RAD Application Complète".

232
L’assistant du module RAD démarre :

Options de l’interface
L’interface permet de définir la présentation générale de votre application. WinDev propose de
gérer automatiquement un des deux types d’interface suivant :
• Interface classique : les fenêtres seront ouvertes en mode modal. Toutes les fenêtres de
l’application se superposeront.
• Interface MDI : les fenêtres seront ouvertes en mode non modal (gestion du multi-fenêtrage).
4 Pour notre exemple, conservez les paramètres par défaut : Interface Classique et cliquez sur
"Suivant".

233
Type de code généré

L’assistant permet de définir les principales options concernant le code de l’application qui va être
générée par le RAD.
Lorsque le code est généré en "Simplifié", tous les ordres de programmations sont visibles. Le
code est généré de manière séquentielle. Le code est dit "simplifié" car ces fenêtres ne gèrent pas
de procédures locales. Le code généré est du code W-Langage.
Ce type de code est conseillé pour des applications basées sur des fichiers Hyper File Classic, par
exemple pour réaliser rapidement des maquettes d’applications complètes.
Lorsque le code est généré en "procédural", tous les ordres de programmation sont visibles. Le
code est généré de manière séquentielle. Les différents traitements sont réalisés dans les fenêtres
à l’aide de procédures locales.
Dans ce cas, le type de code généré peut être :
• Fonctions Hyper File du W-Langage : Les ordres W-Langage permettent d’accéder aux fichiers
en utilisant les fonctions HLitPremier, HLitSuivant, HAjoute, HModifie, …
• Ordre SQL : Les ordres SQL permettent d’accéder aux fichiers en utilisant les requêtes SQL
générées par l’éditeur de requêtes de WinDev.
• Ordre ODBC : Les ordres ODBC permettent d’accéder aux fichiers en utilisant les fonctions
SQLConnecte, SQLExec, SQLTable … du W-Langage.

Lorsque le code est généré en "objet", les ordres de programmation sont présents dans des clas-
ses et des méthodes. Les fenêtres et les états contiennent les appels aux méthodes.
L’option "avec code de création des fichiers" (fonction HCréationSiInexistant) permet de créer auto-
matiquement tous les fichiers de données inexistants, et d’effectuer la connexion à la base de don-
nées (si le projet utilise une base externe) au moment de l’ouverture du projet.
L’option "avec rafraîchissement automatique" permet de mettre à jour automatiquement le con-

234
tenu des fenêtres quand le contenu des fichiers de données a changé (utile lors d’une utilisation en
réseau, mais induit une perte de performance).
4 Pour notre exemple, sélectionnez l’option "Programmation simplifiée".
4 L’assistant propose alors de choisir le thème (le "gabarit") du projet
Gabarit utilisé pour les fenêtres
Vous allez sélectionner le "gabarit" pour la génération des fenêtres et des états. Le "gabarit" permet
de définir le "look" graphique de l’application. Ce choix pourra être modifié par la suite.
4 Choisissez le gabarit "Office12" et cliquez sur "Suivant".

Paramétrage des fenêtres
Vous allez sélectionner la taille maximale des fenêtres générées ainsi que le mode d’alignement et
de positionnement des champs.

235
Les tables permettent d’afficher le contenu des fichiers en tableau (mode "browse").
Le bouton "Conseil" ( ) indique la meilleure méthode pour gérer l’ascenseur dans une

table en fonction de la base de données. Utilisez la méthode conseillée pour avoir les meilleures
performances à l’affichage et dans le scrolling (lorsque vous parcourez la table avec les ascen-
seurs).
4 Conservez les paramètres par défaut ("800x600", "ascenseur proportionnel",

champs sur plusieurs colonnes") et cliquez sur le bouton "Suivant".
"Aligner les
Les fichiers gérés par l’application

Le RAD construit des fenêtres et des états en fonction des différents fichiers décrits dans l’analyse.

236
Dans cet écran, vous pouvez sélectionner le ou les fichiers pour lesquels vous désirez générer des
fenêtres et des états.
Nous conserverons bien évidemment le fichier "PRODUIT".
4 Cliquez sur le bouton "Suivant".

4 L’assistant indique qu’il a toutes les informations nécessaires à la construction automatique de
l’application. Cliquez sur le bouton "Terminer".
Les fenêtres et les états sont en cours de construction. Cela peut prendre un certain temps en
fonction de la complexité de l’analyse, du nombre de fichiers, du nombre de liaisons entre les
fichiers.
Le graphe du projet est automatiquement dessiné à la fin de la génération de l’application. Cette

application complète est déjà entièrement fonctionnelle.
Test du projet
4 Pour tester le projet, sélectionnez l’option "Projet .. Mode Test .. Tester le projet". A partir du
menu, l’option "Produit .. Table produit" permet de visualiser les produits et de saisir de nou-
veaux produits.

237
Fenêtres générées par le RAD

Présentation
Le module RAD a généré ici différents types de fenêtres :
• une fenêtre de menu ("MENU"), qui correspond à la première fenêtre de l’application
• une fenêtre en mode fiche ("Fiche_PRODUIT"), qui correspond à une fenêtre de saisie champ
par champ permettant de visualiser, créer ou modifier enregistrement par enregistrement
dans un fichier.
• une fenêtre en mode table ("Table_PRODUIT"), qui correspond à une fenêtre avec un table
contenant plusieurs enregistrements permettant de visualiser, créer ou modifier les enregis-
trements dans un fichier.
Fenêtre Menu
La fenêtre de menu est la fenêtre principale du projet. Lors du lancement de l’application, cette
fenêtre est affichée en premier (dans le graphe cette fenêtre apparaît sur un fond orange).
4 Pour ouvrir la fenêtre "Menu" dans l’éditeur, double-cliquez sur la fenêtre "Menu" dans le gra-
phe du projet.
4 Dans la fenêtre qui apparaît, cliquez sur les différentes options du menu. Le menu se déroule,
et vous pouvez sélectionner les différentes options.
Pour chacune de ces options, un code (écrit en W-Langage) permet de préciser les actions à
réaliser lorsque l’utilisateur sélectionne l’option.
4 1.
Pour consulter le code W-Langage associé à une option de menu :
Sélectionnez l’option "Produit .. Table Produit" dans le menu de la fenêtre.
2. Faites un clic droit sur cette option : un menu contextuel apparaît.

238
3. Sélectionnez l’option "Code" du menu contextuel. L’éditeur de code s’ouvre et affiche le code
source. Ce code permet d’ouvrir la fenêtre "TableProduit". La fonction W-Langage utilisée est la
fonction Ouvre.
4. Fermez la fenêtre de code (Raccourci [CTRL]+[F4]).

5. Sélectionnez dans le menu de la fenêtre l’option "Produit .. Imprimer", et affichez le code
source de cette option :
Le code visualisé permet de lancer l’exécution d’un état. La fonction iAperçu permettra de visuali-
ser l’édition à l’écran. La valeur "100" indique ici que le niveau de zoom de l’aperçu sera de 100%.
Pour plus de détails sur cette fonction, consultez l’aide en ligne (mot-clé : "iAperçu").
Dans le menu de la fenêtre "Menu", l’option "Fichier .. Configurer l’impression" permet de lancer la
configuration de l’impression. L’utilisateur pourra ainsi modifier l’imprimante par défaut ainsi que
divers paramètres comme l’orientation, le format et le bac de papier, le nombre de copies et
d’autres paramètres liés aux imprimantes installées sur le poste en cours.
4 Fermez la fenêtre de code ([CTRL]+[F4]).
4 Sélectionnez
cette option.
dans le menu de la fenêtre l’option "Fichier .. Quitter" et affichez le code source de
Dans le code affiché, la fonction Ferme ferme la fenêtre en cours. Si cette fenêtre est la première
fenêtre de l’application, l’application se termine. Pour plus de détails sur cette fonction, consultez

239
l’aide en ligne (mot-clé : "Ferme").

Nous n’analyserons pas les autres options de menu.
Fenêtre en mode Fiche

Le modèle de fenêtre "Fiche" permet de :
• créer une fiche,
• modifier une fiche (si la fenêtre est ouverte depuis la fenêtre en mode table)
4 Pour ouvrir la fenêtre correspondant à la saisie des produits dans l’éditeur, effectuez les mani-
pulations suivantes :
1. Affichez si nécessaire le volet "Projet" en mode "TreeView".
2. Sélectionnez la fenêtre "Fiche_Simple_PRODUIT" et double-cliquez sur cette fenêtre.
Les parties principales de cette fenêtre sont les suivantes :

1. Champs de saisie, contenant les différentes rubriques des enregistrements.
2. Actions pouvant être réalisées dans cette fenêtre :
•"OK" pour valider les modifications effectuées dans la fiche en cours.
•"Annuler" pour annuler la visualisation, l’ajout ou la modification en cours.
Etudions en détail le code généré par le RAD pour ces différents éléments.
Remarque : WinDev permet de saisir le code des différents éléments dans le traitement (l’événe-
ment) souhaité. Cet aspect a déjà été évoqué dans l’encadré “Notes”, page 109.

240
Codes d’ouverture de la fenêtre

Les codes d’ouverture de la fenêtre sont les codes exécutés lors de l’affichage de la fenêtre en exé-
cution.
Le code de "déclaration des globales" est le tout premier code exécuté lors de l’ouverture de la
fenêtre. Ce code est exécuté avant que la fenêtre soit visible. Ce code permet de préparer et d’exé-
cuter les traitements nécessaires à l’initialisation de la fenêtre.
Le code d’"initialisation" est exécuté après l’affichage de la fenêtre et après les codes d’initialisa-
tion de champs présents dans la fenêtre.
La fenêtre en "Fiche" peut fonctionner selon 2 modes (gérés dans le code de déclarations des glo-
bales de la fenêtre) :
• Mode "Modif"
• Mode "Création"
Ces modes sont initialisés au lancement de la fenêtre en passant un paramètre à la fenêtre. La
variable "sModeOuverture" contient le mode utilisé.
• Le mode "Modif" permet de se positionner directement en mode modification sur un enregistre-
ment. L’enregistrement qui est en modification a été sélectionné dans la fenêtre appelante
(généralement cette fenêtre est en mode "table").
• Le mode "Création" permet d'ouvrir la fenêtre en mode "création d’un enregistrement". Les
champs dans la fenêtre apparaissent vides.
Le mode d’ouverture par défaut d’une fenêtre en mode fiche est le mode "Création".
Code du bouton OK
Le code de clic du bouton OK permet de valider les opérations effectuées par l’utilisateur dans la
fenêtre fiche.
Dans tous les cas, les données affichées à l’écran sont mémorisées grâce à la fonction EcranVers-
Fichier.
Deux cas sont pris alors en compte :
• la création d’un nouvel enregistrement :
// Ajout de l'enregistrement
HAjoute(PRODUIT)
Info("Impossible d'ajouter un enregistrement"+RC+...
HErreurInfo())
RETOUR
FIN
L’ajout de l’enregistrement dans le fichier de données est réalisé grâce à la fonction HAjoute.
La variable ErreurDétectée permet de vérifier que l’ajout a bien été effectué. Si ErreurDétec-
tée = Vrai, il y a eu un problème, et le message d’erreur correspondant est affiché.
• la modification d’un enregistrement :
// Modification de l'enregistrement
HModifie(PRODUIT)
Info("Impossible de modifier l’enregistrement"+RC+...
HErreurInfo())

241
RETOUR
FIN
Le code de modification de l’enregistrement reprend le même principe. La modification de
l’enregistrement dans le fichier de données est réalisé grâce à la fonction HModifie.
Fenêtre en mode Table

Le modèle de fenêtre "table" permet de visualiser, créer, modifier un ensemble d’enregistrements.
4 Pour ouvrir la fenêtre correspondant à la visualisation en table des produits dans l’éditeur,
effectuez les manipulations suivantes :
1. Affichez si nécessaire le volet WinDev en mode "TreeView".
2. Sélectionnez la fenêtre "Table_produit" et double-cliquez sur cette fenêtre.
Les parties principales de cette fenêtre sont les suivantes :

1. Table contenant les données en saisie.
2. Boutons de parcours ("Premier", "Précédent", "Suivant" et "Dernier") pour la lecture des enre-
gistrements.
3. Actions autorisées dans la fenêtre :
• "Nouveau" pour passer en mode de création et permettre la création d’un nouvel enregistre-
ment.
• "Modifier" pour modifier la ligne en cours dans la table.
• "Supprimer" pour supprimer la ligne en cours dans la table.
Etudions en détail le code de ces différents éléments.

242
Code de la table
4 1.
Pour afficher les différents traitements associés à la table :
Affichez le menu contextuel du champ Table (clic droit sur la table).
2. Sélectionnez l’option "Code".
La table ne contient aucun code. En effet, la gestion de cet élément est entièrement automati-
que. Le champ Table est relié directement au fichier. Le fichier est lu automatiquement et le
remplissage est pris en charge par WinDev.
4 Les paramètres de remplissage de la table sont disponibles dans la fenêtre de description de la

table.
1. Faites un clic droit sur la table puis sélectionnez l’option "Description".
2. Dans la fenêtre de description de la table, cliquez sur l’onglet "Contenu".
Le fichier parcouru est le fichier PRODUIT. Le parcours est "AUTOMATIQUE" sur la rubrique "IDPRO-
DUIT".
Code des boutons de Parcours

Le code des boutons de parcours de la fenêtre de type "Table" est très simple. Ce code permet de
modifier la position du bandeau de sélection sur les lignes de la table. La table est manipulée
directement par son nom (fonction TableSelectPlus).
Bouton "Nouveau"
Le bouton "Nouveau" permet d’ouvrir une fenêtre de type "Fiche" en mode "Création" pour saisir le
nouvel enregistrement. Le mode d’ouverture de la fiche est passé en paramètre à la fenêtre grâce
à la fonction Ouvre.

243
Lorsque la saisie du nouvel enregistrement a été validée (la fonction Ouvre a été exécutée, et la
fenêtre de création de l’enregistrement est refermée), la table est ré-affichée (fonction TableAffi-
che).
// Ouverture en mode création "classique"
Ouvre(Fiche_PRODUIT,"Création")
// rafraichissement de la table
TableAffiche(Table,taCourantPremier)
Bouton "Modifier"
Le bouton "Modifier" permet d’ouvrir une fenêtre de type "Fiche" en mode "Modification" pour modi-
fier l’enregistrement sélectionné dans la table. Le mode d’ouverture de la fiche est passé en para-
mètre à la fenêtre grâce à la fonction Ouvre.
Lorsque le nouvel enregistrement est saisi (la fonction Ouvre a été exécutée, et la fenêtre de modi-
fication de l’enregistrement est refermée), la table est ré-affichée (fonction TableAffiche).
Toutes les autres fenêtres générées par le module RAD sont basées sur les mêmes modèles quel
que soit le nombre de fichiers.
Etats générés par le RAD

Présentation
Le module RAD génère aussi des états sur les différents fichiers. Différents modèles d’états sont
générés dont :
• des états correspondant à des "listes simples" (Etat de type Table)
• des états correspondant à une "fiche" (Etat de type Fiche)
Dans notre exemple, nous avons choisi un RAD simplifié : seul un état de type Table a été généré.
Etat de type Table

4 Pour ouvrir l’état permettant d’afficher la liste des produits, effectuez les manipulations
suivantes :
1. Affichez si nécessaire le volet WinDev en mode "TreeView".
2. Sélectionnez l’état "Etat_Table_produit" et double-cliquez sur cet état.

244
4 1.
Pour visualiser la description de l’état :
Faites un clic droit sur l'état (dans la partie marron) puis sélectionnez l’option "Description de
l'état".
2. Cliquez sur l’onglet "Données". Dans cet onglet, nous visualisons la source de données asso-
ciée à l’état. Dans le cas d’un état généré par le R.A.D., la source de données est une requête.
Cette requête existe uniquement pour cet état, et ne peut pas être manipulée par un autre élé-
ment du projet : c’est une requête intégrée.
4 Pour visualiser la description de la requête associée à l’état, cliquez sur le bouton "Editer la
requête".

245
Les parties principales de cette requête sont les suivantes :

1. Fichier source parcouru par la requête
2. Conditions de sélection ou filtre
3. Rubriques sélectionnées pour l’édition
WinDev permet de gérer deux types de requête :

• les requêtes intégrées, construites lors de la création d’un élément (état par
Notes
exemple). Ces requêtes ne peuvent pas être ré-utilisées dans un autre élément
du projet.
• les requêtes externes, créées directement avec l’éditeur de requêtes, et enregis-
trées dans un fichier au format WDR.
Pour plus de détails sur les requêtes, consultez la leçon “Créez votre 1ère Requête”, page 251.

246
RAD SQL
Nous allons analyser le RAD en mode SQL.
Pour cela, nous n’allons pas refaire un RAD complet, mais utiliser un projet déjà créé en RAD SQL.
4 Ouvrez le projet "WD RADSQL.WDP" (option "Fichier ... Ouvrir un projet"). Ce projet est présent
dans le sous-répertoire "Autoformation\Corriges\WD RADSQL\" du répertoire d’installation de
WinDev 10. Le projet ressemble au projet précédent. Il utilise la même analyse avec le même
fichier "Produit".
Fenêtres générées
Fenêtre en mode Fiche

Le modèle de fenêtre "Fiche" fonctionne exactement comme le modèle utilisé dans le projet précé-
dent (à la différence près qu’il utilise des ordres SQL). Nous ne détaillerons donc pas les différentes
possibilités offertes par ce type de fenêtre.
4 Pour ouvrir la fenêtre correspondant à la saisie des produits dans l’éditeur, effectuez les mani-
pulations suivantes :
1. Appuyez simultanément sur les touches "CTRL"+"E".

2. Sélectionnez la fenêtre "Fiche_produit".
3. Cliquez sur le bouton "OK".
Code d’initialisation
Ci-dessous, un extrait du code d’initialisation généré par le RAD WinDev :
SI ModeOuverture~="Modif" ALORS
// Execution de la requête pour la modification
HExécuteRequête(REQ_SELECT_PRODUIT,hRequêteDéfaut+...
hModifieFichier,PRODUIT.IDPRODUIT)
// affiche un message d'erreur
Erreur("Erreur initialisation de la requête",HErreurInfo())
// fermeture de la fenêtre
Ferme("",gbFenetreModifiee)
SINON
// Lecture de l'enregistrement en cours de modification
HLitPremier(REQ_SELECT_PRODUIT)
FIN
SINON
// Execution de la requête pour le parcours
HExécuteRequête(REQ_SELECT_PRODUIT,...
hRequêteDéfaut+hModifieFichier)
// affiche un message d'erreur
Erreur("Erreur lors de l'initialisation de la requête")
// fermeture de la fenêtre
Ferme("",gbFenetreModifiee)

247
FIN
FIN
La différence principale avec le code généré dans le chapitre précédent est l’utilisation de requêtes
SQL, exécutées par la fonction HExécuteRequête.
La requête utilisée ("REQ_SELECT_PRODUIT") a automatiquement été générée par le RAD lors de le

construction automatique de l’application. Pour visualiser cette requête :
1. Utilisez le volet "Projet" ( ) de WinDev.
2. Sélectionnez dans la liste déroulante "Requêtes"
3. Double-cliquez sur "REQ_SELECT_PRODUIT"
Conclusion
Nous n’avons étudié ici qu’une partie des possibilités du RAD de WinDev.
Pour une utilisation avancée, sachez que vous avez la possibilité de modifier le code, les fenêtres,
les requêtes et les états générés par le RAD.

248

PARTIE 5
Les requêtes
251
LEÇON 5.1. CRÉEZ VOTRE 1ÈRE REQUÊTE

• Manipulations de l’éditeur de requêtes.

• Etape par étape, la réalisation d’une requête.
Vous trouverez dans le répertoire "\Autoformation\Corriges\Faire des requêtes" le

projet "Faire des requêtes.WDP" contenant les illustrations de cette leçon.
l’option "? .. Guide d’auto-formation .. Faire des requêtes".
Partie 5 : Requêtes

252
Introduction
Une requête permet de définir une interrogation sur des fichiers de données. L’éditeur de requêtes
vous permettra par exemple de décrire sans aucune programmation des interrogations du type :
• la liste des fournisseurs appartenant au département 75.
• la liste des 10 clients qui ont le plus commandé.
• la liste des produits dont le stock est à zéro.
Et ce, sur tous les types de bases (Hyper File, Oracle, ...) !
Nous allons voir avec un exemple simple comment manipuler l’éditeur de requêtes. Plus loin dans
ce cours, nous verrons une utilisation avancée de l’éditeur de requêtes.
Dans cette leçon, vous verrez comment :

• Faire une requête simple correspondant à une liste avec une sélection et un tri.
• Faire une requête de comptage.
• Faire une requête multi-fichiers.
4 Dans
tes".
le menu de WinDev, sélectionnez l’option "? .. Guide d’Auto formation .. Faire des requê-

Vous pouvez parcourir les différentes options du menu et choisir des exemples de requêtes.
Exemple
L’exemple "WD Requêtes" livré avec WinDev 10 illustre l’utilisation des requêtes
avec WinDev.
4 Ouvrez le projet "Faire des requêtes.WDP", présent dans le sous-répertoire "Auformation\Exerci-

ces\Faire des requêtes" du répertoire d’installation de WinDev 10.

253
Votre première requête

Nous allons lister les fournisseurs du département 75.
4 1.
Créez une nouvelle requête :
Dans le menu, sélectionnez "Fichier" puis "Nouveau".
2. Sélectionnez "Requête".
L’assistant de création de requêtes se lance :
Vous avez la possibilité d’utiliser l’assistant de création de requêtes ou de saisir directement le

code SQL de la requête (option "Saisir le code de la requête").
Avec l’assistant, vous pouvez réaliser des requêtes de type :
• "Sélectionner (SELECT)" : interrogation
• "Ajouter (INSERT)" : ajout dans un fichier

• "Modifier (UPDATE)" : modification dans un fichier
• "Supprimer (DELETE)" : suppression dans un fichier
• "Unir (UNION)" : combinaison de requêtes de sélection
Attention !
La saisie directe de code SQL est destinée aux utilisateurs maîtrisant le langage
SQL ! Consultez l’aide en ligne pour obtenir la liste des fonctions SQL reconnues
par WinDev (mot-clé : "SQL, Langage SQL").
Vous allez apprendre à utiliser l’éditeur de requêtes en effectuant des requêtes simples : sélections
de clients, comptages ... vous pourrez ensuite approfondir vos connaissances en manipulant et en
testant tous les types de requêtes.

254
4 Pour lister les fournisseurs du département 75, nous allons réaliser une requête de sélection.
4 Sélectionnez les rubriques qui constitueront le résultat de la requête.
Sur la gauche, dans les "Eléments disponibles",
1. Sélectionnez le fichier "Fournisseur".
2. Double-cliquez sur les rubriques "SOCIETE", "NOMFOURNISSEUR", "CODEPOSTAL" et "VILLE".
Ces rubriques apparaissent au milieu de la fenêtre.
4 Pour obtenir les fournisseurs du département 75, nous allons appliquer une condition de sélec-
tion sur le code postal.
La condition de sélection est la suivante : "Nous désirons les fournisseurs du département 75".
C’est-à-dire les fournisseurs dont le code postal commence par 75. En effet, la rubrique
"Département" n’existe pas dans notre fichier.
4 Sélectionnez la rubrique "CODEPOSTAL" au centre. Dans les "Actions" sur la droite, cliquez sur
le bouton "Condition de sélection" puis sur "Nouvelle condition".
La rubrique est donc : "FOURNISSEUR.CODEPOSTAL"
La condition est : "COMMENCE PAR"
La valeur est : "75"

255
4 Saisissez la valeur et cliquez sur "OK".

4 Nous allons maintenant indiquer le critère de tri.
Nous allons trier le résultat par "NOMFOURNISSEUR".
4 Sélectionnez la rubrique "NOMFOURNISSEUR" au centre puis cliquez dans les "Actions" sur le
bouton "Trier" et sélectionnez l’option "Tri sur la rubrique sélectionnée".
Le tri sera croissant :
4 Validez en cliquant sur le bouton "OK".

Une flèche rouge avec le numéro 01 apparaît à la droite de la rubrique "NOMFOURNISSEUR".
Cette flèche indique qu’un tri croissant est fait sur cette rubrique. Le chiffre "01" indique que ce
sera le premier tri réalisé.

256
4 1.
La requête est créée. Nous allons lui donner un nom et la sauvegarder.
En haut de l’écran, saisissez le nom "Fournisseur75".
2. Saisissez le libellé "Fournisseurs du département 75".
La représentation graphique de la requête est la suivante :


257
4 Cliquez sur pour sauvegarder la requête.
Il ne reste plus qu’à tester la requête.
4 Cliquez sur le bouton "GO" . Le résultat s’affiche dans une table :
Si vous faites un clic droit sur la table affichant le résultat de la requête, un menu contextuel appa-
raît. Vous avez alors la possibilité d’exporter le résultat vers :
• Microsoft Excel.
• un fichier XML (eXtensible Markup Language)
• Microsoft Word. Partie 5 : Requêtes

258
LEÇON 5.2. REQUÊTES AVEC COMPTAGE


• Etape par étape, la réalisation d’une requête avec comptage.


259
Réalisation d’une requête avec comptage

Nous allons maintenant créer une requête qui effectue un comptage. Cette requête permet de
comptabiliser le nombre d’occurrences d’une valeur dans un fichier.
Nous allons compter le nombre de clients par ville.

4 1.
Dans le menu, sélectionnez "Fichier" puis "Nouveau".
3. Nous allons réaliser une requête de "sélection" (Option "Sélectionner (SELECT)"). Cliquez sur
"Suivant".
Nous allons sélectionner les rubriques à récupérer dans le résultat de la requête.
4 Nous devons afficher la ville. Sur la gauche, dans les "Eléments disponibles", sélectionnez la
rubrique "VILLE" du fichier "CLIENT" (par un double-clic).
4 1.
Pour créer une rubrique de comptage :
Sélectionnez au centre la rubrique "VILLE"
2. Cliquez dans les "Actions" sur le bouton "Compter".
3. Sélectionnez dans le menu : "Sur la rubrique sélectionnée".
4. Validez en cliquant sur le bouton "OK".

260
L’action "Compter les enregistrements" est ajoutée dans le résultat de la requête.

Comme nous voulons afficher toutes les villes, sélectionnez à nouveau la rubrique "VILLE" du
fichier "CLIENT" (par un double-clic). La rubrique est affichée au centre de l’écran.
4 1.
En haut de l’écran, saisissez le nom "NombreClientparVille.
2. Saisissez le libellé "Nombre de clients par ville".
La rubrique "Comptage_1" contient le comptage des enregistrements décrit plus haut.
4 Cliquez sur pour sauvegarder la requête. Il ne reste plus qu’à tester la requête.
4 Cliquez sur le bouton .
261
LEÇON 5.3. REQUÊTES SOMME


• Etape par étape, la réalisation d’une requête "Somme".


262
Réalisation d’une requête "Somme"

Nous allons maintenant créer une requête qui effectue une somme. Nous allons faire un cumul
d’une valeur d’un fichier.
Nous allons calculer le total de toutes les commandes par client (le Chiffre d’Affaires par client).

4 1.
Dans le menu, sélectionnez "Fichier .. Nouveau".
3. Nous allons réaliser une requête de sélection. Sélectionnez l’option "Sélectionner (SELECT)".
Nous allons sélectionner les rubriques à récupérer dans le résultat de la requête.

Nous afficherons tout d’abord le nom du client et la ville du client.
4 Sur la gauche, dans les "Eléments disponibles", sélectionnez les rubriques "NOMCLIENT" et
"VILLE" du fichier "CLIENT" (par un double clic).
Ensuite, nous devons sélectionner la rubrique sur laquelle nous allons faire la somme (MONTANT-
TOTAL dans cet exemple).
4 Sur la gauche, dans les "Eléments disponibles", sélectionnez la rubrique "MONTANTTOTAL" du

fichier "COMMANDE" (par un double clic).
4 1.
Pour effectuer la somme des valeurs de "MONTANTTOTAL" :
Sélectionnez la rubrique "MONTANTTOTAL" au centre.
2. Dans les "Actions", sur la droite, sélectionnez "Somme".
3. Validez en cliquant sur le bouton "OK" :

263
La somme des "MONTANTTOTAL" 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).
Vous pouvez ainsi vérifier que vous ne vous êtes pas trompé par rapport à l’objectif de votre
requête.
4 1.
En haut de l’écran, saisissez le nom "CAParClient".
2. Saisissez le libellé "CA par client".

264
La représentation graphique correspond à une "jointure". La requête utilise deux sources de don-
nées (les fichiers "CLIENT" et "COMMANDE").
4 Cliquez sur pour sauvegarder la requête. Il ne reste plus qu’à tester la requête.
4 Cliquez sur le bouton .

265
LEÇON 5.4. LE LANGAGE SQL

• Les principaux ordres du langage SQL.


266
Code source d’une requête

Dans WinDev, la requête est représentée dans l’éditeur sous une forme graphique. Nous allons
découvrir maintenant le code source correspondant à une requête. Le langage utilisé pour présen-
ter une requête est le langage SQL. Il s’agit ici d’une présentation de SQL et non pas d’un cours
complet (il existe des livres entiers sur le sujet !).
Nous allons visualiser le code source SQL de la requête créée dans la leçon précédente.
4 Ouvrez la requête "CAParClient".
4 Dans le menu, sélectionnez l’option "Requête .. Code SQL".
La requête en langage SQL est composée de différents mots clés :

• l’instruction SELECT
• l’instruction FROM
• la clause WHERE
• la clause GROUP BY
Attention !
Veillez à bien respecter l’enchaînement de ces ordres. Vous ne pouvez pas inver-
ser cet enchaînement.
WinDev permet de passer très simplement de la description graphique d’une requête au code SQL
de cette requête et inversement.
Pour afficher le code SQL d’une requête créée sous l’éditeur de requêtes, sélectionnez l’option
"Requête .. Code SQL".
Pour afficher la représentation graphique d’une requête créée en code SQL, sélectionnez "Requête
.. Rétro-analyse de la requête".

267
Les ordres SQL

L’instruction SELECT
L’instruction SELECT permet de définir la liste des rubriques et des calculs à visualiser dans le
résultat. La syntaxe est la suivante :
SELECT NOMRUBRIQUE1, NOMRUBRIQUE2 ...
Chaque rubrique peut être renommée (on parle d’alias) en utilisant le mot-clé AS. Par exemple :
CLIENT.NOMCLIENT AS NOM
Dans cet exemple, la rubrique NomClient du fichier CLIENT est renommée en Nom.
NomRubriqueXX peut être soit une rubrique associée à un fichier, soit une formule de calcul.
L’instruction FROM
L’instruction FROM permet de définir la liste des fichiers à partir desquels seront extraites les rubri-
ques et les calculs. La syntaxe est la suivante :
FROM FICHIER1, FICHIER2 ...
FichierXX correspond à un des fichiers de l’analyse. L’utilisation de AS est possible.
La clause WHERE
La clause WHERE contient les conditions de sélection ainsi que les conditions de jointure. Ces con-
ditions permettent de filtrer les enregistrements issus des fichiers de la base de données. Seuls les
enregistrements vérifiant la ou les conditions seront récupérés dans le résultat.
Une jointure permet de faire correspondre à un enregistrement d’un fichier l’enregistrement d’un
fichier relié. Par exemple, une jointure entre les fichiers CLIENT et COMMANDE permettra de con-
naître toutes les commandes de chaque client.
La syntaxe est la suivante :

WHERE CONDITION1 ET/OU CONDITION2
Les opérateurs ET et OU permettent de réaliser une opération logique entre deux conditions.
• L’opérateur ET indique que les deux conditions doivent être vérifiées en même temps.
• L’opérateur OU indique qu’une des deux conditions ou les deux conditions doivent être véri-
fiées.
La clause WHERE n’est pas obligatoire. Si ce mot-clé n’est pas indiqué, tous les enregistrements de
tous les fichiers seront sélectionnés.

268
La clause GROUP BY
La clause GROUP BY permet d’indiquer les rubriques ou formules de regroupement lorsqu’il y a un
calcul. Par exemple, dans la requête que nous avons réalisée précédemment, le calcul portait sur
la somme des commandes par client; c’est-à-dire que les commandes étaient cumulées pour cha-
que client. Le regroupement des commandes était donc réalisé par client.

GROUP BY RUBRIQUE1, RUBRIQUE2 ...
RubriqueXX correspond à une rubrique d’un des fichiers ou à une formule.
La clause ORDER BY
La clause ORDER BY permet d’indiquer les critères de tri de la requête. Les critères de tri permet-
tront de classer le résultat de la requête.

ORDER BY RUBRIQUE1, RUBRIQUE2 ...
RubriqueXX correspond à une rubrique d’un des fichiers ou à une formule.

Notes
L’éditeur de requêtes génère automatiquement le code SQL. C’est également un

moyen didactique de se former à ce langage !

269
LEÇON 5.5. UTILISATION DES REQUÊTES

• Utilisation des requêtes dans les états.

• Utilisation des requêtes dans les champs (listes, combos, tables, zones répétées).
• Utilisation des requêtes en W-Langage.

270
Utilisation d’une requête depuis un état

Lors de la création d’un état, vous pouvez choisir la source de données. La source de données peut
être une requête, un fichier de données, ... Il est possible de faire un état qui travaille directement
sur le résultat d’une requête (pour plus de détails, consultez la leçon sur les états, page 273.
Utilisation d’une requête depuis un champ

Comme pour les états, lors de la création d’un champ table, d’une liste, d’une combo ou d’une
zone répétée, il est possible de définir la source de données pour le remplissage. Cette source peut
être un fichier ou une requête.
Utilisation d’une requête depuis le W-Langage

Vous pouvez également utiliser une requête comme si vous utilisiez un fichier de données. Vous
devez uniquement initialiser l’exécution de votre requête avec la fonction HExécuteRequête. Lors-
que votre parcours est terminé, utilisez la fonction HAnnuleDeclaration. Cette fonction optionnelle
permet d’annuler la définition de la requête. Votre parcours peut s’effectuer normalement avec les
fonctions HLitPremier et HLitSuivant ::
// Initialise la requête
HExécuteRequete(MaRequête)
Erreur("Erreur d’initialisation de la requête"+RC+...
HErreurInfo())
RETOUR
FIN
// lecture du premier enregistrement de la requête
HLitPremier(MaRequête)
TANTQUE PAS HEnDehors()
// Traitement sur l’enregistrement de la requête

// lecture de l’enregistrement suivant
HLitSuivant()
FIN
HAnnuleDéclaration(MaRequête) //optionnel
Offrez la possibilité aux utilisateurs de vos applications de créer eux-mêmes leurs

états et requêtes (ou de modifier des états ou des requêtes que vous mettez à leur
Notes
disposition) !
Il suffit de livrer le logiciel "Etats et requêtes" avec votre application. Pour plus de
détails, consultez le chapitre "Les états", page 273.

PARTIE 6
Les états
273
LEÇON 6.1. VOTRE PREMIER ETAT

• Vocabulaire de base.
• Etape par étape, la construction d’un état.
Vous trouverez dans le répertoire "\Autoformation\Corriges\Faire des éditions" le pro-

jet "Faire des éditions.WDP" contenant les illustrations de cette leçon.
l’option "? .. Guide d’auto-formation .. Faire des éditions".
Partie 6 : Les états

274
Vocabulaire de base
Avant d'aborder les méthodes d'impression, il est important de rappeler le vocabulaire de base
pour ... faire bonne impression !
• Fonte : La fonte définit la forme du caractère (épaisseur de trait, espacement entre

caractères, ...). Par exemple, ce document est imprimé en fonte "Franklin Gothic" (les exemples
de programme en fonte "Courier").
Les fontes sont fréquemment appelées polices par "abus" de langage : nous parlerons donc plu-
tôt de police que de fonte.
• Style : Le style peut être italique, gras, souligné, ... Il ne modifie pas la hauteur des caractères.
• Hauteur du caractère : La hauteur du caractère s'exprime en "point Didot". Un point vaut 0,3759
mm. C'est une unité utilisée en imprimerie. La hauteur des caractères de ce manuel est par
exemple de 10 points. Les hauteurs de 10 et 12 points sont des hauteurs courantes pour des
documents habituels. La hauteur des caractères est indépendante de la définition de l'impri-
mante.
Une hauteur de 16 ou 24 points permet de mettre en valeur un titre.
Une hauteur de 6 points sera difficilement lisible, surtout si la définition de l'imprimante est mau-
vaise
• Police : La police est la forme avec laquelle le texte sera imprimé. Elle correspond à la combinai-
son de la fonte, du style, de la hauteur et de la couleur du caractère.
• Définition de l'imprimante : Chaque imprimante a une définition propre. Plus la définition est
importante, plus convenable sera l'impression. Par exemple, une imprimante à 600 DPI (dots per
inch) fournira des impressions plus nettes qu'une imprimante à 300 DPI. Le type d'impression
(laser, jet d'encre, matricielle 8 ou 24 aiguilles,...) influe également sur la qualité d'impression. La
qualité du papier également, il ne faut pas l'oublier !
• Proportionnelle / Fixe : Une police "fixe" présentera toujours la même largeur de caractère, quel
que soit le caractère. Un "i" aura la même taille qu'un "m". Une police fixe bien connue est "Cou-
rier".
Une police "proportionnelle" utilisera une taille différente en fonction des lettres. Cette documen-
tation est écrite dans une police proportionnelle.
Un Etat est le nom donné à la représentation d’une édition. WinDev vous permet de construire des
états. Lors de l’exécution (ou de l’édition) de l’état, un document est créé.

275
Il existe différentes formes d’états :

• Vierge
• Tableau
• Fiche
• Etiquette
• Mailing
• Formulaire
• Graphe
• Tableau avec graphe
• Tableau croisé
Un Bloc est le nom donné à une partie de l’état. Un état est constitué d’un ensemble de blocs. Les
différents blocs d’un état sont les suivants :
• début de document
• haut de page
• haut de rupture
• corps
• bas de rupture
• bas de page
• fin de document
Il existe également d’autres blocs que nous ne détaillerons pas ici :

• bloc d’itération
• complément de corps
Ces différents blocs ne sont pas tous obligatoires. Ils peuvent être supprimés lors de la conception
de l’état. Seul le bloc "Corps" est obligatoire.
Vous avez également la possibilité d’imprimer des états avec code-barres (automatiquement géné-
rés par WinDev), des états avec étiquettes, ...

276
Présentation
Imprimer avec l'éditeur d'états ou imprimer en W-Langage
WinDev propose deux méthodes d’impression :
• l'éditeur d'états qui permet de créer des états imprimés d'une façon "conviviale".
• par programmation en W-Langage.
Par exemple, il est courant d'imprimer une liste dont les données proviennent d'un fichier.
Pour imprimer le contenu d'un fichier de données, l'utilisation de l'éditeur d'états est conseillée.
Vous découvrirez plus loin dans ce guide comment effectuer une impression par programmation.
Nous allons tout d’abord étudier quelques exemples d’états réalisés avec l’éditeur d’états, ensuite
nous verrons en détail comment les réaliser.
Quelques exemples d’états
4 Sélectionnez l’option "? .. Guide d’Auto formation .. Faire des éditions". Le programme se lance.
La fenêtre ci dessous apparaît.
Parcourez les différentes options du menu et testez les différentes éditions.

Maintenant, passons à la réalisation !
4 Pour apprendre à utiliser l’éditeur d’états, nous allons créer quelques éditions dans un projet
exemple préparé à cet effet.
1. Sélectionnez l’option "Fichier .. Ouvrir un projet".
2. Sélectionnez le sous-répertoire "AutoFormation\Exercices\Faire des éditions\" du répertoire
3. Sélectionnez le fichier "Faire des éditions.WDP".
Le projet se charge.
Ce projet utilise des fichiers de données. Afin de vous familiariser rapidement avec les données,
nous avons pris pour exemple des fichiers simples :
• un fichier CLIENT
• un fichier COMMANDE
• un fichier LIGNECDE
• un fichier PRODUIT
• un fichier FOURNISSEUR

277
Ci-dessous la modélisation logique (MERISE) des données utilisées (appelé MLD) :
Les états à créer

4 •Pour apprendre à utiliser l’éditeur d’états, nous allons créer les exemples suivants :
Liste des clients triée par code postal
• Impression des commandes par client
Création de votre premier état

Création de l’état : Liste des clients triée par code postal
Nous allons imprimer la liste des clients triée par code postal. Pour cela, nous allons utiliser un état
de type tableau, qui permet de représenter clairement une liste de données.
4 Pour créer un état, sélectionnez l’option "Fichier .. Nouveau". Dans la fenêtre qui apparaît, choi-
sissez "Etat".

278
La fenêtre suivante propose plusieurs présentations d’un état :
4 Sélectionnez "Tableau" et cliquez sur le bouton Suivant.

4 Sélectionnez la source de provenance des données de l’état.
4 Sélectionnez "D’une requête" et cliquez sur le bouton "Suivant".

279
La requête n’existant pas, nous allons la créer.
4 Sélectionnez "Une requête que je veux définir maintenant" et cliquez sur suivant.
4 L’assistant de description d’une requête s’affiche. Cet écran permet de sélectionner les fichiers
contenant les données à imprimer.Nous allons imprimer des données provenant du fichier
CLIENT.
4 Cliquez sur le signe "+" à gauche du fichier CLIENT. Sélectionnez les rubriques à imprimer (par
un double clic) :
• NomClient
• CodePostal
• Ville
• idClient

280
4 1.
Pour trier par code postal, il faut choisir un critère de tri :
Sélectionnez la rubrique à trier : cliquez sur le "CodePostal" au milieu de l’écran.
2. Cliquez en haut à droite sur le bouton "Trier". Choisissez l’option "Trier sur la rubrique sélec-
tionnée".
3. Choisissez "Ordre croissant" et validez. Une flèche rouge apparaît à droite de la rubrique
"CodePostal" ainsi que le numéro "01". Cette flèche indique qu’un tri croissant est fait sur cette
rubrique. Le numéro "01" indique que ce tri sera le premier tri effectué.
4 Nous allons valider cet écran : cliquez sur le bouton "Suivant".

L’assistant demande d’indiquer s’il y a une rupture.

281
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 entendus imprimés.
Une rupture est OBLIGATOIREMENT liée à un tri.
Notez la présence d’un en-tête de rupture et d’une fin de rupture.
Notes
Les informations communes aux différentes lignes sont présentes dans l’en-tête
de rupture.
Les totaux, compteurs, ... sont présents dans la fin de rupture.
Cette rupture permet de regrouper une série d’enregistrements par rapport à un

même critère. Dans notre exemple, la rupture concerne le code postal et permet
de regrouper tous les clients d’une même commune.
4 Répondez "Oui" et cliquez sur "Suivant".

282
4 La rupture s’effectue sur le code postal. Cliquez sur suivant.

4 Vous allez ensuite indiquer dans quel ordre sont imprimées les rubriques et leur répartition
dans les différents blocs.
Dans notre exemple, le code postal et la ville seront dans le bloc "haut de rupture 1" et le nom
dans le corps.
Dans la colonne de droite, sélectionnez "haut de rupture 1" pour "Ville".
Décochez la rubrique "idClient".
Les flèches bleues à droite permettent de modifier l’ordre des rubriques. Vous pouvez par exemple
afficher la ville avant le nom.

283

Cet écran permet de définir la mise en page de l’état.
Nous garderons les valeurs par défaut avec l’orientation "Portrait".

Lors du choix des marges d'impression, n'oubliez pas de tenir compte des 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.

4 Sélectionnez par exemple le gabarit "Active XP" et cliquez sur "Suivant". Partie 6 : Les états

284
4 1.
Il ne nous reste plus qu’à donner un nom et un libellé à l’état et à le sauvegarder.
Saisissez le nom "ClientParCodePostal".
2. Saisissez le titre "Liste des clients par code postal".
3. Cliquez sur "Terminer".
4. Enregistrez l’état. L’état est terminé. Nous allons immédiatement le tester pour voir le résul-
tat.
4 Exécutez cet état en cliquant sur l'icone "GO" de la barre d'icones.
La destination de l’impression peut être au choix :


285
4 Choisissez "Aperçu avant impression" et cliquez sur le bouton "OK".

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 les impriman-
tes
• Sélectionner un niveau de zoom plus ou moins important avec les icones .

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

286
LEÇON 6.2. ETATS STATISTIQUES

• Lier plusieurs fichiers de données dans un état.

• Faire des regroupements dans un état.


287
Présentation
Nous allons maintenant éditer la liste des commandes par client. Cette liste sera triée sur le nom
du client. Pour chaque client, nous imprimons la commande et le détail de la commande (lignes)
avec un sous-total pour chaque commande. Nous cherchons à obtenir un résultat semblable à la
représentation ci-dessous :
L’état que nous allons réaliser utilise plusieurs fichiers de données comme source.
Etape par étape
4 Ouvrez le projet "Faire des éditions.WDP". Ce projet est présent dans le répertoire "AutoForma-
tion\Exercices\Faire des éditions\" du répertoire d’installation de WinDev 10.

288
4 Pour créer un nouvel état, sélectionnez l’option "Fichier .. Nouveau .. Etat".
4 Sélectionnez "Tableau" et cliquez sur le bouton "Suivant".

4 Sélectionnez "D’une requête" et cliquez sur le bouton "Suivant".
La requête n’existant pas, nous allons la créer.

289
4 Sélectionnez "Une requête que je veux définir maintenant" et cliquez sur "Suivant".
Nous allons imprimer des données provenant des fichiers CLIENT, COMMANDE, PRODUIT et
LIGNECDE.
4 Sélectionnez les rubriques suivantes à imprimer (par un double clic) :

• Le fichier CLIENT :
• NomClient
• RaisonSociale
• CodePostal
• Ville
• Le fichier COMMANDE :
• IdCommande
• DateCommande
• Le fichier PRODUIT :
• Descriptif
• Le fichier LIGNECDE :
• Reference
• Qtecommandee
• Montant

290
Nous allons trier les résultats par nom de client et par numéro de commande.
4 Dans
tri :
la liste au centre, sélectionnez la première rubrique sur laquelle vous désirez effectuer un
1. Cliquez sur la rubrique "NomClient". Dans le menu contextuel (clic droit de la souris), sélec-
tionnez "Trier la rubrique ... Trier par ordre croissant".
2. Cliquez ensuite sur la rubrique "IdCommande". Dans le menu contextuel (clic droit de la sou-
ris), sélectionnez "Trier la rubrique ... Trier par ordre croissant".
3. Validez.
Une flèche rouge apparaît à droite des rubriques "NomClient" et "IdCommande". Le chiffre situé à
coté de chaque flèche indique l’ordre de tri réalisé.
4 Nous allons valider cet écran. Cliquez sur le bouton "Suivant".

291
4 Nous allons maintenant indiquer les ruptures. Choisissez "Oui" puis sur le bouton "Suivant".
Par défaut, une rupture est proposée sur les rubriques "NomClient" et "IdCommande", car ce sont
les critères de tri déjà définis.
4 Déselectionnez la rubrique NomClient (cliquez sur la coche). Cliquez sur le bouton "Suivant".
Vous allez ensuite définir la répartition des rubriques.
Les informations concernant le client et la commande seront dans le haut de rupture 1. Le corps
de l’édition concerne le détail de chaque commande.

292
4 Répartissez les rubriques comme indiqué dans l’image ci-dessous :

Il faut maintenant indiquer s’il y a des sommes ou des comptages dans l’état. Nous allons addition-
ner le montant des lignes de commandes.
Cette somme sera placée dans une rupture. Nous allons conserver uniquement la somme sur le
montant. Vous allez indiquer qu’il n’y a aucun calcul sur la quantité.
4 Cliquez sur suivant.

4 Nous conserverons les paramètres par défaut pour le format de la page.
293

4 Choisissez un gabarit et cliquez sur le bouton "Suivant".
4 Donnez un nom à l’état pour terminer : "CommandesParClient" par exemple.
4 Validez en cliquant sur le bouton "Terminer". L’état étant trop grand, l’éditeur d’états propose
de changer le format de l’état ou de le réduire.
4 Sélectionnez le mode paysage et validez.


294
L’état apparaît sous l’éditeur :
4 Modifiez si nécessaire la mise en forme des champs.

4 Nous allons maintenant ajouter un interrupteur dans cet état.
Les interrupteurs dans les états permettent notamment de reproduire des formulaires (par
exemple, les cases à cocher "Monsieur", "Madame", ...).
Une rubrique du fichier "CLIENT" indique si le client possède un compte chez le fournisseur (en
l’occurrence chez nous). Cette rubrique peut prendre la valeur "Oui" ou "Non".
4 Sélectionnez l’option "Insertion .. Nouveau champ .. Interrupteur". Placez l’interrupteur sur
l’état dans le bloc "Haut de rupture 1".
4 1.
Dans l’onglet "Général" des propriétés de l’interrupteur (clic droit, "Description") :
Saisissez le nom du champ, "INTENCOMPTE".
2. Cliquez sur le bouton "Autres..." et sélectionnez la rubrique liée "EnCompte" du fichier

"CLIENT".
3. Validez ensuite par "OK".

295
4 Ajoutez un libellé que vous positionnerez à côté de l’interrupteur, et saisissez le texte "Client
Enregistré".
4 Voici l’état, tel qu’il apparaît sous l’éditeur :
4 Enregistrez l’état, et testez-le avec le bouton .

296

297
LEÇON 6.3. ETATS TABLEAU CROISÉ

• Etape par étape, la création d’un état tableau croisé.


298
Présentation
L'éditeur d'états offre également la possibilité de créer des états de type "Tableau Croisé". L'état
est alors constitué uniquement d'un tableau à deux entrées.
Exemple :
Contrairement aux autres types d'états, l'état "Tableau croisé" est toujours basé sur une requête
intégrée. Cette requête est créée grâce à l'assistant de création de l'état "Tableau croisé". Vous
pourrez par ailleurs modifier cette requête une fois votre état créé.
Etape par étape

Nous allons réaliser un état de synthèse sur le chiffre d’affaires par client et par année. Ce tableau
peut être représenté de plusieurs façons :

• en indiquant pour chaque client, les différentes années considérées et le chiffre d’affaires
correspondant.
• en réalisant un tableau croisé, de façon à trier les résultats à la fois par client (vertical) et par
année (horizontal). C’est cette méthode que nous allons utiliser.
4 Ouvrez le projet "Faire des éditions.WDP". Ce projet est présent dans le répertoire "AutoForma-
tion\Exercices\Faire des éditions\" du répertoire d’installation de WinDev 10.
4 Sélectionnez dans le menu "Fichier .. Nouveau .. Etat".
4 Sélectionnez "Tableau Croisé" et cliquez sur "Suivant".
L’assistant vous propose alors de choisir la rubrique qui servira de source de données pour les en-
têtes de colonnes. Vous pouvez ainsi définir la première entrée (ligne) de votre tableau croisé.

299
4 Sélectionnez la rubrique "DateCommande" dans le fichier "COMMANDE".

L’assistant vous propose alors deux choix (jour et année).
Choisissez "Année" puis cliquez sur "Suivant"
4 L’assistant vous demande si vous souhaitez "borner" les dates. Ne cochez rien, nous allons
prendre toutes les commandes. Cliquez sur "Suivant".
4 L’assistant vous demande maintenant de choisir la rubrique qui servira de source de données
pour les lignes. En fait, vous allez choisir la seconde entrée (colonne) de votre tableau croisé.
Sélectionnez la rubrique "NOMCLIENT" dans le fichier "CLIENT".

L’assistant vous demande maintenant de sélectionner le type d’information à afficher dans les cel-
lules du tableau croisé. Comme nous voulons afficher le C.A. par client et par date, nous allons
demander une somme des montants totaux de chaque commande passée pour chaque client cha-

300
que année.
4 Sélectionnez "La somme de la rubrique :". Dans la liste qui apparaît sur le côté, choisissez la
rubrique "MONTANTTOTAL" du fichier "COMMANDE" :

L’assistant vous propose de calculer une somme par ligne et une somme par colonne. Nous
allons accepter ce calcul :
4 Cliquez sur "Suivant". Ne changez rien à la mise en page. Validez par "Suivant".
4 Sélectionnez un gabarit (par exemple "ActivXP". Cliquez sur "Suivant".
4 1.
Vous allez donner un nom à cet état :
Saisissez le nom : "EtatTabCroisé".
2. Saisissez la description : "Synthèse des commandes par client et par date".

301
3. Cliquez sur "Terminer". L’état apparaît sous l’éditeur d’états.
4 Modifiez si nécessaire la taille des colonnes pour obtenir la même mise en page que ci-dessus.
Enregistrez l’état. Il ne reste plus qu’à tester en cliquant sur l'icone .
Vous venez de réaliser facilement un état tableau croisé. Ce type d’état peut bien entendu être uti-
lisé pour d’autres applications, notamment pour effectuer des comparatifs, des statistiques, ...

302
LEÇON 6.4. CHAMPS SPÉCIFIQUES

• La création d’un lien dans un état.

• La création d’un champ clicable (dans l’aperçu)


303
Présentation
L’éditeur d’états de WinDev propose deux fonctionnalités originales au niveau des champs :
• Les champs Lien, utilisables aussi bien dans les états générés en HTML que dans les états
affichés dans l’aperçu avant impression.
Les champs lien permettent d’ouvrir directement un site à partir d’un état. Il est ainsi possi-
ble d’imaginer un récapitulatif de commande envoyé par e-mail. Cet état peut contenir un lien
vers le site de la société, un lien pour envoyer un e-mail à la société, ...
• Les champs clicables, utilisables uniquement dans l’aperçu avant impression.
Dans ce cas, le clic sur un des champs de l’état déclenche un traitement spécifique, par
exemple l’affichage de la fiche complète du client sélectionné.
Dans l’aperçu avant impression, ces deux types de champs sont facilement repérables grâce à des
petites étoiles.
Manipulations pour créer un champ Lien
4 Ouvrez si nécessaire le projet "Faire des éditions.WDP". Ce projet se trouve dans le sous réper-
toire "Autoformation\Exercices\Faire des éditions" de WinDev 10.)
4 Ouvrez l’état "FactureAvecLien.WDE".
4 Affichez la description du champ "Lien". Ce lien permet à l’internaute de visiter le site de la
société qui le facture.
Remarque : Un champ Lien dans un état peut afficher le contenu d’une rubrique ou une URL. Dans
ce cas, il est possible de :
• afficher une page d’un site
• se connecter à un serveur FTP

304
• télécharger, ouvrir, afficher un fichier

• envoyer un e-mail
4 Testez l’état. Ce lien fonctionne en aperçu avant impression (une étoile près du lien indique que
ce lien est clicable) ou en mode HTML.
Manipulations pour créer un champ clicable
toire "Autoformation\Exercices\Faire des éditions" de WinDev 10.)
4 Ouvrez l’état créé précédemment "ClientParCodePostal" (ou l’état "ClientCodePostal" si vous ne
l’avez pas créé). Cet état liste les client par code postal. Nous allons permettre à l’utilisateur de
cliquer sur le nom du client pour voir le détail des informations le concernant dans une fenêtre
fiche.
4 Le projet contient déjà la fenêtre à ouvrir : Fiche_Client. Ouvrez cette fenêtre sous l’éditeur de
fenêtres (option "Fichier .. Ouvrir"). Cette fenêtre a été crée par le RAD. Son code de déclaration
des globales a été modifié pour permettre d’afficher le client dont l’identifiant est passé en

305
paramètre.
4 1.
Pour ouvrir directement la fenêtre "Fiche_Client" depuis l’aperçu avant impression :
Sous l’éditeur d’états, cliquez sur le champ "NomClient".
2. Affichez le code de ce champ (option "Code" du menu contextuel).
3. Saisissez le code suivant dans le traitement "Clic sur NomClient":
Ouvre(FicheClient, "Modif", MaSource.IdClient)
Ce code permet de :
•ouvrir la fenêtre FicheClient en mode Modification
•passer en paramètre à la fenêtre l’identifiant du client cliqué (cet identifiant est présent
dans la requête intégrée à l’état).
4. Enregistrez et testez votre état.

306
LEÇON 6.5. EXÉCUTION DES ETATS

• Exécution des états en W-Langage.


307
Exécuter les états en W-Langage

Vous avez créé des états qui ont été testés depuis l'éditeur. Nous allons voir comment lancer l’exé-
cution d’un état depuis un programme.
WinDev permet d’exécuter directement les états depuis une application grâce aux
Notes
fonctions du W-Langage. Sachez que vous avez également la possibilité de rajou-

ter du code pour effectuer des traitements spécifiques à l’intérieur de chaque bloc
de l’état (par exemple : faire un calcul, afficher une boîte de dialogue ...).
La syntaxe générale d’exécution d’un état est la suivante :

// prévisualisation de l'état "Etiquetteclient"
iAperçu(100)
// Impression de l’état
iImprimeEtat(Etiquetteclient)
En exécutant ce code, un écran d’aperçu vous sera proposé. Pour imprimer directement l’état sans
passer par une fenêtre de prévisualisation, supprimez la ligne :
iAperçu(100)
Fonction iAperçu
La fonction iAperçu permet de sélectionner le mode d’édition. La syntaxe de la fonction iAperçu est
la suivante :
iAperçu(<format de sortie>)
Le paramètre <format de sortie> peut prendre différentes valeurs :

• iImprimante : pour une sortie directe sur l’imprimante courante
• iPage : pour afficher à l’écran la page complète

• i2Page : pour afficher 2 pages à l’écran
• i100 : pour afficher la page en zoom 100%
• iFichier : pour imprimer l’état dans un fichier texte
• iHTML : pour imprimer l’état au format HTML
• iHTMLSansCSS : pour imprimer l’état au format HTML sans feuille de styles
• iPdf :pour imprimer l’état au format PDF
• iRTF : pour imprimer l’état au format RTF
• iXML : pour imprimer l’état dans un fichier XML
• iFax : pour une sortie directe sur un fax.
Pour plus de détails sur la fonction iAperçu, consultez l’aide en ligne (mot-clé : "iAperçu").

308
Fonction iImprimeEtat
La fonction iImprimeEtat permet d’exécuter un état. La syntaxe de cette fonction est la suivante :
iImprimeEtat(<Nom de l’état>)
Remarque
D’autres syntaxes sont possibles pour ces deux fonctions, consultez l’aide en ligne pour plus de
détails (mots-clés : "Impression d'un état", "iAperçu", "iImprimeEtat").
Offrez la possibilité aux utilisateurs de vos applications de créer eux-mêmes leurs

états et requêtes (ou de modifier des états ou des requêtes que vous mettez à
Notes
leur disposition) !
Il suffit de diffuser avec votre application le logiciel "Etats et requêtes". Pour plus
de détails, consultez la leçon suivante.

309
LEÇON 6.6. DIFFUSEZ "ETATS ET REQUÊ-

TES" AVEC VOS APPLICATIONS
• A quoi sert l’application "Etats et Requêtes".

• Comment diffuser l’application "Etats et requêtes".
• Comment utiliser l’application "Etats et requêtes".

WinDev 10 version "Express" :

Cette fonctionnalité n’est pas disponible dans cette version d’évaluation.

310
Présentation du logiciel "Etats et Requêtes"

Le logiciel "Etats et Requêtes" permet aux utilisateurs de vos applications de modifier et de créer à
leur convenance les états de vos applications.
Un utilisateur trouve qu’il manque une information sur l’état fourni en standard ? Avec le logiciel
"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 à disposition de
tous les utilisateurs utilisant l’application en réseau.
Le logiciel "Etats et Requêtes" remplace le logiciel "WDETAT Utilisateur". Ce logiciel

Notes
est désormais gratuit et librement redistribuable avec vos applications créées

avec WinDev. Consultez la licence pour plus de détails sur les conditions de redis-
tribution.
Lancement du logiciel Etats et Requêtes

Pour que les utilisateurs finals 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 finals de lancer le logiciel Etats et Requêtes :
• soit affichez vos états sous la fenêtre d’aperçu avant impression. Les utilisateurs finals pour-
ront lancer le logiciel Etats et Requêtes en cliquant l’icone .
• soit ajoutez le menu "?" dans la fenêtre principale de votre application (option "Fenêtres ..
Menu principal .. 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écessaire
de :
• indiquer au niveau du projet que l’application autorise le lancement du logiciel "Etats et requê-
tes".
• définir si nécessaire au niveau de l’analyse les fichiers et rubriques qui seront utilisable avec le
logiciel "Etats et requêtes".
• définir au niveau des états, quels seront les états manipulables ou non avec 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. Vous pouvez réaliser les manipulations suivantes sur
le projet "Faire des éditions.WDP" que nous avons manipulé jusqu’à présent.

311
Paramétrage du projet
Pour utiliser le logiciel "Etats et Requêtes" à partir de votre application, il est nécessaire de configu-
rer le projet associé à votre application.
toire "Autoformation\Exercices\Faire des éditions" de WinDev 10).
4 Affichez l’onglet "Charte" de la description du projet (option "Projet .. Description du projet").
4 Cochez l’option "Autoriser le lancement de "Etats et Requêtes"". Validez.
Paramétrage de l’analyse pour l’application "Etats et requêtes"
Nous allons maintenant ouvrir l’analyse pour paramétrer les fichiers et rubriques utilisables sous le
logiciel "Etats et Requêtes".
4 Ouvrez l’analyse (option "Projet .. Charger l’analyse").
Par défaut, tous les fichiers et toutes leurs rubriques sont visibles et manipulables avec le logiciel
"Etats et requêtes". Si votre application contient des informations sensibles (mots de passe, ...)
vous pouvez rendre ces fichiers ou rubriques invisibles sous le logiciel "Etats et requêtes".
A partir du logiciel "Etats et requêtes", l’utilisateur ne peut pas ajouter, modifier ou

supprimer des enregistrement (les fonctions HAjoute, HModifie et HSupprime
Notes
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 interdi-
tes).
Pour définir un fichier invisible sous le logiciel "Etats et requêtes" :

1. Sous l’éditeur d’analyses, sélectionnez le fichier voulu.
2. Affichez la fenêtre de description du fichier (option "Structure de fichiers .. Description" ou
option "Description du fichier" du menu contextuel).
3. Dans l’onglet "Général", décochez l’option "Visible par l’utilisateur final (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 voulu.
2. Affichez la fenêtre de description du fichier (option "Structure de fichiers .. Rubriques" ou
option "Description des rubriques" du menu contextuel).
3. Sélectionnez dans la table, la rubrique voulue.
4. Dans l’onglet "Info", décochez l’option "Visible par l’utilisateur final (logiciel Etats et Requê-
tes)".
5. Validez.
4 Pour prendre en compte les modifications effectuées dans l’analyse, il est nécessaire de régé-
nérer l’analyse (option "Analyse .. Génération").

312
Paramétrage des états

Par défaut, un état n’est pas modifiable sous le logiciel "Etats et Requêtes". 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 un état de votre application modifiable sous le logiciel "Etats et Requêtes" :
1. Ouvrez l’état sous l’éditeur d’états.
2. Affichez la description de l’état (option "Etat .. Description").
3. Dans l’onglet "Détail", cochez "Modifiable sous Etats et Requêtes".
4. Validez et enregistrez l’état.
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. C’est lors de la création de la procédure d’installa-
tion, que vous pourrez indiquer les paramètres spécifiques au logiciel "Etats et Requêtes".
4 Pour créer l’exécutable de votre application, sélectionnez l’option "Atelier .. Générer l’exécuta-
ble Windows".
Par exemple, vous pouvez créer l’exécutable du projet "Faire des éditions".
4 Pour créer le programme d’installation de votre application, sélectionnez l’option "Atelier ..
Créer la procédure d’installation". L’assistant de création d’installation se lance.
1. Sélectionnez "Non : Lancer la création d’installation maintenant". Cliquez sur "Suivant".
2. Choississez une "Installation autonome". Cliquez sur "Suivant".
3. Chosissez une "installation standard". Cliquez sur "Suivant".
4. Dans l’écran "Fichiers installés", sélectionnez les fichiers de données (.fic, .mmo et .ndx) pré-
sent dans le répertoire de l’exécutable. Pour celà, cliquez sur "Ajouter" et sélectionnez ces
fichiers. Cliquez ensuite sur le bouton "Suivant".
5. Dans l’écran intitulé "Etats et Requêtes", spécifiez si vous voulez incorporer l’installation de
"Etats et Requêtes" dans votre programme d’installation.
Dans ce cas, le package d’installation du logiciel "Etats et Requêtes" est recherché. Par défaut,
ce pack d’installation est présent dans le sous-répertoire "Etats et requêtes" du répertoire d’ins-
tallation de WinDev 10.

Attention : Incorporer le logiciel "Etats et Requêtes" augmente la taille de votre installation de
façon non négligeable (environ 100 Mo).

313
6. 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 requê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 ou non être modifiés lors de l’installation de l’application.
7. Continuez l’assistant jusqu’à la génération du programme d’installation de votre application
(dans notre exemple, l’application "Faire des éditions").
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’applica-
tion "Faire des éditions".
Le programme d’installation est présent dans le répertoire "\Autoformation\Corriges\Faire des édi-
tions\Install".
4 Lancez le programme "Install.exe". L’installation se lance.
4 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)

314

4 L’écran suivant permet de définir les répertoires utilisés pour l’enregistrement des états.
Cliquez sur "Suivant" et terminez l’installation de l’application.

4 L’installation de l’application, puis l’installation du logiciel "Etats et requêtes" se lance.

315
Test de l’application
Nous allons maintenant nous placer dans la peau de l’utilisateur final de votre application (c’est
pas évident, mais pourquoi pas).
4 Lancez l’application "Faire des éditions".
4 Sélectionnez l’option "Edition .. Liste triée". L’état apparaît en mode "Aperçu avant impression".
Dans cet écran, deux nouveaux icones font leur apparition :

Permet de modifier l’état en cours dans l’aperçu avant impression.
Permet de créer un nouvel état.
4 Nous allons modifier cet état :


316
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 modifi-
cation 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).
4 1.
Dans cet exemple, nous allons mettre la date en rouge. Pour cela :
Sélectionnez le champ date dans le début de document.

2. Dans la barre des champs, cliquez sur l’icone "Palette" ( ) 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" ainsi que l’aperçu en cours.
5. Sélectionnez l’option "Edition .. Liste triée" 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 et Requêtes". Pour plus de détails, consultez
l’aide en ligne (mot-clé : Etats et Requêtes).

PARTIE 7
Programmation
319
LEÇON 7.1. LE MULTI-FENÊTRAGE

• Modes d’ouverture des fenêtres.

• Gestion du multi-fenêtrage avec le W-Langage.
• Accéder aux champs, procédures et traitements d’une fenêtre en W-Langage.
Vous trouverez dans les répertoires suivants les projets contenant les illustrations de
cette leçon :
• "\Autoformation\Corriges\Faire du multifenêtrage" le projet "Multifen.WDP" : Vous
pouvez lancer l’exécutable correspondant directement depuis WinDev grâce à
l’option "? .. Guide d’auto-formation .. Faire du multifenêtrage".
• "\Autoformation\Corriges\Faire du MDI" le projet "ExMDI.WDP" : Vous pouvez lancer
l’exécutable correspondant directement depuis WinDev grâce à l’option "? .. Guide
d’auto-formation .. Faire du MDI".
Partie 7 : Programmation

320
Présentation
La gestion du multi-fenêtrage se traduit généralement par l’utilisation du mode MDI (Multi Docu-
ment Interface).
Lors de sa création une fenêtre peut être définie comme :

• Une fenêtre libre
• Une fenêtre mère MDI
• Une fenêtre fille MDI
Les fenêtres libres ne possèdent aucune contrainte (c’est le type de fenêtre proposé par défaut).
Elles conviennent pour les projets ne gérant pas de fenêtres MDI ou pour les fenêtres de type boîte
à outils dans les projets gérant des fenêtres MDI.
Dans les projets gérant des fenêtres MDI, il est conseillé de d’utiliser une fenêtre Mère MDI en pre-
mière fenêtre du projet.
Dans une fenêtre mère MDI, seuls les champs situés dans la zone "barre d'icones" pourront être en
saisie. En effet dans une fenêtre mère MDI, il n'est pas possible de saisir en dehors de la zone
barre d'icones.
Le style de la zone "Barre d’icones" peut être modifié, comme pour un champ libellé.
Les fenêtres filles MDI doivent nécessairement être ouvertes depuis une fenêtre mère MDI.
Les fenêtres filles MDI seront toutes affichées dans la fenêtre mère MDI.
C’est un peu comme le principe des poupées russes, mais en beaucoup moins compliqué !
De plus, il existe une option "Contextes Hyper File indépendants" (onglet "Détail" de la fenêtre de
description de la fenêtre). Cette option est très utile lorsque plusieurs fenêtres utilisent le ou les
mêmes fichiers de données.
En effet, cette option permet de dupliquer les contextes Hyper File : chaque fenêtre ouverte avec
cette option dispose de son propre accès aux fichiers de données. Les opérations effectuées par
cette fenêtre ne perturberont pas les autres fenêtres qui effectuent des opérations sur les mêmes
fichiers de données. Pour plus de détails sur les contextes Hyper File, consultez l’aide en ligne (mot-
clé : "Contexte Hyper File").
Exemple
Pour plus de détails sur la gestion du multi-fenêtrage, consultez l’exemple "WD

Multi-fenêtrage", livré en standard avec WinDev.
Pour plus d'informations sur les fenêtres MDI, reportez-vous à l’aide en ligne (mot-clé : "MDI, Fenê-
tres MDI").

321
Manipulations sur une fenêtre en W-Langage

Ouverture et fermeture d'une fenêtre
Depuis une autre fenêtre, une fenêtre peut être ouverte selon deux modes :
• ouverture modale
• ouverture non modale
La fenêtre ouvrant la seconde fenêtre est appelée fenêtre mère, la fenêtre ouverte est appelée
fenêtre fille.
Ouverture modale
La fenêtre fille ouverte est en saisie. La fenêtre mère ne peut pas être en saisie.
Pour pouvoir saisir dans la fenêtre mère, la fenêtre fille doit être fermée.
La fenêtre mère ne peut pas être fermée tant que la fenêtre fille est ouverte.
En résumé, avec l'ouverture modale :
• Seule la dernière fenêtre ouverte est en saisie.
• Seule la dernière fenêtre peut être fermée.
• Si la fenêtre en cours est iconisée, tout le projet est iconisé.
L'ouverture modale ne permet pas de gérer le multi-fenêtrage.
Pour ouvrir une fenêtre modale, il faut utiliser la fonction Ouvre.

La fenêtre ouverte est en saisie.
Pour fermer la fenêtre, il faut utiliser la fonction Ferme (sans paramètre). La fonction Ferme ferme
la fenêtre en cours qui est la seule à pouvoir être en saisie.
Ouverture non modale
Une fenêtre fille ouverte peut être en saisie en même temps que la fenêtre mère. La fenêtre fille
peut être fermée, de même que la fenêtre mère (dans ce cas toutes ses filles seront fermées).
Une même fenêtre mère peut ouvrir plusieurs fenêtres filles (identiques ou différentes). Dans ce
cas les fenêtres filles sont soeurs entre elles.
En résumé, avec l'ouverture non modale :

• Plusieurs fenêtres peuvent être en saisie en même temps.
• Toutes les fenêtres peuvent être fermées indépendamment et la fenêtre mère peut ouvrir plu-
sieurs fenêtres filles.
• Si la fenêtre en cours est iconisée, les autres fenêtres ne sont pas iconisées (si la fenêtre
mère est iconisée, ses fenêtres filles deviennent invisibles).
L'ouverture non modale permet de gérer le multi-fenêtrage.
Pour ouvrir une fenêtre fille, il faut utiliser la fonction MDIOuvre (la fonction OuvreFille dans le cas
de fenêtres non MDI).
La fonction MDIOuvre ouvre la fenêtre fille, la fenêtre mère reste en saisie.
Pour ouvrir une fenêtre soeur, il faut utiliser la fonction OuvreSoeur.

La fonction OuvreSoeur ouvre la fenêtre soeur, la fenêtre appelante reste en saisie.

322
Pour forcer la saisie sur la fenêtre fille ou soeur ouverte, il faut utiliser la fonction RepriseSai-
sie(<Fenetre>).
Pour fermer une fenêtre mère, soeur ou fille, il faut utiliser la fonction Ferme en indiquant le nom
de la fenêtre à fermer.
Si la fenêtre mère est fermée, toutes ses filles sont également fermées.
Pour plus de détails sur les différents modes d'ouverture, consultez l’aide en ligne (mot-clé : "Ouvrir,
Fenêtre").
Iconiser une fenêtre

Une fenêtre peut être iconisée par son icone de réduction dans la barre de titre ou par programma-
tion.
La fonction FenTaille permet de connaître ou de modifier la taille d'une fenêtre.
Par exemple :
FenTaille(NomFenetre,TailleMini)
TailleMini est une constante prédéfinie. Vous pouvez également utiliser la fonction Minimise.
4 Pour restaurer une fenêtre à sa taille initiale :

FenTaille(NomFenetre,TailleNormale)
TailleNormale est une constante prédéfinie. Vous pouvez également utiliser la fonction Restaure.
4 FenTaille peut également être utilisée pour maximiser une fenêtre :

FenTaille(NomFenetre,TailleMaxi)
TailleMaxi est une constante prédéfinie. Vous pouvez également utiliser la fonction Maximise.
Remarque : la fonction Iconise permet également de réduire en icone la fenêtre en cours. La fonc-
tion Restaure permet de restaurer la fenêtre iconisée.
Cas des fenêtres MDI

Lorsqu'une fille MDI est réduite en icone, l'icone (partie de la barre de titre) s'affi-
che dans la fenêtre mère.
Lorsqu'une mère MDI est réduite en icone, toutes les filles sont également rédui-
Notes
tes en icone. L'icone de la fenêtre mère s'affiche dans la barre des tâches de Win-
dows.
Une fenêtre MDI (mère ou fille) peut être réduite en icone par programmation avec
la fonction FenTaille.
La fonction MDIMenuFenetre permet de :

• Restaurer toutes les filles iconisées (constante mdiRestaureTout).
• Iconiser toutes les filles ouvertes (constante mdiIconiseTout).
• Aligner les icones dans la fenêtre mère (constante mdiArrange).

323
Une fenêtre dans tous ses états !

Une fenêtre peut se voir attribuer plusieurs états. La fonction FenEtat permet de modifier ou de
connaître l'état d'une fenêtre :
• Active : la fenêtre est affichée et est en saisie (fonction FenEtat avec le paramètre Actif)
• Inactive : la fenêtre est affichée mais n'est pas en saisie (fonction FenEtat avec le paramètre
AffichageSeulement)
• Invisible : la fenêtre est affichée mais est invisible (fonction FenEtat avec le paramètre Invisible)
• Inexistant : la fenêtre n'est pas encore affichée (fonction FenEtat avec le paramètre Inexistant)
• Hors écran : la fenêtre est affichée en dehors de l'écran, à des coordonnées négatives (fonction
FenEtat avec le paramètre HorsEcran).
Actif, AffichageSeulement, Invisible, Inexistant et HorsEcran sont des constantes prédéfinies.
Positionnement d’une fenêtre par rapport à une autre

Lorsque plusieurs fenêtres sont ouvertes en même temps, chaque fenêtre s’affiche selon une alti-
tude.
La fonction FenEtat permet de modifier l’altitude d'une fenêtre :
4 Pour faire passer la fenêtre au dessus des autres fenêtres du projet, utilisez la fonction FenEtat
avec le paramètre Dessus
4 Pour faire passer la fenêtre au dessus de toutes les autres fenêtres ouvertes y compris au des-
sus des fenêtres des autres applications (on parle alors de fenêtre "Top Most"), utilisez la fonc-
tion FenEtat avec le paramètre DessusTout
Dessus, DessusTout sont des constantes prédéfinies.
Exemples
Exemple de programme gérant le multi fenêtrage de fenêtres libres (non MDI)
Pour illustrer les différents modes d'ouverture, nous allons travailler avec le projet "MULTIFEN".
4 Testez cet exemple en sélectionnant l’option de menu "? .. Guide d’auto-formation .. Faire du
Multifenêtrage".
Cet exemple est volontairement simple : il ne fait qu'ouvrir et fermer des fenêtres. Il ne gère pas
de saisie ni de fenêtre MDI. Il a pour but d'illustrer les différents modes d'ouverture des fenê-
tres libres.

324
4 La première fenêtre contient un bouton "Catalogue". Ce bouton ouvre une fenêtre en ouverture
modale.
4 Cliquez sur ce bouton.
Remarquez que vous ne pouvez pas cliquer en dehors de la fenêtre fille (le catalogue) et que la
fenêtre mère d'introduction ne peut pas être en saisie tant que la fenêtre fille est ouverte.
4 Cliquez
sur une des images de fleur, la fiche de la fleur (fenêtre fille du catalogue) s'affiche.
Remarquez que la fenêtre du catalogue (fenêtre mère) reste en saisie.

325
4 Cliquez Partie 7 : Programmation

sur la fenêtre fiche pour qu'elle passe en saisie.
Vous pouvez ouvrir en parallèle toutes les fiches en cliquant dans le catalogue sur chaque fleur.
4 Depuis une fiche de fleur vous pouvez également ouvrir une autre fiche (fenêtre sœur) en sélec-
tionnant la fleur dans la combo et en cliquant sur le bouton "Voir".
4 SiParvous cliquez sur le bouton "Fermer" d'une fiche d'une fleur, seule la fiche se ferme.
contre si vous cliquez sur le bouton "Fermer" du catalogue, toutes les fiches se ferment en
même temps que la fenêtre du catalogue.
En effet, la fermeture de la mère ferme toutes ses fenêtres filles.

326
Détail des traitements
4 Ouvrez le projet "MULTIFEN.WDP". Ce projet est présent dans le sous-répertoire "Autoforma-

tion\Corriges\Faire du multifenetrage" de WinDev 10.
4 Ouvrez la fenêtre "Multi1.WDW". Les traitements associés à chaque champ image sont les
suivants :
-- Initialisation de CLICAGE1
MoiMeme = "Fleur1.PCX"
-- Clic sur CLICAGE1
NomImage est une chaîne
NomImage = MoiMeme
SI FenEtat("CLICAGE1") = Inexistant ALORS
OuvreFille("CLICAGE1" + "=MULTI2,0,0", NomImage)
FIN
La fenêtre fiche de la fleur est affichée par la fonction OuvreFille. De cette façon, plusieurs fiches
pourront être ouvertes en parallèle.
Pour que la fenêtre d'une fleur ne soit pas ouverte plusieurs fois, la fenêtre n'est ouverte que si elle
est inexistante. La fonction FenEtat permet de vérifier si une fenêtre est déjà ouverte ou non.
La fenêtre fiche de la fleur qui a pour nom "MULTI2" peut être ouverte plusieurs fois. Il faut alors
pouvoir distinguer chaque fenêtre ouverte. Pour cela il suffit d'utiliser un alias.
Qu'est ce qu'un alias ?

Un alias permet de différencier la même fenêtre ouverte plusieurs fois.
L'alias est donné lors de l'ouverture de la fenêtre avec la fonction OuvreFille ou OuvreSoeur.
Dans la fenêtre fiche d'une fleur, le traitement du bouton permettant d'ouvrir une autre fiche est le
suivant :
//ouvre la fenêtre des fleurs sélectionnée dans la combo
//après avoir vérifié qu'elle n'est pas déjà ouverte
//récupère la fleur sélectionnée
Indice = ListeSelect(LISTE1)
NomImage = Majuscule(LISTE1[LISTE1]) + ".PCX"
//fleur sélectionnée
SI FenEtat(NomImage) = Inexistant ALORS
OuvreSoeur(NomImage+ ...
"=MULTI2,"+(50*Indice)+","+(50*Indice),NomImage)
FIN
La fenêtre fiche de la fleur est affichée par la fonction OuvreSoeur. De cette façon plusieurs fiches
pourront être ouvertes en parallèle.

327
Exemple de programme gérant des fenêtres MDI

Pour illustrer la gestion des fenêtres MDI, nous allons travailler avec le projet "EXMDI".
4 Ouvrez le projet "EXMDI.WDP" (présent dans le sous répertoire "Autoformation\Corriges\Faire
du MDI" du répertoire d’installation de WinDev 10).
La première fenêtre est une mère MDI (elle a pour nom "MDICatal").
Elle contient une zone barre d'icones.
La zone barre d'icones contient :
• 7 icones
• Un champ de saisie
• 6 zones de clicage
Chaque zone de clicage permet d'ouvrir une fenêtre fille.

Par exemple, pour la première zone de clicage, on trouvera dans le code de clic :
NomImage est une chaîne
NomImage=MoiMême
SI FenEtat("CLICAGE1")=Inexistant ALORS
MDIOuvre(mdifleur,"CLICAGE1","fleur1",NomImage)
FIN

328
Les filles sont des filles MDI, elles s'affichent dans la mère.
Les icones permettent (de gauche à droite) :

• D’ouvrir toutes les filles (les filles sont alors empilées)
• De fermer toutes les filles ouvertes :

MDIMenuFenetre(mdiFermeTout)
• D’afficher les filles ouvertes en mosaïque :

MDIMenuFenetre(mdiMosaique)
• D’afficher les filles ouvertes en cascade :

MDIMenuFenetre(mdiCascade)
• De réduire en icone toutes les filles ouvertes :

MDIMenuFenetre(mdiIconiseTout)
• De restaurer toutes les filles iconisées :

MDIMenuFenetre(mdiRestaureTout)
• D’aligner les icones dans la fenêtre mère :

MDIMenuFenetre(mdiArrange)

329
Affichage en mosaïque :
Affichage en cascade :

330
Le champ "en cours" indique quelle est la fille active. La fille active est la fille qui se trouve en pre-
mier plan, celle dont l’altitude est la plus élevée par rapport aux autres fenêtres.
La fonction MDIActive retourne le nom de la fenêtre fille en avant plan.
Dans notre exemple, une procédure appelée par "timer" affiche le nom de la fenêtre fille active.
L'utilisation des timers est expliquée dans la leçon “Les timers”, page 346.
La fonction MDIMère permet de connaître le nom de la mère MDI.
Accès aux champs, aux procédures et aux traitements

Depuis la fenêtre en cours, il est bien entendu possible d'accéder aux champs d'une autre fenêtre,
par exemple pour récupérer leur valeur ou pour les modifier.

NomFenetre.NomChamp
Par exemple :
MULTI1.MARQUER..Visible = Faux
Selon le même principe, il est possible de faire exécuter un traitement ou une procédure d'une autre
fenêtre. La fonction ExecuteTraitement permet, d'une part, d'exécuter les traitements des champs
d'une autre fenêtre ouverte (en ouverture non modale), et d'autre part, d'exécuter une procédure
décrite dans une autre fenêtre.
Par exemple, dans le projet "MULTIFENETRAGE" de ce chapitre, le code de prise de focus de la fenê-
tre "MULTI2" exécute le code de la procédure "Marque_Fleur" de la fenêtre "MULTI1" (cette procé-
dure permet de marquer la fleur du catalogue qui correspond à la fenêtre fille qui a le focus) :
ExecuteTraitement("MULTI1.Marque_Fleur", trtProcedure, NomFleur)

331
LEÇON 7.2. GESTION DE FICHIERS TEXTE

• Manipulations possibles sur les fichiers externes (texte ou ASCII).
Vous trouverez dans le répertoire "\Autoformation\Corriges\Programmation" le projet

"Programmation.WDP" illustrant cette leçon.
l’option "? .. Guide d’auto-formation .. Programmation".

332
Présentation
Cette leçon traite de la manipulation des fichiers "externes".
Les fichiers externes sont souvent appelés fichiers texte (ou ASCII) ou encore fichiers à accès
direct. Notons que ce type de fichier contient généralement du texte, mais 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 exter-
nes.
Manipulations sur les fichiers externes

WinDev permet de manipuler en programmation les fichiers externes. Les fonctions du W-Langage
gérant les fichiers externes ont une syntaxe proche de celle du langage C. Elles permettent de
créer, lire ... des fichiers externes. Toutes les fonctions peuvent être très facilement identifiées :
elles commencent toutes par la lettre "f".
Dans un fichier externe, il n'y a pas nécessairement de notion "d'enregistrement". Pour pouvoir
manipuler un fichier externe, il faut en connaître la structure, c’est-à-dire connaître l’agencement
des données qui se trouvent à l’intérieur du fichier.
A propos des caractères accentués

Si le fichier a été créé sous MS-DOS, les caractères accentués sont au standard OEM. Si le fichier a
été créé sous Windows, les caractères accentués sont au standard ANSI.
Dans les deux standards, les caractères accentués n'ont pas le même "code" et n’ont pas la même
apparence.
Ainsi sous Windows, pour les fichiers externes créés sous MS-DOS, les caractères accentués s'affi-
cheront sous la forme de "".

Les fonctions OemVersAnsi et AnsiVersOem permettent de convertir les caractères d'un stan-
dard vers l'autre.
Exemples de manipulations
4 Ouvrez le projet "Programmation.WDP". Ce projet est présent dans le sous-répertoire "Autofor-
mation\Corriges\Programmation" de WinDev.
4 Ouvrez la fenêtre "FichierTexte.WDW" et testez-la. Cette fenêtre regroupe de nombreuses mani-
pulations possibles avec WinDev.
De plus, étudiez l’exemple "WD Fichiers Texte" livré en standard avec WinDev 10 : vous aurez ainsi
un aperçu des différentes manipulations possibles sur les fichiers externes :
• créer un fichier externe
• lire (par bloc, par ligne ou en une seule fois) un fichier externe
• écrire dans un fichier externe
• obtenir des informations sur un fichier
• bloquer un fichier
• tester l’existence d’un fichier
• sélectionner un fichier

333
• copier un fichier
• supprimer un fichier
• lister les fichiers d’un répertoire
Cet exemple présente également les manipulations possibles sur les disques et les répertoires :
• créer un répertoire
• connaître le répertoire en cours
• tester l’existence d’un répertoire
• lister des répertoires
• copier un répertoire
• supprimer un répertoire
Exemple
L’exemple "WD Fichiers Texte" livré en standard avec WinDev 10 (exemple didacti-
que), illustre les manipulations possibles sur les fichiers, disques et répertoires
avec le W-Langage.
Pour plus de détails sur les fonctions de gestion des fichiers externes, consultez l’aide en ligne
(mot-clé : "Fichier externe").

334
LEÇON 7.3. IMPRIMER EN W-LANGAGE

• Possibilités d’impression en W-Langage.


335
Présentation
Nous avons vu précédemment comment imprimer avec l'éditeur d'états : cette méthode doit être
privilégiée. Toutefois, le W-Langage permet également d'imprimer du texte et des images directe-
ment par programmation. Vous pouvez dès lors réaliser toutes les éditions que vous souhaitez, de
la plus simple à la plus complexe. Vous pourrez suivre vos impressions particulières au doigt et à
l’oeil !

mation\Corriges\Programmation" de WinDev 10.
4 Ouvrez la fenêtre "Imprim1.WDW" et testez-la. Cette fenêtre regroupe de nombreuses manipula-

tions possibles avec WinDev.
Possibilités d’impression en W-Langage

Consultez l’exemple "WD Impression par programmation" livré avec WinDev 10 (exemple unitaire).
Vous pourrez obtenir un aperçu des possibilités d’impression grâce aux fonctions du W-Langage :
• imprimer du texte
• mettre en forme le texte (polices, couleurs, ...)
• encadrer du texte
• dessiner des formes ...
• imprimer des images
• modifier la taille des images
• déformer les images
• mettre en forme les images (cadrage, taille, ...)
• configurer l’imprimante
• paramétrer la sortie d’une impression
• aperçu à l’écran
• impression directe
• impression dans un fichier
Exemple
L’exemple "WD Impression par programmation" livré en standard avec WinDev 10,
illustre les possibilités d’impression en W-Langage. Cet exemple est un exemple
unitaire.
Pour plus de détails sur les fonctions d’impression en W-Langage, consultez l’aide en ligne (mot-
clé : "Impression, Fonctions W-Langage").

336
LEÇON 7.4. DESSINER EN W-LANGAGE

• Utilisation des fonctions de dessin du W-Langage.


337
Dessiner dans une fenêtre

WinDev permet de dessiner dans une fenêtre. Pour cela, il faut :
1. Créer une champ image.
2. Dessiner avec les fonctions de dessin du W-Langage. Ces fonctions commencent toutes par
"d". Avant de commencer à dessiner dans le champ, il faut appeler la fonction dDebutDessin.
Exemple de tracé de courbe de fonction :

Procedure AfficheCourbe()
X, Y sont des Réels
Xold, Yold sont des Réels
Rayon, Angle sont des Réels
X0, Y0 sont des Réels
X0 = 200
Y0 = 200
// Dessin du fond et des axes de coordonnées
dDebutDessin("IMAGE")
dFond(Fond)
dStylo(Fond)
dRectangle(0,0,500,500)
dStylo(iNoir)
dLigne(0,200,400,200)
dLigne(200,0,200,400)
dStylo(Trait)
ErrCompile est une chaîne
// On compile la fonction de calcul de la valeur de Y
ErrCompile = Compile("ValeurY",...
"Fonction ValeurY(Fonct,X)"+RC+RC+...
"Y est un entier"+rc+Fonct+RC+...
"Renvoyer PartieEntiere(Y)")
SI ErrCompile= "" ALORS
Xold = -201
Yold = ExecuteTraiement("ValeurY", trtProcédure, Fonct,-201)
POUR X=-200 A 200
Y = ValeurY(Fonct,X)
dLigne((EchelleX*Xold)+X0,...
-(EchelleY*Yold)+Y0,(EchelleX*X)+X0,-(EchelleY*Y)+Y0)
Xold = X
Yold = Y
FIN
SINON
Erreur("La fonction n'a pu être compilée")
FIN
Notez que le tracé de courbe de fonction utilise la compilation dynamique.

338
Exemples

4 Ouvrez la fenêtre "Dessine.WDW" et testez-la. Cette fenêtre présente le tracé de courbes de

fonction. Exemple de tracé de courbe de fonction :

339
LEÇON 7.5. LES LISTES GRAPHIQUES

• Quand utiliser les listes graphiques.

• Programmation des listes graphiques.


340
Quand utiliser des listes graphiques

WinDev propose plusieurs façons de réaliser des listes graphiques :
• le champ Liste image. Cette solution permet d’afficher dans une liste déroulée une image et
un texte. Dans ce cas, l’image est toujours située au-dessus de son libellé.
Ce type de champ a été étudié dans la partie “Les champs”, page 107.
• le champ Liste ou Combo avec des images. Dans ce cas, l’image est placée sur la même
ligne que son libellé.
C’est ce dernier type de liste graphique que nous allons étudier dans cette partie.
Les listes graphiques permettent d'afficher des images dans chaque ligne d’une liste. Elles permet-
tent d’égayer un peu leur contenu, de repérer facilement certaines données, ... On peut utiliser
indifféremment les listes déroulées et les listes déroulantes (combos).
Les listes graphiques peuvent également être utilisées dans les tables. Elles sont alors remplacées
par des combos (ou listes déroulantes) graphiques.
Programmer les listes graphiques

Une liste graphique se manipule comme une liste non graphique. Les seules différences notables
entre une liste graphique et une liste standard sont :
• Il est possible de dessiner dans une liste graphique.
• Il est possible d'afficher des images dans une liste graphique.
Par défaut, toutes les listes sont "graphiques".

4 Ouvrez la fenêtre "LISTEGRA.WDW".

Cette fenêtre illustre la programmation des listes graphiques et l’utilisation des combos dans
les tables.

341
Dessiner dans une liste graphique

4 Pour dessiner dans une liste graphique, il faut utiliser les fonctions spécifiques du W-Langage.
Ces fonctions sont les suivantes :
gCadrage Cadrer du texte ou une image dans une liste.

gCercle Dessine un cercle dans une liste.
gCoord Positionne du texte dans une liste.
gFond Définit la couleur de fond dans une liste.

gLigne Dessine une ligne dans une liste.

342
gRectangle Dessine un rectangle dans une liste.
gStylo Modifie les valeurs par défaut du stylo (trait).
Le traitement pour initialiser la liste des couleurs est le suivant (extrait du code d’initialisation de la
liste des couleurs) :
POUR Ind=1 à 16
ListeAjoute(COULEUR,gRectangle(3,3,30,16,iNoir,iNoir)+...
gRectangle(2,2,29,15,VCoul[Ind],iNoir)+" "+TCoul[Ind])
FIN
De la même manière que pour ajouter des données "texte", on utilise la fonction ListeAjoute. Si l’on
souhaite par exemple insérer un rectangle au milieu d’un texte, il suffit d’insérer la fonction gRec-
tangle dans le texte à ajouter dans la liste :
ListeAjoute(MALISTE,gRectangle(3,3,30,16,iNoir,iNoir) + ...
" Rectangle noir.")
Afficher une image

4 Pour afficher une image dans une liste graphique, il faut utiliser la fonction gImage :
// Init de la combo graphique pour l'affichage de la marque
ListeAjoute(Marque,gImage("MARQUE.ICO"))
Si plusieurs images sont utilisées, il faut :

1. Décrire chaque image à afficher avec la fonction ChargeImage.
2. Utiliser la fonction gImage en donnant en paramètre le nom de l'image de ChargeImage :
//dans gImage si le second paramètre vaut ’1’ la marque est

// présente si le second paramètre vaut ’0’ la marque est absente
ChargeImage(7,"MARQUE.ICO",2,1) // image en deux parties
ListeAjoute(MULTI, gImage(7,1)+"Lundi"+gLien("7,1"+TAB+"Lundi"))
ListeAjoute(MULTI, gImage(7,1)+"Mardi"+gLien("7,1"+TAB+"Mardi"))
ListeAjoute(MULTI, gImage(7,2)+"Mercredi"+...
gLien("7,2"+TAB+"Mercredi"))
ListeAjoute(MULTI, gImage(7,1)+"Jeudi"+gLien("7,1"+TAB+"Jeudi"))
ListeAjoute(MULTI, gImage(7,1)+"Vendredi"+...
gLien("7,1"+TAB+"Vendredi"))
ListeAjoute(MULTI, gImage(7,2)+"Samedi"+...
gLien("7,2"+TAB+"Samedi"))
ListeAjoute(MULTI, gImage(7,2)+"Dimanche"+...
gLien("7,2"+TAB+"Dimanche"))

343
Récupérer du texte dans une liste graphique

Pour pouvoir récupérer du texte, il faut lors du remplissage de la liste indiquer avec la fonction
gLien le texte qui pourra être récupéré :
ListeAjoute(MULTI, gImage(7,1)+ gLien("Lundi") + "Lundi")
//...
// On admet que l’utilisateur a sélectionné l’élément "Lundi"
Jour = MULTI[MULTI]
// Jour = "Lundi"
Il existe également une autre possibilité, qui fait intervenir la manipulation des chaînes de caractè-
res.
En effet, la propriété ValeurAffichée sur les listes graphiques, renvoie sous forme de texte tout le
contenu de la ligne sélectionnée. Si des images ont été insérées avec la fonction gImage, elles sont
séparés du texte par le caractère ESC.
Le code suivant permet de récupérer le texte de la ligne sélectionnée dans une liste graphique :
ListeAjoute(MULTI, gImage(7,1) + "Lundi")
//...
// On admet que l’utilisateur a sélectionné l’élément "Lundi"

Jour = MULTI..ValeurAffichée
Trace(Jour) // Affiche "7,1<ESC>Lundi"
Jour = ExtraitChaîne(MULTI..ValeurAffichée,1,ESC,DepuisFin)
Trace(Jour) // Affiche "Lundi"
Nous vous conseillons toutefois d’utiliser la première solution indiquée. La seconde peut être utili-
sée dans le cadre de développements très spécifiques et n’a que très peu d’intérêt.

344
LEÇON 7.6. LES INDIRECTIONS

• Définition.
• Exemple d’utilisation.


345
Présentation
Le mécanisme "d’indirection" permet de construire le nom d’un champ, d’une rubrique de fichier ou
le nom d’une variable à partir d’une expression de type chaîne.
Ceci permet par exemple de créer des traitements génériques indépendants des noms des
champs, des variables, des rubriques de fichier ...
L’indirection est réalisée à l’aide des opérateurs { }.
Pour optimiser la vitesse de vos applications, il est conseillé de préciser lors de l’utilisation de la
syntaxe d’indirection le type de l’élément manipulé.
Ainsi, si vous manipulez un champ, le type correspondant sera IndChamp (voir exemple ci-dessous).
Exemple
Exemple d’indirections simples :
{"NOM",indChamp} = NomCli
//est équivalent à NOM=NomCli
{"NOM",indChamp} = {"CL.NOMCLI"}
//est équivalent à NOM=CL.NOMCLI
{"FENCLI.NOM",indChamp} = NomCli
//est équivalent à FENCLI.NOM=NomCli
{"FENCLI"+".NOM",indChamp} = NomCli
//est équivalent à FENCLI.NOM=NomCli
Exemple d’indirection avec une procédure :
NomChamp est une chaîne
NomChamp = "SAISIE1" //SAISIE1 est le nom du champ
//appel d'une procédure rendant un champ invisible
INVISIBLE(NomChamp)
PROCEDURE INVISIBLE(NChamp)
{NChamp,indChamp}..Visible = Faux
Exemple
Pour plus de détails sur l’utilisation des indirections, consultez l’exemple "WD Indi-
rections", livré en standard avec WinDev.

346
LEÇON 7.7. LES TIMERS

• Intérêt des timers.

• Programmation des timers.

"Programmation.WDP" illustrant cet exemple.

347
Introduction
Un timer permet d’exécuter en parallèle une tâche qui doit être lancée périodiquement (acquisition
de données en tâches de fond, rafraîchissement automatique de données, déclencher un pro-
gramme à une heure donnée ...). Seules les procédures (globales ou locales à une fenêtre) et les
méthodes globales de classe peuvent être appelées par un timer.
Avec WinDev 10, les timers peuvent être gérés directement depuis l’interface de l’éditeur de code.

4 Ouvrez la fenêtre "TIMER1.WDW".
Cette fenêtre gère un timer pour afficher l'heure dans une fenêtre. Testez cette fenêtre.
4 Affichez la procédure "MiseAHeure" (double-cliquez sur le nom de la procédure dans le volet
"Code"). Cette procédure est une procédure locale à la fenêtre Timer_1.
Cette procédure met à jour le champ "HEURE" avec la nouvelle heure et va émettre des bips à
chaque changement d'heure :.
La flèche verte située dans l’en-tête de la procédure signale que cette procédure est une procédure
automatique. Pour définir les propriétés d’une procédure, il suffit de cliquer sur l’icone .

348
4 Double-cliquez sur la flèche verte pour visualiser les propriétés de la procédure :

Arrêter une procédure automatique

Notes
Pour arrêter une procédure automatique, utilisez la fonction FinAutomatismePro-

cédure.
Remarque : pour compatibilité avec les versions précédentes, il est également possible de gérer les
timers grâce à plusieurs fonctions W-Langage :
• La fonction Timer permet d'utiliser un timer géré par WinDev. Ce timer pourra être arrêté grâce à
la fonction FinTimer.
• La fonction TimerSys permet d'utiliser un timer géré par Windows. Ce timer pourra être arrêté
grâce à la fonction FinTimerSys.
Un timer réalisé avec la fonction Timer sera toujours prioritaire par rapport à un timer réalisé avec
la fonction TimerSys.

349
LEÇON 7.8. LES EVÉNEMENTS WINDOWS

• Programmation des événements Windows.


350
Introduction
Toute action effectuée par Windows correspond à un événement Windows. Différents types d’événe-
ments 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.
WinDev propose par défaut 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
De nombreux autres événements peuvent être gérés facilement. Une barre d’outils est disponible
dans l’éditeur de code :
Il suffit d’ajouter l’événement souhaité. Exemple : "Touche Enfoncée" .
Pour la gestion d’événements plus "spécifiques", il existe la fonction W-Langage Evénement. La

fonction Evénement permet de déclencher une procédure en réaction à un événement Windows.

Vous pouvez ainsi associer à tout type d'événement Windows une procédure en W-Langage.
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 Win-
Dev (mot-clé : "Valeur des constantes de l'API Windows").

351
Exemples
Interdire la sortie de Windows
Pour illustrer l'utilisation de la fonction Evénement, nous allons par exemple intercepter l’arrêt de
Windows. Cet événement se nomme "WM_QueryEndSession".
Cet exemple peut être très utile par exemple pour rappeler à l’utilisateur qu’il doit enregistrer ces
modifications avant de quitter Windows.
Notre exemple interdit la sortie de Windows tant que le projet est en cours d’exécution.
Lorsque l'événement "WM_QueryEndSession" est intercepté, la procédure "EndSession" est exécu-
tée.
//dans le code d'initialisation du projet
Evenement("EndSession","*.",17)// 17=WM_QueryEndSession
La procédure doit renvoyer "Vrai" pour autoriser la sortie de Windows ou "Faux" pour la refuser.
Pour matérialiser le refus de sortie de Windows, il faut forcer le focus sur une fenêtre du projet.
Pour forcer le focus, il faut envoyer l'événement "WM_ACTIVATE" à la fenêtre en cours du projet. La
fonction PostMessage permet d'envoyer des messages dans la file des messages de Windows.
4 Voici le code de la procédure "EndSession" :

PROCEDURE EndSession(Message, wParam, lParam)
SELON Message
CAS 17// QueryEndSession: Confirmation de sortie de Windows
//on interdit la sortie
Info("Vous devez quitter le programme "+...
"avant de sortir de Windows.")
//forcer le focus sur le projet (WM_ACTIVATE)
hWnd est un entier
hWnd = Handle(FenEnCours())
PostMessage(hWnd,6,1,hWnd)//WM_ACTIVATE=6
RENVOYER Faux
FIN
Détecter le clic sur une liste

4 Ouvrez la fenêtre "Evenem" et testez-la. Cette fenêtre détecte si la liste est manipulée avec la
souris ou avec le clavier.

352
LEÇON 7.9. LES COMPOSANTS

• Qu’est-ce qu’un composant ?

• Etape par étape, la création d’un composant.
• Diffusion d’un composant.
Vous trouverez dans le répertoire :

• "\Autoformation\Corriges\Composant\Calendrier" le projet "Calendrier.WDP"
• "\Autoformation\Corriges\Composant\Planning" le projet "Planning.WDP"
Ces projets correspondent aux corrections des exercices de cette leçon.

353
Présentation
Un composant WinDev est une bri-
que applicative qui peut être réutili-
sée dans un nombre illimité de
projets (et donc d'exécutables).
Un composant permet d'avoir un
traitement identique avec un code
source unique pour réaliser une
opération donnée même si ce traite-
ment doit être réalisé par plusieurs
projets.
Les projets qui utilisent un compo-

sant ont accès sous l'éditeur Win-
Dev 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 est très simple.
Comment faut-il faire ? Faites comme d'habitude, créez vos fenêtres, procédures, classes. Puis lors-
que 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 quatre 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
Voici plusieurs cas dans lesquels les composants peuvent être intéressants.
Travail en équipe
Un développeur crée et maintient un composant 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 permettent d'avoir plusieurs projets distincts de tailles réduites, et d'avoir un pro-
jet central dans lequel les éléments des autres projets sont visibles. L’utilisabilité des composants
est bien meilleure que les bibliothèques (fichiers WDL).

354
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
regroupant les opérations d'accès (en écriture au moins) à la base de données dans un composant,
cela permet d'avoir un seul code source à vérifier/maintenir, et cela permet donc de limiter le ris-
que d'incohérences dans la base de données.
Les traitements utilisés dans plusieurs projets

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

Les composants permettent de réaliser une fonctionnalité ou un ensemble de fonctionnalités.
D'autres développeurs WinDev pourront intégrer ces fonctionnalités dans leurs propres projets. Les
développeurs qui utilisent un composant peuvent voir les éléments du composant 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 !
Composant multiproduits
Un composant 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 .
• d’indiquer pour chaque plateforme d’exécution le code W-Langage correspondant (par exem-
ple, 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).

355
Etape par étape

Etape 1 : Création d’un composant
Nous allons créer un composant proposant un calendrier. Lors de l’appel au composant, vous
pourrez :
• Passer une date en paramètre pour se positionner dans le calendrier, à l’ouverture.
• Récupérer la date sélectionnée dans le calendrier à la fermeture.
4 Créez un nouveau projet nommé "CALENDRIER".

Ce projet n’a pas d’analyse.
Le composant est constitué d’une fenêtre contenant un calendrier.

4 Dans l’éditeur de WinDev, affichez le volet "Assistants, Exemples et Composants" si ce n’est
pas déjà fait (option "Affichage .. Barre d’outils .. Assistants, Exemples et Composants").
4 Affichez les exemples dans l’onglet "Assistants, Exemples et Composants" (bouton "Exemples").
Sélectionnez les exemples unitaires.
4 Réalisez un "Drag and Drop" de l’exemple "Calendrier popup" vers l’éditeur de WinDev. La fenê-
tre apparaît sous l’éditeur de fenêtres.
4 Sauvegardez la fenêtre.
4 Pour créer un composant, dans le menu de WinDev, sélectionnez l’option "Atelier ..

Composant .. Définir un nouveau composant à partir de ce projet".

356
4 L’assistant de création du composant démarre. Cliquez sur "Suivant".

4 1.
Identifiez votre composant :
Saisissez le nom "Calendrier".
2. Saisissez comme libellé : "Composant calendrier".

Sélectionnez les éléments qui constituent le composant. Cochez uniquement la fenêtre "Pop-
Calendrier".

357

L’assistant vous demande de sélectionner les éléments du composant qui seront accessibles
depuis l’application cliente. Dans notre exemple, seule la fenêtre "PopCalendrier" sera utilisée :
4 Cliquez sur "Suivant". WinDev propose de générer le composant.

4 Dans l’assistant qui apparaît, choisissez les langues du composant. 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 et cliquez sur "Suivant".
4 •Dans cette fenêtre, saisissez les différentes informations concernant le composant :
Propriétaire,
• Libellé, Copyright, ...

358
4 Cliquez une nouvelle fois sur "Suivant".

4 Vous pouvez associez une image à votre composant. Les utilisateurs du composant pourront
l’identifier rapidement dans le volet "Catalogue d’exemples".
4 Spécifiez la présentation générale du composant.

4 Cliquez sur "Suivant". L’assistant va maintenant effectuer la génération automatique de la
documentation sur le composant. Cette documentation peut être basée sur les commentaires
que vous aurez insérés dans votre code source.

359
4 Cliquez à nouveau sur "Suivant". Vous avez la possibilité de modifier l’aide générée.
Nous n’allons pas y toucher. Cliquez sur "Suivant".
4 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. Décochez si nécessaire l’option. Cliquez sur "Sui-
vant".
4 Vous avez la possibilité d’autoriser les utilisateurs finaux du composant à saisir leur propre
code W-Langage pour personnaliser vos traitements. Les suggestions peuvent directement
vous être envoyées. Dans cet exemple, nous n’allons pas autoriser la saisie de "Macro Code Uti-
lisateur". Cliquez sur "Suivant".

360
4 Nous n’allons pas enregistrer le composant dans le centre de ré-utilisabilité. Il ne reste plus
alors qu’à donner un nom physique à notre composant.
4 Cliquez sur "Terminer". Voilà, votre premier composant est maintenant créé, il est prêt à
l’emploi !
Le composant apparaît alors dans le volet "Assistants, Exemples et Composants" (bouton
"Composants", rubrique "Composants personnels").

361
Etape 2 : Utilisation du composant

Une fois créé, votre composant est alors utilisable dans n’importe quel autre projet WinDev. Nous
allons maintenant voir comment réutiliser ce composant.
4 Créez un nouveau projet. Ce projet s’appelle "Planning" et n’a pas d’analyse.

4 Dans l’éditeur de projet, sélectionnez l’option "Atelier .. Composant .. Importer un composant
dans le projet .. A partir d’un fichier".
Remarque : Si vous avez enregistré le composant dans le centre de ré-utilisabilité, vous pouvez
l’importer directement depuis le centre de ré-utilisabilité.
4 Dans le répertoire du projet CALENDRIER, sélectionnez le sous-répertoire EXE, puis le fichier
"CALENDRIER.WDI".
4 Après avoir cliqué sur "Ouvrir", la description de notre composant s’est affichée :
4 Validez par "OK".

Vous allez maintenant créer une nouvelle fenêtre vierge dans laquelle vous allez ajouter :
• un champ de saisie de type "Date"
• un bouton.
4 Cliquez sur "Fichier .. Nouveau .. Fenêtre". Sélectionnez une fenêtre vierge.
4 Nommez votre fenêtre "FenPlanning" et donnez-lui le titre "Planning".
4 Créez un champ de saisie que vous nommerez "SAI_LADATE". Dans la fenêtre de description de
ce champ, indiquez qu’il s’agit d’un champ "Date".
4 Créez
date".
ensuite un bouton que vous nommerez "BTN_SELDATE" avec comme libellé "Choisir la

362
4 Editez maintenant le code de clic du bouton "BTN_SELDATE" et saisissez le code suivant :

SAI_LADATE = Ouvre(CALENDRIER_POPUP)
4 Sauvegardez votre fenêtre, puis testez en cliquant sur le bouton .

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

363
Distribuer un composant
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
fichier 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 Hyper File, ....).
• la mise à jour automatique des fichiers de données utilisés par le composant (si nécessaire).
• la désinstallation du composant.
4 Revenez sur le projet "Calendrier". Pour créer l’installation, sélectionnez l’option "Atelier ..
Composant .. Créer la procédure d’installation d’un composant".
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 WinDev, Distribuer un composant").
Quelques composants livrés en standard avec WinDev 10 :
• Affiche image • Moteur de recherche
• Agent • Paiement sécurisé
• Ballon Tip • Sélecteur
• CodePostaux France • Sélecteur Couleurs
• Envoi Fax • SOAPGMT
• Gestion Login • Zone mémoire visuelle
• JourFérié • ComposantHFInternet

364
LEÇON 7.10. PROGRAMMATION OBJET

• Concepts de la programmation orientée objet.

• Exemples de déclaration d’objet.


365
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éu-
tilisés dans d’autres logiciels. Ils vont regrouper un ensemble de procédures et encapsuler la struc-
ture de données sur laquelle les procédures 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 classi-
ques du W-Langage.
Notion d’héritage
L’héritage permet d’inclure les caractéristiques d’une classe existante (classe de base) dans une
nouvelle classe (classe dérivée). L’héritage permet de créer un nouveau type de données à partir
d’un type connu, dans le but de lui ajouter des fonctionnalités, ou d’en modifier le comportement.
La classe de base ne sera donc pas modifiée. Une classe peut hériter d’une classe dont elle
devient une sous-classe.
Une classe dérivée hérite des membres et des méthodes de sa classe mère (qui peut, elle-même,
être une sous-classe d’une autre classe mère), en plus de ses propres membres et méthodes (et
également des membres et méthodes de la première classe mère, s’il s’agit d’un héritage multi-
ple). Il n’est pas nécessaire de dupliquer les membres et méthodes de la ou des classe(s) mère(s).

366
Constructeur et Destructeur
La notion de Constructeur et Destructeur est importante puisqu’elle permet un appel automatique
de méthodes d’intialisation 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 à certain 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.
Créer un programme orienté objet

Pour créer un programme en objet en W-Langage, 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")

4 Ouvrez la fenêtre "POO1.WDW".
Nous ne détaillons pas ici la syntaxe de la P.O.O., nous présenterons uniquement un exemple sim-
ple de programme orienté objet. Pour avoir plus de détail sur la syntaxe de la P.O.O., consultez
l’aide en ligne et le manuel de programmation de WinDev (mot-clé : "POO, Classe").
Déclarer une classe

Pour créer une classe :
1. Affichez le volet code ( ).
2. Choisissez "Classe". Dans le cadre qui apparaît, faites un clic doit puis sélectionnez l’option
"Nouvelle classe".

367
3. Saisissez un nom et validez par [Entrée].
Une classe est de la forme :

Fichier est une classe
NomLong est une chaîne
NomCourt est une chaîne
Extension est une chaîne
CheminCourt est une chaîne
CheminLong est une chaîne
FIN
"Fichier" est le nom de la classe.

"NomLong", "NomCourt", "Extension"... sont des membres de la classe.
Décrire les méthodes

Pour créer une méthode :
1. Cliquez avec le bouton droit de la souris dans le volet "Code", sur votre classe
2. Choisissez "Nouvelle méthode", en bas du menu qui apparaît.
3. Saisissez un nom et validez par [Entrée].

368
Une méthode est de la forme :

//Méthode Fichier::SelectionFichier
//Cette méthode renvoie un résultat
PROCEDURE Fichier::SelectionFichier()
Res est une chaîne
Res = fSelecteur(fRepEnCours(), "*.BMP", ...
"Sélection des images BMP", "Images" + TAB + ...
"*.BMP", "BMP")
:NomLong = fNomLong(Res)
:NomCourt = fNomCourt(Res)
:Extension = ExtraitChaine(fNomLong(Res),2,".")
//Chemin long
Pos est un entier
Pos = Position(Majuscule(Res),Majuscule(:NomLong))
:CheminLong = Res[[1 à Pos-2]]
//Chemin Court
Ch1 est une chaîne = ""
Ch2 est une chaîne = ""
//Extraire le lecteur
Pos = Position(Res,"\")
Ch1 = Res[[1 à Pos-1]]
Ch2 = Ch1 + "\"
//Extraire chaque sous répertoire
BOUCLE
Pos = Position(Res,"\",Pos+1)
Ch1 = Res[[1 à Pos-1]]
SI Pos = 0 ALORS SORTIR
Ch2 = Ch2 + fNomCourt(Ch1) + "\"
FIN
:Chemincourt=Ch2[[1 à Taille(Ch2)-1]]
RENVOYER Res
Le nom de la méthode est "SelectionFichier".

"Fichier::SelectionFichier" signifie que la méthode "SelectionFichier" appartient à la classe "Fichier".
Pour faire référence à un membre de l’objet "Fichier", il faut utiliser la syntaxe

//Depuis la classe Fichier
:<Nom du membre>
//Depuis le programme appelant
<NomObjet>:<nom du membre>

369
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 :
GLOBAL
Fic1 est un objet Fichier
L'objet est manipulé de la façon suivante :

//appel de la méthode
Ch = Fic1:SelectionFichier()
SI Ch ="" ALORS RETOUR
Infofic..Etat = Grisé
NOML = Fic1:NomLong
NOMC = Fic1:NomCourt
EXTENS = Fic1:Extension
CHEMINL = Fic1:CheminLong
CHEMINC = Fic1:CheminCourt
TailleF = Fic1:TailleFichier()
DateF = Fic1:DateFichier()
HeureF = Fic1:HeureFichier()
4 Ouvrez la fenêtre "POO2.WDW" et testez cette fenêtre.

Cette fenêtre présente un exemple de programme objet manipulant les héritages et les métho-
des Constructeur.
Nous ne nous attarderons pas plus sur la présentation de la POO dans ce cours.

370
LEÇON 7.11. UML

• Qu’est-ce que le UML ?

• Les différents types de diagrammes gérés par WinDev.


371
Qu’est-ce que UML ?

UML (Unified Modeling Language) est une norme de modélisation permettant de "modéliser" des
traitements.
Les diagrammes gérés par WinDev

Diagramme de classes
Le diagramme de classes permet de modéliser la structure d’un système et des relations entre les
différents éléments composant ce système. Il est principalement utilisé en POO.
Avec WinDev, grâce au dessin d’un diagramme de classe UML, vous pourrez automatiquement
générer les classes et les méthodes qui en découlent.
Utilisable en rétro-analyse ("reverse engineering"), vous pourrez alors avoir un aperçu visuel des
relations entres les différentes classes que vous aurez créées.
Diagramme de cas d’utilisation

Utilisable une fois le cahier des charges établi (en phase de pré-projet), le diagramme de cas d’utili-
sation permet d’établir de façon claire et visuelle le comportement de votre projet (correspondance
entre les implémentations des demandes des utilisateurs par les développeurs, ...). On nomme par-
fois ce type de diagramme, "un diagramme de séquence" (sans chronologie particulière).
Il n’est pas possible de générer une application à partir de ce type de diagramme. Ce type de dia-
gramme sert uniquement lors de la mise en place de la gestion de projet.
Diagramme d’objets
Un diagramme d’objets représente un ensemble d’objets et leurs relations à un moment donné.
Un diagramme d’objets est utilisé pour montrer un contexte (avant ou après une interaction entre
objets par exemple).
Diagramme de composants
Un diagramme de composants décrit l'architecture physique et statique d'une application informati-
que. Par exemple : fichiers sources, librairies, exécutables, ...
Diagramme d’activité
Un diagramme d’activité représente le comportement d’une méthode ou le déroulement d’un cas
d’utilisation.
Diagramme de séquence
Un diagramme de séquence représente l’ordre chronologique des messages envoyés et reçus par
un ensemble d’objets.

372
Diagramme de collaboration
Un diagramme de collaboration présente l’organisation structurelle des objets qui envoient et reçoi-
vent des messages.
Diagramme d’états-transitions
Un diagramme d’états-transitions présente un automate à états finis. Il permet ainsi de décrire les
changements d'états d'un objet ou d'un composant.
Un état se caractérise par sa durée et sa stabilité.
Une transition représente le passage instantané d'un état vers un autre.
Une transition est déclenchée :
• soit par un événement.
• soit automatiquement lorsque aucun événement déclencheur est spécifié.
Diagramme de déploiement
Un diagramme de déploiement montre la répartition physique des matériels (les noeuds) utilisés
dans un système et l’association des programmes exécutables à ces matériels.
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").

373
LEÇON 7.12. WINDEV ET XML

• Qu’est-ce que le XML ?

• Un exemple simple d’utilisation des fonctions XML de WinDev.
Vous trouverez dans le répertoire "\Autoformation\Corriges\XML" le projet

"XML.WDP" contenant les illustrations de cette leçon.
l’option "? .. Guide d’auto-formation .. XML".

374
Qu’est-ce que le langage XML ?

XML (Extensible Markup Language, ou Langage Extensible de Balisage) est le langage destiné à
succéder à HTML sur le World Wide Web. Comme HTML (Hypertext Markup Language), le XML est
un langage de balisage, c'est-à-dire un langage qui présente de l'information encadrée par des bali-
ses. Mais contrairement à HTML, qui présente un jeu limité de 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 Hyper File
contenant plusieurs rubriques et enregistrements peut par exemple être exporté dans un fichier
XML (fonctions XML*) .
Exemple
Pour plus de détails sur l’utilisation du XML, consultez l’exemple "WD XML", livré
en standard avec WinDev.
WinDev gère en standard :

• les bases de données au format XML grâce à un accès natif fourni avec WinDev. Pour plus de
• les exportations vers le XML (fonctions TableVersXML, HExporteXML)
• l’import de données XML (fonction HImporteXML)
• la manipulation d’un document XML. Les fonctions permettant de manipuler un document
au format XML commencent toutes par XML* . Il est possible :
•Créer un document XML manipulable par WinDev (fonction XMLDocument)
•Lire et naviguer dans un document XML (fonctions XMLFils, XMLParent, XMLPremier, ...)
•Modifier un document XML (fonctions XMLInsèreDocument, XMLInsèreElément, XMLModi-

fie, ...)
•Exécuter une requête XPath dans un document XML (fonction XMLExécuteXPath)

375
Exemple de lecture d’un fichier XML

Nous allons travailler sur un fichier exemple "Exemple.XML".
4 Ouvrez le projet "XML.WDP". Ce projet est présent dans le sous-répertoire "Autoformation\Corri-

ges\XML" de WinDev 10.
Le fichier "Exemple.XML" contient les informations suivantes :
<COMMANDE>
<LIGNECDE NUMERO="1">
<PRODUIT> Choux </PRODUIT>
<PRIXUNI MONNAIE="Euro"> 2.06 </PRIXUNI>
<QUANTITE> 2 </QUANTITE>
</LIGNECDE>
<PRODUIT> Carotte </PRODUIT>
<QUANTITE UNITE="KG"> 1 </QUANTITE>
</LIGNECDE>
<PRODUIT> Ail </PRODUIT>
<QUANTITE UNITE="Gousse"> 1 </QUANTITE>
</LIGNECDE>
</COMMANDE>
Ce document XML représente une commande ("<COMMANDE>") de trois lignes de produits :

• 2 choux à 2.06 Euros pièce (<LIGNECDE NUMERO="1">)
• 1 kilo de carottes à 1.93 Euro le kilo (<LIGNECDE NUMERO="2">)
• 1 gousse d’ail à 0.65 Euro la gousse (<LIGNECDE NUMERO="3">)
Dans cet exemple, nous verrons comment traiter cette commande au format XML, effectuer des
parcours sur les balises XML et extraire les données qui s’y trouvent.
4 Ouvrez la fenêtre "ExempleXML.WDW".

376
Traiter un document XML

Afin de pouvoir effectuer des manipulations sur le document XML, il est nécessaire de "créer" un
document XML avec la fonction W-Langage XMLDocument. Voici la syntaxe d’utilisation de cette
fonction :
-- Code du bouton Créer un document
SAI_OPERATIONS = ""
TraiteXML..Etat = Grisé
CodeXML est une chaîne
CodeXML = fChargeTexte("Exemple.XML")
//Fermeture du document s'il s'agit du deuxieme clic
XMLTermine("Commande")
//Création du document
XMLDocument("Commande", CodeXML)
Erreur("Le document n'est pas au format XML")
RETOUR
SINON
SAI_OPERATIONS = CodeXMl
TraiteXML..Etat = Actif
Info("Le document XML a bien été créé")
FIN
Ce code permet de charger le code XML (présent dans un document texte) dans un document XML
nommé "Commande". Ce code est récupéré grâce à la fonction fChargeTexte du W-Langage. On
manipulera ensuite le document XML par ce nom.
Parcours
On parcourt un fichier XML de la même manière que l’on parcourt un fichier de données (avec les
fonctions HLit*). Les fonctions XMLPremier, XMLSuivant, XMLDernier, XMLPrécédent et XMLEnDe-
hors permettent de parcourir un document XML en se positionnant sur les balises contenues dans
ce document. Les fonctions XMLNomElement et XMLDonnée permettent entre autre de récupérer
le nom de la balise en cours de lecture et sa valeur.
Vous devez toujours avoir à l’esprit la notion de niveau dans un document XML.
Notes
En effet, un document XML est un document structuré avec une racine, des
noeuds "parents" et des noeuds "enfants".
Dans notre exemple, les balises "LIGNECDE" sont toutes de même niveau. "COMMANDE" est la
balise de niveau supérieure par rapport aux balises "LIGNECDE". Les balises "PRODUIT", "PRIXUNI"
et "QUANTITE" sont des balises de niveaux inférieurs par rapport aux balises "LIGNECDE".
Détecter la fin du document

La fonction XMLEnDehors permet de détecter la fin d’un document XML. La fonction XMLEnDehors

377
permet également de détecter la fin d’un niveau.

SI XMLEnDehors("Commande") ALORS
Erreur("Fin de parcours")
FIN
Se positionner sur la première balise d’un niveau

Pour se positionner sur la première balise du document, il faut utiliser la fonction XMLPremier :
XMLPremier("Commande")
Info("Première balise du parcours : " + ...
XMLNomElement("Commande"))
Pour se positionner sur la dernière balise d’un niveau, il faut procéder de la même façon avec la
fonction XMLDernier.
Se positionner sur la balise suivante de même niveau

Pour se positionner sur la balise suivante de même niveau, il faut utiliser la fonction XMLSuivant :
XMLSuivant("Commande")
Info("Il n'y a plus de balise à lire sur ce niveau")
SINON
Info("Balise suivante du parcours : " + ...
XMLNomElément("Commande"))
FIN
Pour se positionner sur la balise précédente, il faut procéder de la même façon avec la fonction
XMLPrécédent.
Le message d’erreur vous indique que vous êtes arrivé en fin de parcours. Cela est tout à fait nor-
mal, puisqu’il n’y a pas d’autres balises de même niveau que "<COMMANDE>".
Se positionner sur la balise d’un autre niveau

Pour se positionner sur la balise suivante sur un autre niveau, il est nécessaire d’utiliser les fonc-
tions XMLFils (pour se positionner sur la première balise fille de la balise en cours) et XMLParent

378
(pour se positionner sur la balise mère de la balise en cours).

Notes
Si une balise possède un attribut (par exemple "<LIGNECDE NUMERO=1>"), la fonc-

tion XMLFils se positionne sur l’attribut et le considère comme une balise.
Descendre d’un niveau

//Récupère le nom de la balise en cours
NomBalise est une chaîne = XMLNomElément("Commande")
//Descend d’un niveau
XMLFils("Commande")
SINON
Info("Balise fille de la balise : " + NomBalise + " est " + ...
XMLNomElément("Commande"))
FIN
Remonter d’un niveau :

//Récupère le nom de la balise en cours
NomBalise est une chaîne = XMLNomElément("Commande")

//Remonte d’un niveau
XMLParent("Commande")
SINON
Info("Balise parente de la balise : " + NomBalise + ...
" est " + XMLNomElément("Commande"))
FIN

379
Récupérer des valeurs
Récupérer le nom de la balise en cours

Nous l’avons déjà évoqué, la fonction permettant de récupérer le nom de la balise courante est
XMLNomElement :
Info("La balise courante est " + XMLNomElement("Commande"))
Récupérer le nom de la balise en cours

Nous l’avons déjà évoqué, la fonction permettant de récupérer la valeur de la balise courante est
XMLDonnée :
Info("La valeur de la balise courante est " + ...
XMLDonnée("Commande"))
Effectuer une recherche
Vous avez la possibilité d’effectuer une recherche dans un document XML. L’élément recherché
peut être une balise, un attribut ou une valeur
La fonction permettant d’effectuer des recherches dans un document XML est XMLRecherche.
Nous ne détaillerons pas cette fonction. Consultez l’aide en ligne (mot-clé : "XMLRecherche").
Pour en savoir plus sur les fonctionnalités XML de WinDev, consultez l’aide en ligne (mot-clé :
"XML").

380
LEÇON 7.13. LE MULTITHREAD

• Qu’est-ce que le "multithread" ?


381
Définition
Les threads permettent d'exécuter du code (ou des traitements) en parallèle de l'application princi-
pale. 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.
Les threads remplacent certains types de timer.
Un thread efficace est un thread qui attend un événement, par exemple, une action de l'utilisateur,
la réception d'un e-mail, la réception d'un appel téléphonique, ...
Quelques exemples d'utilisation des threads :

• Récupération d'e-mails en tâche de fond, pendant la saisie d'un nouvel e-mail par exemple.
• Application de communication : gestion des appels téléphoniques, communication par
socket, ...
Avec WinDev, vous avez la possibilité de :

• gérer simplement des threads (fonctions Thread*, ThreadExécute, ThreadArrête ...)
• utiliser les threads avec des "sémaphores", afin de limiter leur action en simultané à un ins-
tant donné (fonctions Sémaphore*)
• gérer des "signaux" afin de synchroniser plusieurs threads (fonctions Signal*, SignalCrée,
SignalDétruit ...)
Exemple
Exemple
WinDev est livré en standard avec un exemple permettant de comprendre l’intérêt
et l’utilisation des threads, "WD Pool de Threads".
Pour plus de détails sur la gestion du multithread avec WinDev, consultez l’aide en ligne (mot-clé :
"Thread").

382

PARTIE 8
Application JAVA
385
LEÇON 8.1. CONCEPTS

• Qu’est-ce qu’une application JAVA ?

• Principe de génération d’une application JAVA depuis WinDev

Partie 8 : Application Java

386
Qu’est-ce qu’une application Java ?

Une application WinDev Java est entièrement compilée en Java. Si cette application manipule une
base de données, cette base doit disposer d’un driver JDBC (MySQL, Oracle, ...). Ce driver est spéci-
fique à chaque base de données (et peut être trouvé sur le site Internet de l’éditeur de la base de
données).
Une application Java correspond à un fichier ".jar" et nécessite le runtime Java pour pouvoir être
exécutée.
Pourquoi développer une application Java avec WinDev ?

Vous possédez une application WinDev qui fonctionne sous Windows et vous voulez la rendre
accessible quel que soit le système d’exploitation ? Générez une application Java et ainsi les utili-
sateurs travaillant sous un système MAC OS par exemple pourront également utiliser votre applica-
tion.
Vous pouvez ainsi partager vos applications réseau
Principe de génération d’une application Java avec WinDev

WinDev permet de générer une application Java sans connaître le langage Java. Le développement
de l’application se fait comme pour toutes les applications WinDev en W-Langage.
Lors de la compilation du projet WinDev, les fenêtres et les fonctions du W-Langage sont automati-
quement converties en Java.

387
Les différentes étapes permettant de créer une application Java à partir de WinDev sont les suivan-
tes :
Analyse
W-Langage
Fonctions compatibles uniquement
RAD JAVA
Collections de procédures
Fenêtres
Java Création d’une archive Java

- Création des fichiers Java
- Compilation automatique (SDK de Sun
version 1.4.2 ou supérieure nécessaire)

Java
Application Java
redistribuable
(fichier .JAR)
Remarque : Le nombre de fonctions W-Langage utilisables dans un projet JAVA est limité
dans cette version. Ce nombre de fonctions est amené à croître régulièrement.

388
LEÇON 8.2. PREMIÈRE APPLICATION JAVA

• Comment créer un projet Java.

• Comment créer et installer une application Java.
Vous trouverez dans le répertoire "\Autoformation\Corriges\WD Java" le projet "WD

Java.WDP" illustrant cette leçon.
l’option "? .. Guide d’auto-formation .. Archive Java".


389
Présentation
WinDev permet de générer des applications Java sans pour autant connaître le langage Java. Tout
le développement de l’application se fait en W-Langage, comme pour toute autre application créée
avec WinDev.
Dans cette leçon, nous allons manipuler un projet WinDev destiné à une génération Java.
L’utilisation d’une base de données utilisant un driver JDBC implique une configuration spécifique
du poste de développement ou d’un serveur. Dans cette leçon, nous manipulerons donc un fichier
texte (plus simple à mettre en place).
4 Ouvrez le projet "WD JAVA.WDP". Ce projet est présent dans le sous-répertoire "Autoforma-
tion\Corriges\WD JAVA" de WinDev.
4 Lancez le test du projet (icone (ou [CTRL + F9]). Ce projet permet de manipuler une liste de
clients présente dans un fichier texte.
Pour compiler (en Java) un projet Java réalisé avec WinDev, il est nécessaire d’installer sur le
poste de développement le J2SDK de Sun (version 1.4.2 ou supérieure nécessaire). Une version
est disponible sur le CD d’installation de WinDev. Il est également possible de télécharger ce pro-
gramme sur le site de Sun.
Pour exécuter un projet Java réalisé avec WinDev, il est nécessaire d’installer sur le poste de
déploiement :
• le runtime Java (JRE de Sun version 1.4.2 ou supérieure)
• l’application générée par WinDev (Fichier .jar)
• la librairie WD100Java.jar. Cette librairie peut être intégrée dans le fichier .jar.
• les drivers JDBC nécessaires pour manipuler une base de données. Ces drivers peuvent être inté-
grés dans le fichier .jar.

390
Créer un projet JAVA

Pour créer un projet Java, il suffit d’indiquer dans l’assistant de création d’un projet que vous vou-
lez générer une application Java. Vous pouvez :
• soit utiliser l’option "Fichier .. Nouveau", suvolez le "P" et cliquez sur l’icone Java.
• Soit utiliser l’option "Fichier .. Nouveau .. Projet", et indiquer dans l’assistant que le projet corres-
pond à une application Java.
A tout moment, vous pouvez créer une configuration de projet "Java" dans votre projet (option "Pro-
jet .. Configuration de projet .. Gestion des configurations").
Dès que le projet est configuré comme un projet Java (ou si une configuration Java est sélection-
née), tous les outils disponibles avec WinDev sont automatiquement paramétrés pour le projet Java
:
• Le RAD fenêtre ou le RAD application complète est spécifique à une base de données mani-
pulée par une application Java.
• La compilation du projet indique si votre projet contient des fonctions ou des champs non uti-
lisables en Java. Un message apparaît en bleu dans le volet "Code". .
• La création de l’archive permet de générer un fichier .jar dans le répertoire EXE du projet.
Remarque : Il est conseillé de créer un nouveau projet WinDev pour développer une application
Java plutôt que de transformer une application WinDev en application Java.
Le RAD Java
Comme sur tout projet WinDev associé à une analyse, vous pouvez utiliser le RAD pour générer les
fenêtres de votre application Java.
Vous pouvez créer des fenêtres fiche, table, ... Le RAD Java prend en compte toutes les spécifici-
tées de la génération Java (champs, traitements, fonctions utilisables dans une application WinDev
générée en Java).
Quel que soit le type de fenêtre à générer, vous pouvez choisir d’accéder à la base de données soit
par Hyper File (sous Windows et Linux), soit par le driver JDBC.
Si vous utilisez le driver JDBC, l’assistant permet de spécifier les paramètres de connexion à la

391
base de données utilisant le driver JDBC :
Les fenêtres générées par le RAD Java utilisent les fonctions SQL du W-Langage. La connexion à la
base de données est réalisée grâce à la fonction SQLConnecte.
Test d’un projet Java sous l’éditeur

Lors du test d’un projet Java (icone ), le projet est compilé et lancé sous Windows. Le projet

n’est pas compilé en Java.
Compiler un projet Java sous WinDev

La compilation d’un projet Java permet de :
• connaître les erreurs de programmation présentes dans le code W-Langage
• visualiser les champs, traitements, fonctions W-Langage non disponibles en Java. Ces
erreurs apparaîssent en bleu dans le volet "Code".
Pour plus de détails sur les éléments WinDev non disponibles dans une application Java,
consultez l’aide en ligne.
Remarque : Le nombre de fonctions W-Langage utilisables dans un projet JAVA est limité
dans cette version. Ce nombre de fonctions est amené à croître régulièrement.
Pour compiler un projet Java, utilisez l’option "Projet .. Compiler le projet".

392
Créer une archive Java

WinDev permet de :
• créer et compiler sous un compilateur Java les différents fichiers Java nécessaires à l’application
• créer une archive Java.
Pour compiler (en Java) un projet Java réalisé avec WinDev, il est nécessaire d’installer sur le
poste de développement le J2SDK de Sun (version 1.4.2 ou supérieure nécessaire). Une version
est disponible sur le CD d’installation de WinDev. Il est également possible de télécharger ce pro-
gramme sur le site de Sun.
Pour créer l’archive Java :

1. Sélectionnez l’option "Atelier .. Java .. Générer l’archive Java". L’assistant de création
d’archive Java se lance :
Sélectionnez "Générer une application Java directement exécutable" et cliquez sur le bouton
"Suivant".

393
2. Dans cet exemple, nous allons créer une application Java classique :
Vous pouvez également créer :

- une applet Java : dans ce cas, l’applet pourra être affichée et manipulée dans une page Web.
- une application pour Java Web Start : dans ce cas, l’application Java installée sur un serveur
sera lancée par une page Web. Cette archive sera exécutée comme une application classique.
Cliquez sur le bouton "Suivant".
3. Indiquez le nom de l’archive et sa description.
Cliquez sur le bouton "Suivant’.

394
4. Spécifiez si le framework WinDev pour Java doit être intégré dans l’archive .jar.

5. Indiquez les autres fichiers à intégrer dans l’archive .jar. Vous pouvez sélectionner par exem-
ple les drivers JDBC permettant l’accès à une base de données.
6. Indiquez :
• le compilateur Java à utiliser (si plusieurs compilateurs sont installés sur le poste). Vous pou-
vez également spécifier la ligne de commande à utiliser (pour plus de détails, consultez la
documentation du compilateur choisi).

• l’outil de création d’archive à utiliser. Vous pouvez également spécifier la ligne de commande
à utiliser (pour plus de détails, consultez la documentation du compilateur choisi) et le con-
tenu du manifeste de l’archive.
• la commande d’intégration d’autres archives.
7. Indiquez si vous souhaitez faire une sauvegarde du projet (conseillé lors du déploiement de
l’application).
8. La création de l’archive .jar est terminé. Le fichier correspondant a été créé dans le réper-
toire "EXE" du projet. Vous pouvez l’exécuter.
Déployer une application Java

Pour déployer une application Java, il est nécessaire de copier l’archive .Jar ainsi que le framework
WinDev présent dans le répertoire EXE du projet sur le poste d’exécution (Windows ou Linux).
Sur le poste d’exécution, il suffit ensuite de lancer l’archive Java (fichier .Jar).
Pour plus de détails, consultez l’aide en ligne (mot-clé : Java, Déployer une application Java)
Remarque : une application Java peut également être installée selon le principe "Java Web Start".

395
Dans ce cas, l’application est déployée sur un serveur Web, et lancée depuis un navigateur sur les
postes Client. Cette application est exécutée comme une application Java "classique". La mise à
jour de l’application sur le serveur provoque la mise à jour de l’application sur les postes Client.
Pour utiliser cette fonctionnalité, lancez l’assistant de génération d’une archive Java, et choisissez
le type d’application "Générer une application pour Java Web Start".
Création d’une applet Java

WinDev permet très simplement de créer une applet Java à partir de votre application et de tester
immédiatement cette applet. cette applet pourra ensuite être intégrée dans votre site Web (déve-
loppé par exemple avec WebDev).
Pour créer une applet Java :

1. Sélectionnez l’option "Atelier .. Java .. Générer l’archive Java". L’assistant de création
d’archive Java se lance :
Sélectionnez "Générer une application Java directement exécutable" et cliquez sur le bouton
"Suivant".
2. Sélectionnez l’option "Générer une applet Java".
3. Précisez les informations générales de l’archive.
4. Spécifiez si le framework WinDev pour Java doit être intégré dans l’archive .jar.
5. Indiquez les autres fichiers à intégrer dans l’archive .jar. Vous pouvez sélectionner par exem-
ple les drivers JDBC permettant l’accès à une base de données.
6. Définissez les paramètres de signature de l’archive Java.
7. Indiquez :
• le compilateur Java à utiliser (si plusieurs compilateurs sont installés sur le poste). Vous pou-

396
vez également spécifier la ligne de commande à utiliser (pour plus de détails, consultez la
documentation du compilateur choisi).
• l’outil de création d’archive à utiliser. Vous pouvez également spécifier la ligne de commande
à utiliser (pour plus de détails, consultez la documentation du compilateur choisi) et le con-
tenu du manifeste de l’archive.
• la commande d’intégration d’autres archives.
• la commande de génération du fichier de signature
• la commande de signature d’archive
8. La création de l’applet Java est terminée. Le fichier correspondant a été créé dans le réper-
toire "EXE" du projet. Il est possible de tester cet applet directement en lançant la page HTML
générée dans le répertoire "EXE" du projet.
Autres fonctionnalités
Intégration à Eclipse
Eclipse est un environnement de développement intégré dont le but est de fournir une plate-forme
modulaire pour permettre de réaliser des développements informatiques en Java.
L’appel à l’environnement WinDev peut être intégré dans les menus d’Eclipse, ce qui simplifie
l’appel de WinDev depuis Eclipse.
Un plug-in est fourni avec WinDev. Pour plus de détails, consultez l’aide en ligne (mot-clé :
"Eclipse").
Réaliser l’interface d’une application Java avec WinDev
WinDev peut être utilisé comme générateur de fenêtres d’une application Java.
L’application Java dispose ainsi de l’ergonomie, des tests automatiques d’une application WinDev.
Fenêtres et champs se manipulent par des classes et des méthodes spécialisées pour chaque
fenêtre et chaque champ. La "Javadoc" est fournie dans le répertoire "Aide" de WinDev.

PARTIE 9
Communication
399

• La communication avec WinDev.

400
Communiquez avec WinDev
Les moyens de communication offerts par WinDev vous permettent une ouverture totale !
Réplication, RPC, TAPI, réseau, socket, FTP, e-mail, HTTP, XML, SOAP, J2EE, .NET, Twain, RS232 ...
autant de standards supportés par WinDev.
Dans cette partie, nous n’aborderons malheureusement pas toutes les possibilités offertes par
WinDev 10. Nous étudierons en particulier les points suivants :

• la gestion des e-mails
• le transfert de fichiers par FTP
• les services Web (SOAP, .NET et J2EE)
Pour plus de détails sur la communication avec WinDev, consultez l’aide en ligne et les exemples
livrés en standard avec WinDev.

401
LEÇON 9.2. LA GESTION DES E-MAILS

• Prise de connaissance avec les fonctions Email de WinDev.

402
Présentation
Le W-Langage possède toutes les fonctions de programmation nécessaires pour gérer la réception
ou l’envoi de messages Internet (appelés "e-mails"). De plus, grâce à WinDev, vous pourrez connaî-
tre toutes les caractéristiques d’un e-mail :
• expéditeur, destinataires
• date d’envoi, sujet, message
• pièces jointes ...
WinDev permet de gérer les e-mails grâce à deux méthodes :

1. Les protocoles POP3 / SMTP (méthode la plus courante). Ces protocoles sont des protocoles
de gestion des e-mails reconnus par tous les fournisseurs de service. Ces protocoles vous per-
mettent de dialoguer directement avec le serveur, disponible chez votre fournisseur d’accès.
2. L’API "Simple Mail API" (appelé aussi SMAPI ou Simple MAPI) : ce mode de gestion des e-
mails est utilisé par la plupart des applications Microsoft et principalement Microsoft
Exchange.
Nous évoquerons dans ce cours uniquement la méthode de gestion par les protocoles POP3 /
SMTP. En effet, c’est le mode qui est actuellement le plus utilisé dans le monde.
Pour plus de détails sur Simple MAPI, consultez l’aide en ligne (mot-clé : "Simple MAPI").
Les fonctions de gestion des e-mails commencent toutes par "Email".
Les protocoles POP3 / SMTP

Pensez également à consulter l’exemple "WD POP3" livré en standard avec WinDev.
Le protocole POP3 permet de recevoir des e-mails.
Le protocole SMTP permet d'envoyer des e-mails
Nous ne détaillerons pas ici le principe de fonctionnement de ces protocoles.
Pour envoyer ou lire des messages grâce aux protocoles POP3/SMTP, il faut :
1. Se connecter au fournisseur d'accès (si nécessaire).
2. Ouvrir une session de messagerie avec la fonction EmailOuvreSession.
3. Envoyer et lire les messages.
4. Fermer la session de messagerie avec la fonction EmailFermeSession.
5. Se déconnecter (si nécessaire).

403
Ouvrir une session de messagerie
4 Pour ouvrir une session de messagerie, il faut utiliser la fonction EmailOuvreSession :

USER est une chaîne = "Utilisateur"
Password est une chaîne = "MotDePasse"
ServeurPOP est une chaîne = "pop.wanadoo.fr"
ServeurSMTP est une chaîne = "smtp.wanadoo.fr"
NomUser est une chaîne
USER est une chaîne = "Utilisateur"
ServeurPOP est une chaîne = "pop.wanadoo.fr"
ServeurSMTP est une chaîne = "smtp.wanadoo.fr"
NomUser est une chaîne
SI EmailOuvreSession(USER,Password,ServeurPOP,ServeurSMTP) ALORS
NomUser = USER
SINON
NomUser = ""
Erreur("Impossible d'établir la connexion")
FIN
Avec la fonction EmailOuvreSession, vous pourrez à la fois lire et envoyer des e-mails. Pour plus de
détails, consultez l’aide en ligne (mot-clé : "Email, Fonctions E-mails").
Envoyer un e-mail
Pour envoyer un message avec WinDev, il suffit de renseigner les principales informations d’un e-
mail qui seront contenues dans la structure Email. Nous listons ici les éléments indispensables à
l’envoi d’un e-mail. Bien entendu, il existe d’autres informations que vous pouvez renseigner
(fichiers attachés, destinataires en copie cachée, etc ...), consultez l’aide en ligne pour plus de
détails (mot-clé : "Email, Structure email").
Email.AdresseExpediteur Chaîne de caractères obligatoire contenant l'adresse de l'expédi-

teur.
Email.Expediteur Chaîne de caractères contenant l'adresse à laquelle la réponse au

message doit être envoyée.
Email.NbDestinataire Entier contenant le nombre de destinataires du message. Il est

conseillé de limiter ce nombre à 20, en effet certains serveur
n’accepte pas plus de 20 destinataires par message.
Email.Destinataire Tableau de chaînes de caractères contenant les adresses des des-

tinataires principaux.
Email.Sujet Chaîne de caractères contenant le sujet du message
Email.HTML Chaîne de caractères contenant le message avec une mise en

forme HTML. Limité à 2 Go

404
Email.Message Chaîne de caractères contenant le texte du message (avec une

mise en forme texte simple). Limité à 2 Go
Astuce
Dans le cas d’un e-mail avec un contenu de type "texte brut", utilisez la variable
Email.Message plutôt que la variable Email.HTML.
Le code suivant illustre le remplissage des principales variables à renseigner :

// connexion au serveur effectuée avec EmailOuvreSession
// Remplissage des variables Email
Email.AdresseExpediteur = "pcsoft@pcsoft.fr"
Email.Expediteur = "pcsoft@pcsoft.fr"
Email.NbDestinataire = 1
Email.Destinataire[1] = "utilisateur@mail.com"
Email.Sujet = "Envoyer des e-mails avec WinDev !"
Email.Message = "Bonjour, ceci est un test"
Pour mettre en forme le message, on aurait pu écrire à la place de Email.Message :

Email.HTML = "<HTML><BODY><P ALIGN=’CENTER’>Bonjour, ceci" ...
+ " est un test</P></BODY></HTML>"
Il est possible d’utiliser les deux formes ensemble (texte et HTML). Ainsi les destinataires lisant leur
e-mail avec un outil incapable d’afficher du HTML verront le texte de Email.Message.
4 Pour envoyer le message que nous venons de décrire, il suffit tout simplement d’utiliser la fonc-
tion EmailEnvoieMessage :
// Lors de la connexion nous avons récupéré le nom
// de l’utilisateur dans la variable NomUser
// Envoie le mail
EmailEnvoieMessage(NomUser)
Erreur("EMailEnvoieMessage a échoué '" + ...
ErreurInfo(errMessage) + "'")
SINON
Info("EMailEnvoieMessage a réussi")
FIN
4 Pour ré-initialiser toutes les variables Email (par exemple lors de l’envoi de plusieurs e-mails les
uns à la suite des autres), il suffit d’utiliser la fonction EmailRAZ.

405
Lire un e-mail
Maintenant que nous sommes connectés à notre serveur et que nous avons envoyé un message,
nous allons voir comment en lire e-mail.
Sur le même principe qu’un parcours de fichier avec les fonctions HLitPremier, HLitSuivant ... il est
possible de lire les e-mails reçus avec les fonctions EmailLitPremier, EmailLitSuivant ... Pour plus
de détails sur ces fonctions, consultez l’aide en ligne (mot-clé : "Email, Lire un email").
Pour chaque e-mail lu, la structure Email est initialisée. Les variables de cette structure correspon-
dent à l'ensemble des caractéristiques de l'e-mail en cours.
Exemple de code :
// connexion au serveur effectuée avec EmailOuvreSession
// Lors de la connexion nous avons récupéré le nom
// de l’utilisateur dans la variable NomUser
// Lecture du premier e-mail
sMessage est une chaîne
EmailLitPremier(NomUser)
SI PAS Email.EnDehors ALORS
SI Email.HTML = "" ALORS
sMessage = Email.Message
SINON
sMessage = "Email au format HTML:" + RC + Email.HTML
FIN
Info("Expéditeur: " + Email.Expediteur + RC + ...
"Date d’envoi: " + Email.DateReception + RC + ...
"Sujet: " + Email.Sujet + RC + "Message: " + sMessage)
FIN
Comment récupérer un document attaché ?
Utilisez les variables Email.Attache et la fonction EmailSauveAttache ... Exemple de code :
Repert_Temp est une chaîne = "C:\temp\"
CID est une chaîne
I est un entier
// Pour chaque fichier attaché
POUR I = 1 à Email.NbAttache
// Copier le fichier dans un répertoire temporaire
EmailSauveFichierAttache(Email.Attache[I], Repert_Temp ...
+ Email.Attache[I])
// Récupérer l'identifiant du fichier attaché dans le mail
CID = "cid:" + Email.IdentifiantAttache[I]
// Remplacer les références au fichier attaché par
// le nom réel du fichier
Email.HTML = Remplace(Email.HTML, CID, "file:" + ...
Repert_Temp + Email.Attache[I])
FIN

406
Déconnexion
Pour vous déconnecter, il suffit tout simplement d’utiliser la fonction EmailFermeSession :
SI NomUser <> "" ALORS
EmailFermeSession(NomUser)
NomUser = ""
FIN
Autres possibilités
Il est également possible de :
• envoyer des fichiers attachés dans vos e-mails. Pour plus de détails, consultez l’exemple "WD
POP3" fourni avec WinDev.
• effectuer des mailings par e-mails. Pour plus de détails, consultez l’exemple "WD Mailing par
email".
• piloter le logiciel Microsoft Outlook grâce aux fonctions du W-Langage. Pour plus de détails,
consultez l’exemple "WD Outlook".
Pour plus de détails sur la gestion des e-mails avec WinDev, consultez l’aide en ligne (mot-clé :
"Email, Gestion des email").

407
LEÇON 9.3. TRANSFERTS FTP

• Prise de connaissance avec les fonctions FTP de WinDev.

408
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 W-Langage 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.
Connexion à un serveur FTP

La fonction W-Langage FTPConnecte permet de se connecter à un serveur FTP. Vous devez au préa-
lable posséder un compte FTP (nom d’utilisateur et mot de passe) pour accéder à un serveur FTP.
Exemple de code :
NomUSER est une chaîne = "Utilisateur"
AdresseFTP est une chaîne = "ftp.monsite.com"
Res est un entier
Res = FTPConnecte(AdresseFTP, NomUSER, Password)
SI Res = -1 ALORS
Erreur("Impossible de se connecter." + RC + ...
ErreurInfo(errMessage))
SINON
Info("Connexion réussie.")
FIN
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").

409
Envoyer un fichier
Pour envoyer un fichier vers un serveur FTP, il suffit tout simplement d’utiliser la fonction
FTPEnvoie :
// lors de la connexion au serveur avec FTPConnecte, nous avons
// récupéré le numéro de connexion dans la variable Res
// Transfert du fichier "C:\MesDocuments\Fichier.DOC" vers
// le répertoire "Temp" qui se trouve sur le serveur.
Result est un booléen = FTPEnvoie(Res, ...
"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
Attention !
sous UNIX et sont "case-sensitive", c’est-à-dire qu’ils sont sensibles à la casse du

nom des fichiers et des répertoires.
Par exemple, si sur le serveur FTP se trouve un répertoire nommé "MonRepertoire"
et que vous tentez d’accéder au répertoire "monrepertoire", le serveur FTP pourra
vous renvoyer une erreur du type "Chemin inexistant".
Récupérer un fichier
Pour récupérer un fichier depuis un serveur FTP sur votre machine, il suffit tout simplement d’utili-
ser la fonction FTPRécupère :
// 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
Res est un booléen = FTPRécupère(Res, ...
"/Document/Fichier.DOC","D:\Temp")

410
Déconnexion
Comme pour la fermeture d’une session de messagerie, il existe en W-Langage une fonction pour se
déconnecter d’un serveur FTP. Cette fonction se nomme FTPDéconnecte :
// Déconnexion
FTPDeconnecte(Res)
Il existe également d’autres fonctions FTP que nous ne détaillerons pas dans ce cours. Elles permet-
tent 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").


PARTIE 10
Utilisation avancée de WinDev

413
LEÇON 10.1. IMPORTS / EXPORTS

• Importer des éléments d’un projet dans un autre.

• Exporter les éléments de votre projet.
• Imports spécifiques (Projet WebDev, Access, Visual Basic, fenêtres non WinDev, ...).

Partie 10 : Utilisation avancée

414
Importer des éléments

Vous avez la possibilité d’importer des éléments WinDev existants dans votre projet. Vous pouvez
importer tous les types d’éléments WinDev :
• des fenêtres
• des états
• des classes
• des composants
• des procédures
• ...
4 1.
Pour importer des éléments existants dans le projet en cours :
Sélectionnez l’option "Fichier .. Importer .. Des éléments WinDev et leurs dépendances ..."
2. Cliquez sur et sélectionnez le répertoire où se trouvent les éléments à importer (le réper-
toire doit comporter des éléments WinDev).

415
3. Cliquez sur "OK" pour valider. WinDev liste alors les différents éléments que vous pouvez
importer présents dans le répertoire spécifié (les sous-répertoires ne sont pas pris en compte)
4. Sélectionnez les éléments à importer, puis validez par "OK".

Les éléments (et tous les fichiers utilisés par ces éléments : images, ...) font désormais partie
du projet.
Notes
Le bouton "Calculer" (présent dans la fenêtre d’importation) permet de calculer la

taille des éléments sélectionnés avec toutes leurs dépendances.

416
Exporter des éléments

Vous pouvez également exporter des éléments de votre projet vers un autre répertoire par exemple.
Ces éléments pourront alors être réutilisés dans d’autres projets.
L’exportation d’éléments est plus qu’une simple copie d’éléments. En effet, c’est
Attention !
le seul moyen sûr pour transmettre un élément d’un projet avec toutes ses dépen-
dances (images, icones ...). Une solution pratique pour transmettre des fenêtres
avec leurs dépendances par e-mail, par exemple.
4 1.
Pour exporter des éléments de votre projet :
Cliquez sur "Fichier .. Exporter .. Vers un répertoire ...".
Dans la fenêtre qui s’affiche, sélectionnez les éléments de votre projet que vous souhaitez
exporter.
2. Indiquez le nom du répertoire de destination (ou sélectionnez-le avec le bouton ).

Les éléments sont alors exportés vers le répertoire indiqué. Ces éléments sont toujours disponi-
bles dans votre projet.
Notes
Le bouton "Calculer" (présent dans la fenêtre d’importation) permet de calculer la

taille des éléments sélectionnés avec toutes leurs dépendances.

417
Importations spécifiques
Importation d’un projet WebDev
De plus en plus de sites WebDev doivent être transformés en applications WinDev. Désormais,
cette fonctionnalité est automatique.
WinDev permet d’importer une page ou un projet WebDev entier dans une application WinDev.
Lors de cette importation :
• Les pages sont transformées en fenêtres.
• Les codes "Serveur" et "Navigateur" sont regroupés.
• L’import d’éléments sans equivalent en WinDev (code Javascript par exemple), est effectué sous
forme de commentaires ou d’éléments séparés.
Pour importer un projet WebDev dans un projet WinDev :

1. Sélectionnez l’option "Fichier .. Importer .. Un projet WebDev". L’assistant d’import de projet
WebDev se lance.
2. Sélectionnez le projet WebDev à importer. Ce projet ne sera pas modifié et un nouveau pro-
jet WinDev sera créé.
3. Donnez le nom et l’emplacement du projet WinDev à créer.
4. Si une analyse est liée au projet, indiquez son nom, son emplacement, et si elle doit être uti-
lisée par le projet WinDev.
5. Indiquez les éléments à partager entre le projet WinDev et le projet WebDev (éléments com-
muns du type Etats, Classes, ...). Si les éléments sont partagés, ils ne seront pas copiés dans le
projet WinDev.
6. Cliquez sur "Terminer". Le projet WebDev est converti en projet WinDev.

Pour importer des éléments WebDev dans un projet WinDev :
1. Ouvrez le projet WinDev dans lequel l’élément doit être importé.
2. Sélectionnez l'option "Fichier .. Importer .. Des éléments WebDev". La liste des éléments pou-
vant être importés s’affiche.
3. Sélectionnez les éléments à importer. Cliquez sur "Suivant".
4. Indiquez les éléments à partager entre les projets WinDev et WebDev. Ces éléments ne
seront pas copiés dans le projet WinDev.
5. Validez (bouton "Terminer"). Les éléments spécifiés sont automatiquement importés dans le
projet WinDev en cours.
Importation d’une fenêtre

Une fenêtre d’une application non WinDev vous intéresse ? Vous souhaitez récupérer son
interface ? Rien de plus simple.
WinDev permet d’importer une fenêtre ouverte dans l’environnement en cours.
La fenêtre est importée dans le projet en cours. Chaque élément de la fenêtre est automatique-
ment transformé en élément WinDev (libellé, champ de saisie, bouton, ...).
Remarque : Tous les éléments de la fenêtre sont importés mais il est souvent nécessaire de modi-
fier la fenêtre pour obtenir l’interface voulue.

418
Pour importer une fenêtre dans un projet WinDev :

1. Ouvrez le projet WinDev dans lequel la fenêtre doit être importée.
2. Sélectionnez l'option "Fichier .. Nouveau .. Fenêtre".
3. Affichez l’onglet "Import". Les fenêtres actuellement affichées sur le poste en cours sont
automatiquement listées. Ces fenêtres sont identifiées par leur titre (affiché dans la barre de
titre).
Remarque : L’option "Générer des images pour les champs non reconnus" permet de rendre
l’interface finale plus proche de l’interface de la fenêtre à importer.
4. Validez (bouton "OK"). L’aperçu de la fenêtre à importer s’affiche.
5. Modifiez si nécessaire le type de champ créé lors de l’importation de la fenêtre (bouton
"Détails").
6. Validez (bouton "OK"). La fenêtre est automatiquement intégrée au projet WinDev en cours.
Limites : Ne sont pas importés :
• le code des éléments.
• les champs différents des champs suivants :
•champ standard de Windows.
•champs Delphi.
•champs Visual Basic.
• les images et les images de fond (sauf si l’option "Générer des images pour les champs non
reconnus" est cochée).
• la couleur des éléments.
Importation Access
WinDev offre la possibilité d’importer des éléments Access : Analyse, Formulaire, Requête, ou projet
complet.
Pour importer des éléments d’une application Access :
1. Sélectionnez l’option "Fichier .. Importer .. Un projet ou des éléments Access".
2. Sélectionnez le fichier ".mdb" correspondant au projet Access.
3. Sélectionnez les éléments à importer. Indiquez si nécessaire si la base de données doit être
migrée au format Hyper File ou conservée au format Access.
4.Validez.
Attention : L’importation d’éléments d’une application Access peut être relativement longue.
Importation Visual Basic

WinDev offre la possibilité d’importer des projets Visual Basic et des formulaires Visual Basic.
Pour importer des éléments d’une application Visual Basic :
1. Sélectionnez l’option "Fichier .. Importer .. Un projet ou des éléments Visual Basic".
2. Sélectionnez les fichiers correspondants aux éléments à importer.
3. Validez.
Attention : L’importation d’éléments d’une application Visual Basic peut être relativement lon-
gue.

419
LEÇON 10.2. DICTIONNAIRE

• Manipulation du dictionnaire.
• Gestion des abonnements.

420
Introduction
Le dictionnaire est un fichier pouvant contenir des éléments du projet :
• description de fichiers,
• description de rubriques,
• fenêtres,
• ...
Le dictionnaire est un moyen simple de conserver des éléments créés avec WinDev en prévision
d’une prochaine ré-utilisation dans de nouveaux projets.
Lors de cette ré-utilisation, chaque élément provenant d'un dictionnaire peut être "abonné" aux
modifications. A chaque modification de l’objet du dictionnaire, tous les objets abonnés pourront
intégrer cette modification, et ainsi "suivre" les évolutions du dictionnaire.
Un dictionnaire peut aussi être utilisé pour simplifier le travail en groupe : un dictionnaire partagé
entre plusieurs développeurs peut ainsi contenir des procédures, des boutons pré-définis, ... Ces
objets sont mis en communs, et accessibles par tous les développeurs.
Pour partager du "code", WinDev propose principalement quatre méthodes :

1. Les collections de procédures
Notes
2. Les classes
3. Les superchamps (à travers l’utilisation d’un dictionnaire)
4. Les composants
Pour manipuler un dictionnaire :

1. Affichez si nécessaire le volet "Dictionnaire" (option "Affichage .. Barre d’outils .. Diction-
naire).
2. Par un clic droit dans le volet :
•Choisissez l’option "Nouveau ..." pour créer un nouveau dictionnaire.
•Choisissez l’option "Ouvrir ..." pour ouvrir un dictionnaire existant.
Manipulation du dictionnaire
WinDev permet simplement de :
• Créer et ouvrir un dictionnaire.
• Ajouter des éléments dans un dictionnaire.
• Copier des éléments depuis un dictionnaire.

421
Création et ouverture d’un dictionnaire

Un dictionnaire correspond physiquement à un fichier ".DIC". Ce fichier est créé à partir du volet
"Dictionnaire" (option "Nouveau" du menu contextuel).
De même, l’ouverture d'un dictionnaire spécifique est réalisée à partir du volet "Dictionnaire"
(option "Ouvrir" du menu contextuel). Le fichier sélectionné est ouvert dans le volet.
4 1.
Pour afficher l'ensemble des éléments présents dans le dictionnaire :
Sélectionnez le nom du dictionnaire.
2. Affichez le menu contextuel du dictionnaire (clic droit) et sélectionnez l'option "Dérouler

tout".
Ajouter des éléments dans le dictionnaire

4 1.
Pour ajouter un élément dans un dictionnaire :
Réalisez un "Drag and Drop" de l'élément choisi vers le dictionnaire.
Selon l’objet à intégrer, le "Drag and Drop" peut être réalisé de différentes façons :
•directement depuis les éditeurs concernés (champ, groupe de champs, fenêtre, ligne de
code, ...).
•depuis le volet "Analyse" ou le volet "Projet" (fenêtre, fichier, rubrique).
•depuis le volet "Code" (procédure).
2. Indiquez si l'élément de l'application en cours doit être abonné à l'élément présent dans le
dictionnaire. En effet, lors de l’ajout d’un élément dans le dictionnaire, cet élément est
dupliqué : l'application d’origine contient un exemplaire de l’élément et un autre exemplaire est
copié dans le dictionnaire.
En cas de modification de l’élément de l'application, l’abonnement permet de répercuter ces
modifications à l’objet du dictionnaire, et par son intermédiaire à tous les objets abonnés.

422
Gestion des abonnements

L'abonnement à un élément du dictionnaire est automatiquement proposé :
• lors de l'intégration d'un élément dans le dictionnaire.
• lors de la copie d'un élément du dictionnaire dans un projet.
Si l’objet abonné n’est pas en phase avec le dictionnaire, la mise à jour de l’objet abonné est propo-
sée à l’ouverture ou la sauvegarde de cet objet :
Cet écran permet de :

• ouvrir l’élément sans mise à jour de l’abonnement,
• annuler l’ouverture de l’élément,
• mettre à jour tous les éléments les plus anciens,
• mettre à jour l’élément du dictionnaire à partir de l’élément abonné sélectionné dans la liste,
• mettre à jour l’élément abonné sélectionné à partir de l’élément du dictionnaire,
• supprimer l’abonnement, ...
Cas particulier : conflits

Un élément du dictionnaire peut être en conflit avec l’élément abonné. L’élément du dictionnaire et
l’élément abonné ont été modifiés différemment et ne sont plus en phase.
Le développeur peut :
• intégrer les évolutions de l’élément du dictionnaire : les dernières évolutions de l’élément abonné
seront perdues.
• mettre à jour l’élément du dictionnaire : les dernières évolutions de l’élément du dictionnaire
seront perdues.
Ré-utilisation des éléments d’un dictionnaire

Tous les éléments du dictionnaire peuvent être ré-utilisés dans n’importe quelle application WinDev.
Pour ré-utiliser un élément du dictionnaire, il suffit de :
1. Ouvrir le dictionnaire dans le volet "Dictionnaire".
2. Copier l’élément du dictionnaire vers l’éditeur concerné, par un simple "Drag and Drop". Lors
de cette copie, l’abonnement de l’élément copié à l’objet du dictionnaire est proposé.

423
LEÇON 10.3. DÉVELOPPEMENT EN GROUPE

• Présentation
• Le gestionnaire de sources


424
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 res-
sources (fenêtres, classes, ...) manipulées.
WinDev gère en standard :

• un gestionnaire de sources nommé "GDS" permettant de partager les sources de différents
projets entre développeurs.
• un mode de développement nommé "Groupware développeur".
Le gestionnaire de sources
Présentation
Totalement intégré à l’environnement, le GDS permet le développement performant en équipe,
l’historique des modifications et des versions, et l’automatisation de la sauvegarde des sources de
l’équipe de développement.
Dimensionné pour des équipes de 1 à 100 développeurs, le GDS favorise et normalise sans con-
trainte les échanges entre développeurs.
Le GDS utilise une base de sources : procédures, classes, fenêtres, états, composants, requêtes, ...
Cette base peut être installée :
• sur un serveur dédié
• sur un poste réseau, dans un répertoire partagé.
Le GDS permet un fonctionnement connecté en local et à distance, via Internet ou une liaison HTTP
ou HTTPS. Il est possible de travailler sur un projet depuis une agence ou depuis un site client, sans
crainte de perte des modifications effectuées. Le GDS permet également un fonctionnement
déconnecté (train, ...).
Fonctionnalités
Parmi les nombreuses fonctionnalités du GDS, vous trouverez :
• La base gère plusieurs projets : si plusieurs projets utilisent un même élément, cet élément
peut être partagé.
• Un historique de tous les éléments, depuis leur création est mémorisé dans la base.
• Le projet est présent sur chaque poste de développement. Il est donc possible de développer
avec un poste déconnecté.
• Sans login et sans les droits nécessaires, il est impossible d’accéder aux projets (sauf pour le
chef de projet). De même, chaque développeur peut avoir des droits différents sur chaque
élément.
• Il est possible de consulter à tout moment la liste des modifications effectuées entre deux
versions, par soi-même et/ou par d’autres développeurs.
• La base de données contenant le GDS peut être au format Client / Serveur ou réseau.

425
Remarque : A l’heure où nous imprimons ces lignes, le gestionnaire de sources est actuellement
en cours de validation par notre service Qualité. Une leçon spécifique du cours d’auto-formation
sur ce sujet sera prochainement disponible au format PDF sur le site de PC SOFT (www.pcsoft.fr).
Utilisation du groupware développeur

Création d’un projet
La création d’un projet destiné à être utilisé par plusieurs développeurs est identique à la création
d’un projet individuel. Dans ce cas, il est nécessaire de :
• créer le projet dans un répertoire partagé, accessible en lecture et écriture par tous les déve-
loppeurs du projet.
Il est important de noter que le répertoire partagé, s’il est accessible

Attention !
depuis un lecteur réseau, doit être "mappé" avec la même lettre de lecteur
sur tous les postes de développement.
Par exemple, si le projet est présent sur T:\Projet Partagé, tous les postes
doivent utiliser ce même chemin (avec le lecteur T) pour accéder au projet.
• spécifier que le projet va être utilisé par plusieurs développeurs.
Lors de la création d’un projet partagé, il est possible de :

• créer dès le début la structure du projet : analyse, principales fenêtres, classes, collections
de procédures, ... En effet, les développeurs participant au développement du projet n’auront
ainsi qu’à modifier les éléments du projet selon leurs besoins.
• accorder des droits spécifiques sur les différents éléments du projet grâce aux droits des
développeurs.
Nous utiliserons indifféremment les termes "groupware développeur" et "développement en

groupe" pour désigner ce mode de développement.

426
Caractéristiques du projet
Vous développez un projet à plusieurs :
4 Cochez simplement l'option "Nous travaillons à plusieurs sur le projet" présente dans la fenêtre
de description du projet (option "Projet .. Description du projet"). Votre projet est alors prêt pour
le développement en groupe.
Ouverture d'un élément du projet (fenêtre, état, ...)

Avec WinDev, vous pouvez extraire les éléments (pour 10mn, 1 heure, 3 jours ou 3 semaines ...)
d’un projet afin de les modifier et les réintégrer après modification.
Par défaut, tout élément du projet ouvert sous un éditeur de WinDev est automatiquement "extrait
du projet".
Seul le développeur qui a ouvert cet élément peut modifier cet élément. Les autres développeurs
peuvent uniquement visualiser l'élément dans l'état "avant extraction".
L'élément extrait apparaît dans un cadre bleu sous l'éditeur de projet. Le nom du développeur
ayant extrait l'élément est affiché.
Lors d'un test du projet ou lors de la création d'un exécutable, les autres développeurs manipulent
toujours l'élément dans son état avant extraction.
Pour visualiser uniquement un élément du projet (sans le modifier), ouvrez l'élé-

Astuce
ment en mode "Lecture seule" (option "Ouvrir en lecture seule" du menu contex-
tuel de l'élément sous l'éditeur de projet).
Connaître l'état des éléments d'un projet

4 Pour connaître l'état des éléments d'un projet, sélectionnez l'option "Projet .. Groupware Déve-
loppeur .. Etat des éléments".
Cette option permet également d'extraire ou de réintégrer un ou plusieurs éléments.
Fin de la modification d'un élément : réintégration

Lorsque les modifications effectuées sur l'élément sont terminées (20 minutes, 1 heure, ou plu-
sieurs jours après l'extraction), l'élément doit être réintégré (option "Fichier .. Groupware .. Réinté-
grer" ou option "Réintégrer" du menu contextuel de l'élément). L'élément devient disponible pour
tous les autres développeurs.

427
Attention !
Si vous réintégrez un élément actuellement ouvert sous votre éditeur, cet élément
sera en "Lecture seule" pour les autres développeurs.
Test d'un projet ou création d'un exécutable

Il existe deux possibilités :
1. Aucun élément n'a été réintégré par d'autres développeurs depuis votre dernière compilation
du projet : le test se fait selon le mode habituel, par le bouton .
2. Un ou plusieurs éléments ont été réintégrés depuis votre dernière compilation du projet : lors
du test ou de la création de l’exécutable, une synchronisation avec recompilation totale du pro-
jet est proposée par défaut. Cette recompilation n'est pas obligatoire.
Droits des développeurs

WinDev offre la possibilité de définir des droits d'accès spécifiques sur les différents éléments d'un
projet.
Cette option permet par exemple de restreindre les droits d'accès à un stagiaire. Cette option est
toutefois peu utilisée et n'est pas obligatoire lors du développement à plusieurs.
Par défaut, seuls le superviseur et le créateur de l'objet peuvent modifier les droits accordés aux
autres développeurs sur un objet.
Il est ainsi possible de gérer les droits d’accès sur les éléments suivants : le projet, l'analyse et ses
fichiers, les requêtes, les fenêtres, les états, les classes, les collections de procédures, le graphe

UML, le dictionnaire et les objets du dictionnaire.
4 1.
Pour protéger l’accès à un élément du projet :
Sélectionnez l’élément.
2. Dans le menu contextuel, sélectionnez l’option "Droits groupware".
3. Dans la fenêtre de visualisation des droits, vous pouvez :
•Consulter et / ou modifier les droits accordés à un développeur,
•Prendre en compte de nouveaux développeurs.
Les droits disponibles sont les suivants :

• Lecture : le développeur visualisera l’élément mais ne pourra pas le modifier.
• Ecriture : le développeur visualisera l’élément et pourra le modifier
• Modification de droits : le développeur sera autorisé à modifier les droits sur cet élément.
• Caché : le développeur ne pourra pas accéder à l’élément.
• Aucun droit : le développeur peut visualiser l’élément, mais ne peut pas l’éditer et le modifier.
Lors du développement d’un projet utilisant le groupware développeur, plusieurs messages infor-
meront le développeur des possibilités de manipulation des différents éléments du projet. Ainsi, le
signe "+" présent dans la barre de titre de l’élément signale que l’utilisateur a uniquement les
droits en lecture.

428
Cas particuliers
Travail en groupe et modification de l'analyse

La propagation des modifications réalisées dans l'analyse n'est pas effectuée automatiquement
sur les éléments extraits par d'autres développeurs.
La mise à jour de ces éléments devra être effectuée plus tard grâce à l'option "Projet .. Autres
actions .. Synchronisation des éléments restants".
Travail en groupe et sauvegarde du projet (option "Outils .. Sauvegarder")

Par défaut, seuls les éléments réintégrés dans le projet sont sauvegardés.
4 Pour
jet".
sauvegarder les éléments extraits, cochez l'option "Contenu des sous-répertoires du pro-
Bon à savoir :
Notes
Par défaut lors d’un travail en groupe, tout élément ouvert sous un éditeur est
automatiquement "extrait" du projet.
Astuce
Appuyez sur [F5] à tout moment pour visualiser les éléments extraits du projet.
Pour plus de renseignements sur le groupware développeur, consultez l’aide en ligne de WinDev
(mot-clé : "Groupware développeur").

429
LEÇON 10.4. ANALYSEUR DE PERFOR-

MANCES
• Présentation de l’analyseur de performances.

• Utilisation de l’analyseur de performances.

430
Présentation
L'analyseur de performances est un outil permettant de vérifier et d'optimiser le temps d'exécution
de votre application.
Il est conseillé d'utiliser l'analyseur de performances pour optimiser votre application (avant sa dif-
fusion par exemple).
Son principe est simple :

Vous testez votre application. Pendant ce test, l'analyseur de performances répertorie toutes les
actions et traitements exécutés.
A la fin du test, l'analyseur de performances vous présente :
• les 10 traitements qui ont pris le plus de temps
• toutes les actions effectuées dans l'application testée, triées par durée (de l'action la plus
longue à l'action la moins longue).
Il est possible de sélectionner en particulier un traitement afin d'analyser les causes d’un temps de
traitement trop important.
Utiliser l’analyseur de performances

L'analyseur de performances peut être lancé :
• directement depuis l'éditeur de WinDev (option "Projet .. Performances et améliorations .. Analy-
ser les performances".
Dans ce cas, le projet est alors automatiquement exécuté en mode test. Vous pouvez manipuler
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 W-Langage, 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 fichier WPF correspondant peut être ouvert dans l'analyseur de performances (option
"Projet .. Performances et améliorations .. Rapport de performances .. Ouvrir un rapport de per-
formances").
Par défaut, l'analyseur de performances enregistre les statistiques réalisées sur le code de l'appli-
cation dans un fichier <Nom du Projet>.WPF.
Pour changer ce nom, cliquez sur le bouton "Enregistrer sous ..." dans l'analyseur de performances.
Pour ouvrir un fichier de statistiques spécifique (par exemple un fichier créé par programmation) :
1. Sélectionnez l'option "Projet .. Performances et améliorations .. Rapport de performances ..
Ouvrir un rapport de performances".
2. Indiquez le chemin et le nom du fichier de statistiques.
La liste des derniers fichiers de statistiques ouverts est présente dans le menu "Projet .. Perfor-
mances et améliorations .. Rapport de performances .. ").

431
Optimiser un traitement avec l’analyseur de performances

Lire le résultat de l’analyseur de performances
L'analyseur de performances présente le résultat de l'analyse dans deux onglets :
• l'onglet "Synthèse" présente les 20 traitements qui ont pris le plus de temps.
• 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).
Pour chaque traitement, les informations suivantes sont affichées :
Les éléments affichés sont les suivants :

1. Fonction : Fonction, traitement ou procédure exécutée.
2. Temps Total : Temps d’exécution de la fonction.
3. Nb appels : Nombre d’appels effectués à la fonction (procédure ou traitement)
4. Temps 1 appel : Temps d’exécution d’un appel à la fonction (procédure ou traitement)
5. % Code : Pourcentage du temps passé dans le traitement de la fonction ou de la procédure
(code du développeur pouvant être optimisé)
6. Parent : Elément qui contient le traitement.

Choisir un traitement à optimiser
Le choix du traitement à optimiser se fait en fonction de plusieurs critères :
• le temps d'exécution du traitement. Les traitements les plus longs doivent bien entendu être opti-
misés.
• le pourcentage de temps passé dans le traitement de la fonction ou procédure. Plus ce pourcen-
tage est important, plus le code peut contenir des traitements pouvant être optimisés.
Optimiser un traitement
Lorsque le traitement à optimiser est choisi, l'analyseur de performances vous permet de connaître
le détail des opérations effectuées.
Pour afficher le détail des opérations effectuées dans un traitement :
1. Sélectionnez la fonction à optimiser dans l'onglet "Détail".
2. Affichez le détail de cette fonction :
•soit en double-cliquant sur la fonction.
•soit en cliquant sur le bouton "Appels".

432
L'onglet suivant apparaît :
Cet onglet est divisé en trois parties :

• La fonction sélectionnée (avec le nombre d'appels à cette fonctions et le temps total de traite-
ment).
• La liste des fonctions appelées par la fonction sélectionnée.
• La liste des fonctions appelant le traitement sélectionné.
La liste des fonctions appelées permet d'affiner la recherche du traitement à optimiser. En effet, il
est possible de visualiser les différentes fonctions appelées, et le temps de traitement de chaque
fonction.
Tous les traitements contenant du code W-Langage (nommé "Code du développeur") peuvent être
optimisés.
Un double-clic sur une des fonctions de cette liste (par exemple : "Clic sur Valider") permet de visua-
liser le détail des traitements appelés par cette fonction.
Remarques :
• Le libellé "Traitement interne au moteur d'exécution" correspond au temps d'exécution de la fonc-
tion ou de la procédure (cas d'une fonction W-Langage par exemple). Ce temps est incompressi-
ble et ne peut pas être optimisé.
• Le libellé "Code du développeur" correspond au temps d'exécution du code même de la fonction
ou de la procédure (hors appels de sous-fonctions). Ce temps est compressible et peut être opti-
misé.
• Pour visualiser rapidement le code du traitement en cours, il suffit de cliquer sur l'icone .
L'analyseur reste ouvert, et vous pouvez modifier le code en cours.
• Le bouton "Précédent" permet de revenir à la fonction immédiatement appelante.
• Le bouton "Début" permet de revenir au traitement du début de l'application.

433
LEÇON 10.5. COMPARATEUR DE PROJETS

Ce que vous allez apprendre dans cette leçon
• Présentation du comparateur de projets.

• Utilisation du comparateur de projets.

434
Présentation
Comparer deux fenêtres (deux états, deux classes, ...) est un besoin courant dans la vie d’une appli-
cation.
Par exemple, une fenêtre qui fonctionnait il y a deux semaines a été modifiée par un stagiaire. Cette
fenêtre ne fonctionne plus désormais. Comment connaître les modifications effectuées dans cette
fenêtre ? Il suffit d’utiliser le comparateur de projets !
Le comparateur de projets permet de comparer deux projets ou deux éléments WinDev (fenêtres,
états, ...) entre eux.
La comparaison est effectuée :

• sur l’IHM de l’élément et de ses sous-éléments (fenêtre et champs de cette fenêtre par exem-
ple).
• sur le code associé à l’élément et à ses sous-éléments (état et champs de cet état par exem-
ple).
Toutes les différences trouvées entre les deux éléments comparés sont listées.
Les éléments WinDev suivants peuvent être comparés :

• projet
• fenêtre
• état
• requête
• classe
• collection de procédures
Comparer des éléments

Le comparateur de projets permet de comparer :
• soit l’élément WinDev en cours avec un autre élément WinDev.
• soit deux éléments WinDev.
• soit deux projets WinDev.
Comment le faire ?
Pour comparer deux projets WinDev :
1. Sélectionnez l’option "Fichier .. Comparaison .. Comparer deux projets". L’assistant de compa-
raison se lance.
2. Sélectionnez les deux projets WinDev à comparer.
3. Validez (bouton "Terminer").
L’ensemble des différences trouvées entre les deux projets est listé.
Pour comparer l’élément WinDev en cours avec un autre élément WinDev :

1. Sélectionnez l’option "Fichier .. Comparaison .. Comparer l’élément en cours". L’assistant de
comparaison se lance.
2. Sélectionnez l’élément à comparer avec l’élément en cours.

435
L’ensemble des différences trouvées entre les deux éléments est listé.
Pour comparer deux éléments WinDev :
1. Sélectionnez l’option "Fichier .. Comparaison .. Comparer deux éléments". L’assistant de
comparaison se lance.
2. Sélectionnez le type d’élément WinDev à comparer (projet, fenêtre, état, ...).
3. Sélectionnez les deux éléments WinDev à comparer.
L’ensemble des différences trouvées entre les deux éléments est listé.
Visualiser les différences trouvées entre deux éléments

Les différences sont classées selon l’ordre suivant :
• différence de code : l’icone permet de visualiser simultanément le code des deux élé-
ments en cours de comparaison.
• différence d’interface : l’icone permet de visualiser les caractéristiques modifiées.

436
LEÇON 10.6. TESTS DE NON RÉGRESSION

• Présentation de WDTest.
• Utilisation de WDTest.


437
Présentation de WDTest
WDTest est un utilitaire permettant d'enregistrer et d'exécuter automatiquement des scripts de test
d'applications (WinDev ou non WinDev).
Un script de test contient principalement les différentes manipu-
lations (position de la souris, clic de souris et touche du clavier
utilisé) effectuées sur une application.
Après avoir été enregistré, le script de test peut être exécuté à
volonté. Lorsqu'un script est exécuté, un script de résultat est
automatiquement généré. Les différences entre les deux scripts
(script d'origine et script de résultat) sont signalées.
Il est ainsi possible par exemple de vérifier le fonctionnement de
vos applications WinDev entre deux mises à jour.
WDTest permet donc d'automatiser les procédures de test de vos applications.
Conditions d'utilisation
WDTest est un outil non redistribuable. WDTest ne peut pas être installé avec les applications déve-
loppées avec WinDev.
Pour utiliser WDTest, WinDev doit obligatoirement être installé sur le poste en cours.
Nous ne détaillerons pas toutes les possibilités offertes par WDTest. Nous aborderons uniquement
les principes d’utilisation de WDTest.
Utilisation de WDTest

WDTest peut être lancé :
• soit depuis l’éditeur de projet (menu contextuel d’une fenêtre par exemple, option "Tester la
non régression".
• soit depuis l’option de menu "Outils .. WDTest - Editeur de tests de non régression".
• soit depuis l’éditeur de fenêtres (option de menu "Fenêtre .. Tester la non - régression".
Le principe d'utilisation de WDTest est très simple :

1. Enregistrement du script de test.
2. Modification du script de test (si nécessaire).
3. Exécution du script de test et affichage du compte-rendu.
Enregistrement d’un script de test

L'enregistrement du script de test est une étape importante. Le script de test est un fichier texte
(extension ".TXT") contenant toutes les manipulations effectuées pendant l'enregistrement du
script. Pour chaque manipulation, le script contient :
• l'action effectuée (déplacement de la souris, utilisation d'une touche, ...).
• la position du curseur de la souris, s'il s'agit d'une action de la souris.
• la touche utilisée, s'il s'agit d'une action du clavier.
• la durée de l'action (en millisecondes).

438
• le titre de la fenêtre manipulée.
Pour enregistrer un script de test :

1. Lancez l’application à tester, et fermez toutes les autres applications.
2. Lancez WDTest (dans le menu de WinDev, "Outils .. WDTest - Editeur de tests de non régres-
sion").
3. Cliquez sur le bouton "Nouveau". Dans la fenêtre qui s’ouvre, indiquez un nom et spécifiez
les répertoires de sauvegarde des scripts et des résultats des tests.

439
4. Lorsque WDTest vous demande si vous souhaitez enregistrer le script, cliquez sur "Oui" si
vous êtes prêt à tester votre application. Sinon, vous pourrez lancer l’enregistrement du script
en cliquant sur le bouton "Enregistrer un script" dans WDTest.
5. WDTest vous informe alors que vous pourrez arrêter le test en appuyant sur la touche [Arrêt
Défil] ou en effectuant la combinaison suivante [CTRL] + [SHIFT] + [’+’ du pavé numérique].
6. Effectuer les différentes manipulations "tests" sur votre application (que vous aviez lancée
au départ).
7. Lorsque vous avez terminé, appuyez sur [Arrêt Défil]. L’enregistrement est alors effectué.
Pour réaliser des copies d'écran :

1. Lors de l'enregistrement du script, appuyez simultanément sur les touches

[Alt]+[Arrêt défil.] dès qu'une copie d'écran doit être réalisée.
2. Lors de l'exécution du script, les copies d'écran seront automatiquement
réalisées. Chaque copie d'écran réalisée sera enregistrée dans un fichier bit-
Astuce
map (extension ".BMP").

Ces fichiers sont nommés "<NomFichierScriptRésultat>XXX.BMP" et sont créés
dans le répertoire du fichier de script de résultat (répertoire du fichier ".LOG").
"XXX" représente trois chiffres correspondant à l'ordre de réalisation des copies
d'écran. La première copie d'écran s'appellera "<NomFichierScriptRésul-
tat>000.BMP", la seconde "<NomFichierScriptRésultat>001.BMP" et ainsi de suite.
Nous n’allons pas détailler la modification du script. Pour plus de détails, consultez l’aide en ligne
(mot-clé : "WDTest").
Exécution d’un script

WDTest permet d'exécuter les scripts de test :
• en continu. Tout le script est exécuté. Une vérification est effectuée à la fin.
• pas à pas. Il est possible d'exécuter :
• soit un à un les événements du script.
• soit un ensemble d'événements du script.
• soit tout le script est exécuté.

440
Cette fonctionnalité permet de connaître le résultat d'exécution d'un événement ou d'un

ensemble d'événements.
Un événement, un ensemble d'événements ou tout le script peut être exécuté selon des paramè-
tres d'exécution. Pour plus de détails, consultez l’aide en ligne (mot-clé : "WDTest").
Lors de l'exécution d'un événement, d'un ensemble d'événements ou de tout le script de test, un
fichier de script de résultat (fichier ".LOG") est généré. Ce fichier texte contient la description des
manipulations effectuées.
WDTest permet de :
• modifier la durée d'exécution d'un événement, d'un ensemble d'événement ou de tout le
script de test.
• spécifier un délai entre chaque manipulation du script de test.
Pour modifier la durée d'exécution, spécifiez un coefficient de temporisation dans l'option
"Coefficient" :
• pour augmenter la durée d'exécution : saisissez une valeur supérieure à 1.
• pour diminuer la durée d'exécution : saisissez une valeur comprise entre 0 et 1.
• pour conserver la durée d'exécution d'origine : saisissez "1".
Pour spécifier un délai entre chaque manipulation du script de test, spécifiez ce délai (en millise-
condes) dans l'option "Délai de temporisation supplémentaire".
Attention !
Si une des options ci-dessus est utilisée, l'action d'origine peut être modifiée. Par
exemple, un double-clic de souris exécuté plus lentement sera interprété comme
deux clics successifs (selon les propriétés de la souris utilisée).
Vous avez également la possibilité d’exécuter le script en continu, pour vérifier la stabilité de l’appli-
cation par exemple (bouton "Jouer les scripts" dans WDTest), ou bien exécuter le test en mode pas
à pas (bouton "Exécuter pas à pas").
Une fois l’exécution lancée, vous pouvez observer sur votre écran toutes les manipulations que
vous aviez enregistrées lors de l’enregistrement du script de test.
Lorsque l’exécution du test est terminée, WDTest compare le fichier de script de test avec un fichier
de résultat, pour observer d’éventuelles différences de comportement de votre application.
Astuce
Plutôt qu’un long scénario, créez plusieurs petits scénarios de tests, que vous
enchaînerez ...
Nous ne détaillerons pas plus les fonctionnalités de WDTest, nous vous conseillons de consulter
l’aide en ligne (mot-clé : "WDTest").

PARTIE 11
Comment le faire ?
443
QUESTIONS / RÉPONSES
• Réponses aux questions que vous pouvez vous poser.
Durée estimée : 1h30
Partie 11 : Questions / Réponses

444
Champs, fenêtres
Question Comment dupliquer un champ dans une fenêtre par programmation ?
Le "clonage humain" n’est pas encore en vogue, mais avec WinDev, il est déjà possible de cloner
les champs. La fonction ChampClone permet de dupliquer par programmation un champ dans une
fenêtre ou un état.
Le champ est dupliqué avec les mêmes caractéristiques mais avec un nom différent.
Question Comment supprimer un champ dans une fenêtre par programmation ?
La fonction ChampSupprime permet de supprimer par programmation un champ dans une fenêtre
ou un état.
Question Comment gérer les plans d’une fenêtre ?
Les plans d'une fenêtre permettent de répartir des champs dans différentes "couches" afin d'éviter
les écrans trop chargés ou la multiplication des fenêtres dans un projet.
Pour associer un champ à un plan :

1. Faites un clic droit sur le champ.
2. Sélectionnez l'option "Associer à un plan".
3. Choisissez le numéro du plan auquel le champ doit être associé.
Pour passer d'un plan à l'autre dans l'éditeur, utilisez les touches [Page Suivante] et [Page Précé-
dente] du clavier. Le numéro du plan en cours est affiché :
• dans la barre de message de l’éditeur (en bas à gauche)
• dans la fenêtre d’accueil de la fenêtre en cours (en haut à droite).
Astuce
Pour éviter de dupliquer un même champ dans une fenêtre, vous pouvez associer
le champ à "aucun plan". Le champ est alors visible dans tous les plans.
Seuls les champs du plan en cours et les champs n'appartenant à aucun plan sont visibles en édi-
tion et en exécution.
Vous pouvez également utiliser la propriété Plan pour :
• connaître et changer le plan actif d’une fenêtre.
• connaître et changer le plan associé à un champ.

445
Question Comment gérer le clic sur un volet d’un onglet ?
Un onglet est une sorte de bouton constitué de plusieurs zones clicables nommées "Volets".
Pour gérer et déterminer sur quel volet un clic est réalisé, utilisez la syntaxe suivante dans le code
de clic de l’onglet :
SELON NomChampOnglet
CAS 1 // premier volet
//...Traitement à effectuer...
CAS 2 // deuxième volet
//...Traitement à effectuer...
AUTRES CAS
//...Autres traitements à effectuer...
FIN
Question Comment afficher la progression d’un traitement ?
Pour afficher la progression d'un traitement, on utilise le plus souvent une jauge.
Pour cela, utilisez un champ Jauge dans une fenêtre (option "Insertion .. Champ .. Jauge").
Dans le code d’initialisation du champ Jauge :

1. Initialisez la valeur minimale de la jauge :

NomJauge..BorneMin = ValeurMini
2. Initialisez la valeur maximale de la jauge :
NomJauge..BorneMax = ValeurMaxi
Dans le code du traitement voulu, incrémentez la jauge à chaque étape du traitement :

NomJauge ++
// ou NomJauge = NomJauge + 1
Question Comment afficher un site internet dans une fenêtre ?
Avec WinDev, vous pouvez facilement insérer une liaison Internet dans vos applications. Pour cela :
1. Insérez un champ HTML dans une fenêtre (option "Insertion .. Champ .. Champ HTML").
2. Initialisez le champ HTML avec l'adresse du site auquel vous souhaitez vous connecter :
NomChampHTML = "http://www.pcsoft.fr"
Bien évidemment, votre poste (ainsi que le poste de l’utilisateur final) doit avoir une connexion à
Internet active.

446
Question Comment modifier la couleur d’un champ ?
La couleur d’un champ se définit dans le style du champ (option "Champ .. Choisir un style").
Cependant, il est possible de modifier la couleur de ce champ par programmation. La syntaxe est la
suivante :
// Colorier le texte en rouge
NomChamp..Couleur = iRougeClair
// Colorier la couleur de fond du libellé en vert
NomChamp..CouleurFond = iVertClair
// Remettre la couleur d'origine (celle du style)
NomChamp..Couleur = iCouleurDefaut
Notes
Cette syntaxe s'applique à tous les types de champs.
La fonction RVB permet de définir une couleur à partir des différentes valeurs des composantes
Rouge, Vert et Bleu.
<CodeCouleur> = RVB(<rouge>,<vert>,<bleu>)
Il est également possible de modifier les couleurs des lignes, des colonnes ou d’une cellule d'un
champ Table. La syntaxe est la suivante :

// Modification de la couleur d'une colonne
NomColonne..Couleur = <CodeCouleur>
// Modification de la couleur d'une ligne
NomTable[IndiceLigne]..Couleur = <CodeCouleur>
// Modification de la couleur d'une cellule
NomColonne[IndiceLigne]..Couleur = <CodeCouleur>
// ou
// NomTable[IndiceLigne, IndiceColonne]..Couleur = <CodeCouleur>
Question Comment rendre un bouton invisible ?
Un bouton peut être rendu invisible par programmation avec la syntaxe suivante :
NomBouton..Visible = Faux
Donnez la valeur "Vrai" pour rendre le champ à nouveau visible.

Cette syntaxe peut également être appliquée sur tous les types de champs et sur les groupes de
champs.

447
Question Comment créer le menu principal de mon application ?
Effectuez les opérations suivantes :

1. Créez une nouvelle fenêtre ou ouvrez une fenêtre existante.
2. Sélectionnez l'option "Fenêtre .. Ajouter le menu principal".
Une option est créée automatiquement.
3. Faites un clic droit sur cette option.
4. Cliquez sur "Description" pour modifier l'option sélectionnée.
5. Cliquez sur "Ajouter" pour ajouter une nouvelle option après.
6. Cliquez sur "Insérer" pour insérer une nouvelle option avant.
7. Cliquez sur "Insérer un sous-menu" pour ajouter un sous-menu dans l'arborescence du
menu.
Question Comment lier une fenêtre à une option de mon menu principal ?
La fonction Ouvre permet d'associer une fenêtre à une option de menu. Saisissez le code suivant
dans le code de clic de votre option de menu :
Ouvre(MAFENETRE)
Notes
Pour associer un état à une option de menu, utilisez la fonction iImprimeEtat :

iImprimeEtat(MONETAT)
Question Comment insérer automatiquement le menu "?" ?
Pour insérer automatiquement un menu "?" dans votre application, sélectionnez l’option "Fenêtres
... Menu principal .. Ajouter le menu ’?’" et sélectionnez les options désirées dans l’assistant qui se
lance.
Question Comment créer un menu contextuel ?
Un menu contextuel peut être ajouté :

• soit au niveau de la fenêtre.
• soit au niveau d'un champ.
Pour une fenêtre :
1. Faites un clic droit sur la fenêtre et sélectionnez l’option "Description".
2. Cliquez sur l'onglet "Détail" et sélectionnez "Menu contextuel".
Pour un champ :
2. Cliquez sur l'onglet "Détail" et sélectionnez "Menu contextuel".

448
Pour connaître ou modifier le menu contextuel d’une champ ou d’une fenêtre par programmation,
utilisez la propriété MenuContextuel.
Question Comment fermer une fenêtre automatiquement après une durée prédéfinie ?
Il suffit d’utiliser un bouton et la fonction DélaiAvantFermeture. Par exemple :

DélaiAvantFermeture("FENETRE", "BOUTON", 200)
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Fermer, Fermeture automatique (bouton)").
Notez que vous pouvez également utiliser l’option "Validation automatique" disponible dans l’onglet
"Détail" de la description de la fenêtre.
Question Comment modifier le curseur de survol pour un champ ou une fenêtre ?
Un curseur de survol peut être défini :

• soit au niveau de la fenêtre.
• soit au niveau d'un champ.
Pour définir le curseur de survol
1. Faites un clic droit sur l’élément (fenêtre ou champ) et sélectionnez l’option "Description".
2. Cliquez sur l'onglet "IHM" et sélectionnez le curseur de survol voulu dans la combo "Curseur".
Vous pouvez choisir parmi des curseurs prédéfinis ou sélectionner un curseur que vous avez créé.
Pour modifier le curseur de survol par programmation, utilisez la propriété CurseurSouris.
Question Comment passer des paramètres à une fenêtre ?
La méthode pour passer des paramètres à une fenêtre est similaire au passage des paramètres à
une procédure.
Dans le code de déclaration globales de la fenêtre, saisissez la syntaxe du code W-Langage

449
suivante :
PROCEDURE NomFenêtre(pNomParam1, pNomParam2, ...)
Lors de l'ouverture de la fenêtre avec la fonction Ouvre, passez les paramètres après le nom de la
fenêtre, par exemple :
Ouvre(Nomfenêtre, ValeurParam1, ValeurParam2, ...)
Si vous initialisez un paramètre lors de la déclaration dans la fenêtre, ce paramètre devient
optionnel :
// pNomParam2 est un paramètre optionnel
PROCEDURE NomFenêtre(pNomParam1, pNomParam2 = "Test")
Notes
Il est préférable de passer des paramètres à une fenêtre plutôt que de déclarer
des variables globales dans le projet.
Question Comment récupérer des paramètres passés en ligne de commande à un

exécutable ?
Il suffit d’utiliser la fonction LigneCommande dans le code d'initialisation du projet.

Consultez l'aide en ligne pour plus de détails sur cette fonctionnalité (mot-clé : "Ligne de com-
mande").

Vous pouvez simuler le passage de paramètres en ligne de commande à votre pro-
jet en mode test. Dans l'éditeur :
Astuce
1. Cliquez sur l'option "Projet .. Mode test .. Ligne de commande du mode

test".
2. Saisissez les paramètres de la ligne de commande.
Question Comment regrouper des champs pour modifier leurs propriétés par
programmation ?
Effectuez la manipulation suivante :

1. Sélectionnez plusieurs champs avec la souris.
2. Dans le menu de l'éditeur, sélectionnez l'option "Champ .. Groupes .. Associer la sélection".
3. Saisissez le nom du groupe et validez.
Les groupes de champs sont utilisables aussi bien dans les fenêtres que dans les états.
Les champs seront associés à ce groupe. Vous pourrez ensuite modifier les propriétés des champs
de ce groupe par la syntaxe :
NomGroupe..<NomPropriété> = Valeur

450
Attention !
Seules les propriétés communes à tous les champs sont modifiables.
Question Comment transformer un champ interrupteur en un champ sélecteur ?
L'option de menu "Champ .. Permuter .. Sélecteur/Interrupteur" inverse les deux types de champs.
Notes
Cette opération peut également être effectuée entre un champ Liste et une
Combo ou entre un champ Potentiomètre et un Potentiomètre rotatif.
Question Comment mettre des boutons à la même taille ?
4 Sélectionnez en premier le bouton servant de référence pour la taille (largeur et hauteur).

4 Sélectionnez les options d'alignement "Même largeur, Même hauteur" dans les outils d'aligne-
ment (option "Champ .. Alignement").
Question Comment gérer la persistance des champs ?
4 Pour gérer la persistance des champs, sélectionnez l’option "Mémoriser la valeur" dans l’onglet
"Détail" de la fenêtre de description du champ.
Remarque : l’utilisateur peut également mémoriser la valeur d’un champ grâce au menu contextuel
du champ.
Question Comment ajouter une image en fond dans une fenêtre ?
Sur la fenêtre :
1. Faites un clic droit et sélectionnez l'option "Description".
2. Sélectionnez l'onglet "Image". Vous pouvez choisir une image et son mode d'affichage.
Question Comment gérer la transparence d’une fenêtre ?
Sur la fenêtre :
1. Faites un clic droit et sélectionnez l'option "Description".
2. Sélectionnez l'onglet "Style".
3. Définissez l’opacité de la fenêtre grâce au potentiomètre.
Il est également possible de définir l’opacité d’une fenêtre grâce à la propriété W-Langage Opacité.

451
Environnement
Question Comment visualiser l’élément auquel appartient le traitement en cours ?
Pour visualiser l’élément correspondant au traitement en cours, cliquez sur l’icone . 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'icone dans la barre
d'icones de l'éditeur ou en sélectionnant l'option "Fichier .. Imprimer le dossier", ou la combinaison
de touches CTRL P.
Question Comment imprimer le dossier d’analyse ?
Le dossier d'analyse peut être imprimé directement en cliquant sur l'icone dans la barre d'ico-
nes de l'éditeur ou en sélectionnant l'option "Fichier .. Imprimer le dossier", ou la combinaison de
touches CTRL P.

Question Comment imprimer le dossier complet de mon projet ?
Le dossier complet du projet peut être imprimé en sélectionnant l'option "Projet .. Imprimer le dos-
sier du projet".
Question Comment créer un gabarit ?
Cette manipulation comprend de nombreuses étapes. Pour plus de détails, consultez l’aide ligne
(mot-clé : "Créer gabarit"). Mais n’oubliez pas : de nombreux gabarits sont disponibles en standard
avec WinDev !
Question Comment rechercher et/ou remplacer une variable dans le code ?
Les fonctions de recherche ou de remplacement dans le code sont accessibles depuis le menu de
WinDev (choix "Edition .. Rechercher" ou "Edition .. Remplacer") ou dans le volet "Recherche" en cli-

452
quant sur :
Vous pouvez accéder à la recherche à tout moment en appuyant sur les touches [CTRL]+[F].
Question Comment gérer une liste de tâches dans mon projet ?
La liste des tâches d'un projet peut être consultée et mise à jour en temps réel dans le volet "Liste
des tâches" de l'éditeur.
4 Pour ajouter directement une nouvelle tâche, faites un clic droit sur la liste des tâches et sélec-
tionnez "Créer une nouvelle Tâche".
Si vous saisissez dans l'éditeur de code un commentaire commençant par :

Astuce
// A FAIRE: écriture de la procédure Blabla

Une tâche sera ajoutée automatiquement dans la liste des tâches.
Cette liste des tâches est liée au projet en cours. Lors du développement en groupe, tous les déve-
loppeurs peuvent consulter et mettre à jour cette liste.
Question Comment connaître la liste des éléments de mon projet ?
Les éléments d'un projet contenus dans un projet sont : fenêtres, états, requêtes, …
4 Pour visualiser les éléments d'un projet, sélectionnez l’option "Projet .. Liste des éléments du
projet".
Astuce
Pour rechercher simplement un élément du projet, utilisez les touches "CTRL"+"E".

Vous pouvez rechercher un élément du projet sur une partie de son nom.

453
Question Comment visualiser et changer l’ordre de navigation des champs dans une
fenêtre ?
L'ordre de navigation des champs est défini par l'ordre de création des champs dans la fenêtre.
La touche de fonction [F5] permet de visualiser l'ordre en cours.
4 1.
Pour modifier l'ordre de navigation :
Sélectionnez l'option "Fenêtres .. Ordre de navigation .. Editer".
2. Dans la fenêtre affichée, modifiez l'ordre de saisie des champs.
L'option de menu "Fenêtres .. Ordre de navigation .. Définir en automatique" définit automatique-

ment l'ordre des champs en fonction de leur position et de leur alignement dans la fenêtre. Le par-
cours des champs démarre à partir du coin en haut à gauche de la fenêtre.
Question Comment ajouter une langue à mon projet ?
Dans le menu de WinDev, sélectionnez l'option "Projet .. Description du projet" puis sélectionnez
l'onglet "Langue". Dans la fenêtre affichée, cochez la ou les nouvelles langues à gérer.
Question Comment modifier les options de WinDev ?

Les paramètres d'environnement de l'éditeur (répertoire, langue, login, ...) sont modifiables depuis
les options de WinDev (option "Outils .. Options de WinDev").
Les paramètres d'affichage des fenêtres ou des états (clic, magnétisme, …) sont modifiables
depuis l'option "Affichage .. Options .. Modifier les options".
Question Comment créer un perso-dossier dans l’éditeur de projet ?
Les perso-dossiers permettent de ranger des éléments du projet. Vous pouvez par exemple créer
un perso-dossier pour conserver tout ce qui se rapporte à la gestion des fournisseurs. Le nombre
de perso-dossiers n’est pas limité et un élément peut être commun à plusieurs perso-dossiers.
4 1.
Pour créer un perso-dossier :
Affichez le menu contextuel du graphe du projet (Clic droit) et sélectionnez l’option "Nouveau
Perso-Dossier".
2. Indiquez le nom du perso-dossier et validez.
3. Déplacez par "Drag and Drop" les différents éléments dans le perso-dossier. Ce déplacement
peut être effectué directement dans le graphe du projet, ou depuis le volet "Projet".

454
Divers
Question Comment créer un site Internet dynamique relié à vos données ?
WebDev est un AGL dédié au monde Internet/Intranet.

Avec un existant sous WinDev, il est très facile de créer un site dynamique accédant aux mêmes
données. WebDev permet de créer rapidement ce site.
La philosophie de WinDev et WebDev est identique, l’ergonomie générale des deux produits est
très proche.
De nombreux éléments peuvent être partagés :
• Fichiers de données
• Classes, collections de procédures
• La majeure partie des ordres de programmation
• L’analyse.
La prise en main est donc facilitée. WinDev pour le Back Office, WebDev pour le Front Office.
Consultez notre service commercial pour obtenir de plus amples informations sur WebDev.
Question Comment créer une application pour Pocket PC reliée à vos données ?
WinDev Mobile est un AGL dédié au monde des Mobiles (Pockets PC, Smartphones, ...).
Avec un existant sous WinDev, il est très facile de créer une application pour Pocket PC accédant
aux mêmes données. WinDev Mobile permet de créer rapidement cette application.
La philosophie de WinDev et WinDev Mobile est identique, l’ergonomie générale des deux produits
est très proche.
De nombreux éléments peuvent être partagés :

• Fichiers de données
• Classes, collections de procédures
• La majeure partie des ordres de programmation
• L’analyse.
La prise en main est donc facilitée.

Consultez notre service commercial pour obtenir de plus amples informations sur WinDev Mobile.
Question Comment piloter Word et Excel par OLE Automation ?
OLE Automation permet d'utiliser directement les fonctions de Word et Excel. Par exemple pour pilo-
ter Word depuis WinDev, il suffit de déclarer :
MonWord est un objet OLE "Word.Application"

455
Et ensuite toutes les fonctions internes à Word sont pilotables en W-Langage. Exemple : la fonction
"Enregistrer Sous" :
MonWord >ActiveDocument>>SaveAs("C:\temp\MonDocument.doc")
Question Comment faire une "hard copy" ?
Intégrez dans votre fenêtre le superchamp "Capture d’écran" disponible dans le volet "Assistant
Catalogue". Vous n’avez même pas besoin de saisir de code !
Question Je souhaite numériser un document, est-ce possible avec WinDev ?
WinDev 10 intègre des fonctions TWAIN.

Les fonctions TWAINxxx permettent de numériser un document ou une image à partir de tout péri-
phérique compatible avec la norme TWAIN et donc depuis la plupart des scanners du marché.
Pour plus d'informations, consultez l'aide en ligne concernant les fonctions TWAIN* (mot-clé :
"TWAIN").
Question Je souhaite compresser des données, est-ce possible avec WinDev ?
WinDev possède un ensemble de fonctions permettant de compresser et de décompresser des

données. Le nom des fonctions concernées est préfixé par le mot "Zip".
Ces fonctions permettent de manipuler aussi bien le format ZIP de WinDev que les formats ZIP
standard (Winzip ou PKZip).
Pour plus d'informations, consultez l'exemple "WD Zip" livré avec WinDev ou reportez-vous à l'aide
en ligne (mot-clé : "Zip").
Question Comment lire et écrire dans la base de registres ?
Les fonctions RegistreLit, RegistreEcrit permettent de lire et écrire dans la base de registres.
Consultez l'aide en ligne pour obtenir la syntaxe détaillée de ces fonctions et des autres fonctions

456
de gestion de la base de registres (mot-clé : "Base de registres, Fonctions W-Langage").

Attention !
Veillez à bien sauvegarder la base de registres avant toute manipulation afin de

pouvoir la restaurer si vous faites une mauvaise manipulation.
Question Comment lire et écrire dans un fichier INI ?
Les fonctions IniLit, IniEcrit permettent de lire et d'écrire dans un fichier INI.
Consultez l'aide en ligne pour obtenir la syntaxe détaillée de ces 2 fonctions (mots-clés : "IniLit",
"IniEcrit").
Question Comment désinstaller une application réalisée avec WinDev ?
Lors de la création du programme d'installation, il est possible de prévoir la désinstallation de

l’application.
Si cette option a été choisie, le programme de désinstallation a automatiquement été créé. Votre
application a donc été enregistrée auprès de Windows pour pouvoir la désinstaller ultérieurement.
Pour désinstaller une application :
1. Cliquez dans le menu "Démarrer".

2. Sélectionnez le choix "Panneau de configuration".
3. Sélectionnez "Ajout/Suppression de programmes".
4. Sélectionnez l’application et cliquez sur "Désinstaller".
Question Comment créer une installation par CD-ROM ?
Lors de la création de l’installation (option "Atelier .. Créer la procédure d’installation"), vous avez la
possibilité de choisir différents supports d’installation. En sélectionnant l’option "CD-ROM", WinDev
créera un dossier dans lequel tous les fichiers nécessaires à une installation par CD-ROM seront
créés (fichier AUTORUN, fichiers d’installation, ...).
Vous n’avez plus alors qu’à graver le contenu de ce dossier complet sur un CD-ROM vierge pour dis-
tribuer votre application !
Question Comment créer un exécutable ?
L'exécutable de votre projet peut être créé en sélectionnant l'option "Atelier .. Générer l'exécutable
Windows".

457
Question Comment installer une application ?
Lorsque l’exécutable a été réalisé (option "Atelier .. Créer l’exécutable"), le répertoire EXE présent
dans le répertoire de votre projet contient tous les éléments permettant de faire fonctionner votre
application.
Pour préparer une installation de votre application :
1. Sélectionnez l'option "Atelier .. Créer la procédure d’installation". L'assistant de préparation
d'une installation démarre.
2. Suivez les instructions à l’écran.
Question Comment associer un icone à mon exécutable ?
L'icone qui est associé à votre exécutable peut être défini lors de la création de l'exécutable. Cet
icone doit être au format ICO.
Notes
Un catalogue d'icones prédéfinis est fourni en standard avec WinDev. Ce catalo-

gue est accessible lors de la sélection de l'icone.

Question Comment associer une image de lancement (splash screen) à mon
exécutable ?
L'image de lancement qui est associée à votre exécutable peut être définie lors de la création de
l'exécutable. Cet image doit être à un format standard reconnu par WinDev (BMP, WMF, GIF, JPEG,
TIFF, …)
Un catalogue d'images prédéfinies est fourni en standard avec WinDev. Ce catalogue est accessi-
ble lors de la sélection de l'image.
WinDev offre la possibilité de personnaliser directement cette image lors de la création de l’exécu-
table. Vous pouvez ainsi écrire le texte de votre choix (avec la mise en forme voulue) sur cette
image.
Question Comment mettre l’icone de mon application en bas à droite dans la barre de
tâches ?
Utilisez la fonction SysIconeAjoute. Exemple :

Res = SysIconeAjoute("C:\Icones\Icone.ICO", "MenuContextuel",...
"Message survol", "NomProcédure associée")
Pour rétablir votre application, utilisez la fonction SysIconeSuppprime.

Pour plus de détails sur ces fonctions, consultez l’aide en ligne (mot-clé : "SysIconeAjoute").

458
Question Comment installer un raccourci d’une application sur le bureau ?
La fonction CréeRaccourci permet de créer un raccourci d’une application par programmation.

Cette fonction permet de créer aussi bien un raccourci sur le bureau que dans un groupe de pro-
grammes.
Par exemple, pour installer un raccourci sur le bureau :
CréeRaccourci(RaccourciBureau, "Libellé de mon icone", ...
"C:\program Files\Compta\Compa.EXE")
Consultez l'aide en ligne pour la syntaxe détaillée de cette fonction (mot-clé : "Créer, Un raccourci").
Question Comment partager le framework WinDev entre les différentes applications

installées sur un même poste ?
Lors de la création du programme d’installation de l’application, vous avez la possibilité de dire si

votre application partage le Framework WinDev avec les autres applications installées sur le poste.
Dans ce cas, le Framework WinDev sera installé dans le répertoire "C:\Windows\PCS\10.0".
Consultez l'aide en ligne pour la syntaxe détaillée de cette fonction (mot-clé : "Framework").

459
Gestion des fichiers et des disques
Question Comment lister tous les fichiers d’un répertoire ?
La fonction fRep avec l’utilisation de la constante FRFichier permet de lister les fichiers d’un réper-
toire.
Pour une utilisation avancée, la fonction fListeFichier permet de récupérer la liste des fichiers d'un
répertoire ou de plusieurs répertoires en cascade.
Consultez l'aide en ligne de cette fonction (mot-clé : "fListeFichier").
Question Comment connaître le type d’un disque ?
La fonction fDisqueInfo permet de connaître le type d'un disque (réseau, CD ROM, Disquette, …).
Consultez l'aide en ligne de cette fonction (mot-clé : "fDisqueInfo").
Question Comment faire une copie de fichiers ?
La fonction fCopieFichier permet de faire une copie de fichiers.

Consultez l'aide en ligne de cette fonction (mot-clé : "fCopieFichier").
Question Comment créer un répertoire ?
La fonction fRepCree permet de créer un répertoire sur un disque.

Consultez l'aide en ligne pour la syntaxe détaillée de cette fonction (mot-clé : "fRepCrée").
Question Comment lire un fichier texte ?
Deux méthodes s’offrent à vous :

1. Utilisez les fonctions fOuvre, fLitLigne, fFerme. Ces fonctions permettent de lancer un assis-
tant générant le code suivant nécessaire. Exemple :
LigneFichier est une chaîne
NumeroFichier est un entier = fOuvre("C:\MONFICHIER.TXT", ...
FOLecture)
SI NumeroFichier <> -1 ALORS
LigneFichier = fLitLigne(NumeroFichier)
TANTQUE PAS LigneFichier = EOT
Info(LigneFichier)
LigneFichier = fLitLigne(NumeroFichier)

460
FIN
FIN
fFerme(NumeroFichier)
2. Utilisez la fonction fChargeTexte. Exemple :

ContenuFichier est une chaîne
ContenuFichier = fChargeTexte("C:\MONFICHIER.TXT")
Info(ContenuFichier)
Pour plus de détails sur ces fonctions, consultez l’aide en ligne (mot-clé : "Lecture dans un fichier
externe").
Question Est-il possible de crypter ou de décrypter efficacement un fichier ou du texte

avec WinDev ?
Pour permettre l'enregistrement de données confidentielles (numéro de compte, mot de passe, ...),
WinDev dispose d'un ensemble de fonctions de cryptage / décryprage utilisables :
• sur du texte (fonctions Crypte et Décrypte)
• sur un fichier quelconque (fonctions fCrypte et fDécrypte)
Ces fonctions sont disponibles en plus de la possibilité de crypter les fichiers d'une base de don-
nées Hyper File (point abordé dans la leçon “Cryptage de données”, page 197).
Pour plus d'informations, consultez l'exemple "WD Cryptage de données".

461
Tables
Question Comment modifier la clé de parcours d’une table reliée à un fichier ?
La clé de parcours dans un champ table correspond à la rubrique qui sert d'argument de tri pour
les lignes de la table.
4 1.
Pour modifier la clé de parcours d'une table reliée à un fichier :
Faites un clic droit sur la table fichier et sélectionnez "Description".
2. Cliquez sur l'onglet "Contenu".
3. Sélectionnez dans la combo "Rubrique de parcours" la rubrique du fichier qui servira de clé
de parcours.
Notes
En programmation, la clé de parcours peut être modiée grâce à la propriété

..RubriqueParcourue.
Question Comment imprimer le contenu d’une table ?
Le contenu d'un champ Table peut être imprimé à l'aide du bouton "Etat sur table". Ce bouton est

accessible depuis le menu l'éditeur de WinDev. Pour cela :
1. Sélectionnez le champ Table.
2. Cliquez sur le bouton "Etat sur Table" ou sélectionnez "Insertion .. Spécial .. Bouton Etat sur
table" et déplacez la souris dans la fenêtre pour insérer le bouton.
Un état possédant la même structure que la table est créé. Il ne vous reste plus qu'à sauvegarder
l'état et à le tester.
Le code du bouton créé contient les lignes suivantes :

iAperçu(i100)
iImprimeEtat(Etat_Table_NomTABLE)
Question Comment modifier la rubrique mémorisée d’une table reliée à un fichier ?
La rubrique mémorisée dans un champ table fichier correspond à la valeur récupérée dans la table
pour la ligne sélectionnée.
4 1.
Pour modifier la rubrique mémorisée d'une table reliée à un fichier :
Faites un clic droit sur la table fichier et sélectionnez "Description".
2. Cliquez sur l'onglet "Contenu".
3. Sélectionnez dans la combo "Rubrique mémorisée" la rubrique du fichier qui pourra être

462
récupérée.
Astuce
La rubrique mémorisée d'une table peut être utilisée pour relier en cascade deux
tables fichier.
Notes
En programmation, la clé mémorisée peut être modiée grâce à la propriété ..Rubri-

queMémorisée.
Question Comment récupérer le contenu d’une table dans Excel ?
Le contenu d'une table peut être récupéré dans Excel en réalisant la manipulation suivante :
1. En exécution, faites un clic droit dans la table.
2. Sélectionnez l'option "Exporter la table vers Excel".
3. Saisissez un nom de fichier et validez.
Un fichier Excel ayant le nom que vous avez saisi sera créé et contiendra les données de la table.
Ce fichier pourra être ensuite ouvert dans Excel.
Question Comment récupérer le contenu d’une table dans Word ?

Le contenu d'une table peut être récupéré dans Word en réalisant la manipulation suivante :
2. Sélectionnez l'option "Exporter la table vers Word".
3. Saisissez un nom de fichier et validez.
Un fichier Word ayant le nom saisi sera créé et contiendra les données de la table. Ce fichier pourra
être ensuite ouvert dans Word.
Question Comment exporter les données d’une table vers un fichier au format XML ?
Le contenu d'une table peut être exporté dans un fichier au format XML en réalisant la manipula-
tion suivante :
2. Sélectionnez l'option "Exporter la table vers XML".
3. Saisissez un nom de fichier et validez. Un fichier ayant le nom saisi sera créé et contiendra
les données de la table sauvegardé au format XML.

463
Hyper File
Question Comment désactiver une contrainte d’intégrité ?
Les contraintes d'intégrité sont définies dans l'analyse lors de la création des liaisons entre les
fichiers.
Chaque contrainte est nommée. Par défaut, toutes les contraintes sont activées.
La gestion de la désactivation d'une contrainte se fait à l'aide de la fonction HGèreIntégrité. Vous
pouvez utiliser cette fonction avant et après certains traitements spécifiques ou bien l’utiliser dans
le code d’initialisation de vos fenêtres ou projets.
Consultez l'aide en ligne pour la syntaxe détaillée de cette fonction (mot-clé : "Intégrité").
Question Comment gérer la valeur NULL ?
Pour gérer la valeur NULL dans vos fichiers, vous disposez :

• Sous l'éditeur d'analyses :
•d'une option "NULL supporté" dans la description du fichier. Cette option permet de définir
si la gestion du NULL est supportée pour ce fichier. Dans ce cas, il sera possible de gérer
la valeur NULL pour les différentes rubriques du fichier.

•d'une option "Valeur NULL par défaut" pour chaque rubrique de vos fichiers. Cette option
permet de définir la valeur nulle comme valeur par défaut de la rubrique.
• En programmation, de deux propriétés :
NULL Permet de :
• définir la valeur NULL comme valeur par défaut pour une rubrique d'un
fichier lors de sa description dynamique
• associer ou non la valeur NULL à une rubrique d'un fichier
NullSupporté Permet de :
• définir le mode de gestion de la valeur NULL pour un fichier lors de sa des-
cription dynamique.
• connaître le mode de gestion de la valeur NULL d'un fichier
Pour plus de détails, consultez l’aide en ligne (mot-clé : "NULL").
Question Comment gérer une erreur de doublons lors d’une écriture dans un fichier ?
Par défaut, si une erreur de doublons est rencontrée lors d’une écriture dans un fichier (fonctions
HAjoute et HModifie), une fenêtre de gestion des erreurs s’affiche automatiquement. Cette fenêtre
permet à l’utilisateur de modifier les valeurs saisies.
Pour savoir par programmation si une erreur de doublons est survenue et pour la traiter, il suffit de
tester la fonction HErreurDoublon après l’utilisation des fonctions HAjoute et HModifie.

464
Exemple de code :
HModifie(CLIENT)
SI HErreurDoublon() ALORS
Erreur("Impossible de modifier le client",...
"Erreur de doublons")
FIN
Rappel : Le moteur Hyper File propose en standard une gestion automatique des doublons. En cas
d’erreur, une fenêtre est affichée, et l’utilisateur peut corriger sa saisie.
Question Comment gérer une erreur d’intégrité lors d’une écriture ou d’une suppres-
sion dans un fichier ?
Par défaut, si une erreur d’intégrité est rencontrée lors d’une écriture dans un fichier (fonctions
HAjoute et HModifie) ou d’une suppression (HSupprime), une fenêtre de gestion des erreurs s’affi-
che automatiquement.
Pour savoir par programmation si une erreur d’intégrité est survenue et pour la traiter, il suffit de
tester la fonction HErreurIntégrité après l’utilisation des fonctions HAjoute , HModifie, et HSup-
prime.
Exemple de code :
HSupprime(CLIENT)
SI HErreurIntégrité() ALORS
Erreur("Impossible de supprimer le client",...

"Erreur d’intégrité")
FIN
Rappel : Le moteur Hyper File propose en standard une gestion automatique des erreurs d’inté-
grité. En cas d’erreur, une fenêtre est affichée, et l’utilisateur peut corriger sa saisie.
Question Comment remplir un champ Arbre à partir d’un fichier ?
Exemples de code de remplissage d'un champ Arbre à partir d'un fichier :

Algorithme :
// Parcours du fichier
HlitPremier(NomFichier, NomClé)
TANTQUE HEnDehors() = Faux
// Ajout dans l'arbre
ArbreAjoute(NomChampArbre,Racine+TAB+Branche+TAB+Feuille)
HlitSuivant(NomFichier, NomClé)
FIN

465
Exemple 1. On charge des sociétés par ville :

HlitPremier(SOCIETE, VILLE)
ArbreAjoute(ChampArbre,Societe.VILLE+TAB+Societe.NomSoc)
HlitSuivant(SOCIETE,VILLE)
FIN
Exemple 2. On charge les noms de clients par initiales (classement de type agenda) :
HlitPremier(CLIENT, NOMCLI)
ArbreAjoute(ChampArbre,Gauche(Client.NomCli,1)+TAB+Client.Nom-
Cli)
HlitSuivant(CLIENT,NOMCLI)
FIN
Exemple 3. Avec une syntaxe plus courte (utilisation de l'opérateur POUR TOUT) :
POUR TOUT CLIENT SUR NOMCLI

ArbreAjoute(ChampArbre,Gauche(Client.NomCli,1)+TAB+Client.Nom-
Cli)
FIN
Question Comment gérer une clé composée lors d’une recherche ?
Il faut utiliser la fonction HConstruitValClé avant d’amorcer une recherche avec HFiltre ou HLitRe-
cherche.
Exemple :
// Construction de la clé composée
sValRech est une chaîne = HConstruitValClé(CLIENT,NOM_PRENOM, ...
"MOULIN","Françoise")
Pour plus de détails sur la fonction HConstruitValClé, consultez l’aide en ligne (mot-clé :
"HConstruitValClé").

466
Requêtes
Question Comment optimiser la vitesse d’exécution d’une requête ?
L’éditeur de requêtes permet d’optimiser la vitesse d’exécution d’une ou de plusieurs requêtes de

votre projet.
L’optimisation d’une requête repose sur le principe suivant : un assistant détermine les clés com-
posées à modifier et/ou à ajouter dans l’analyse associée au projet.
Pour optimiser la vitesse d’exécution de la requête en cours, sélectionnez l’option "Requête .. Opti-
miser la requête". La fenêtre d’optimisation d’une requête s’affiche et propose les différentes modi-
fications possibles à effectuer dans l’analyse.
Attention : L’ajout d’un nombre important de clés composées dans l’analyse augmente la taille des
fichiers d’index et peut ralentir les accès aux fichiers de données.
Remarque : Cette option est disponible uniquement si les conditions suivantes sont réunies :
• le "Live Data" est activé (option "Projet .. Description du projet .. Live Data"). Pour plus de
détails, consultez l’aide en ligne (mot-clés : "Live Data").
• les fichiers de données sont présents dans le répertoire de test du projet (option "Projet ..
Description du projet .. Fichiers"). Pour plus de détails, consultez l’aide en ligne (mot-clés :
"Tester, Projet").
Question Comment ajouter ou modifier une condition dans une requête ?
4 1.
Pour ajouter ou modifier une condition dans une requête :
Sélectionnez et ouvrez la requête à modifier.
2. Faites un clic droit sur la requête et sélectionnez "Description de la requête".
3. Sélectionnez la rubrique sur laquelle une condition doit être modifiée.
4. Cliquez sur le bouton "Conditions de sélection" et sélectionnez l’option "Modifier la condi-
tion".
Rappel : Lors de la définition d'une condition, vous pouvez faire référence à une valeur (constante
dans la requête) ou à un paramètre (valeur passée en paramètre lors de l'appel à la requête).
Question Comment ajouter ou modifier un tri dans une requête ?
4 1.
Pour ajouter ou modifier un tri dans une requête :
Sélectionnez et ouvrez la requête à modifier.
2. Faites un clic droit sur la requête et sélectionnez "Description de la requête".
3. Faites un clic droit sur la rubrique voulue, sélectionnez "Trier la rubrique ..." et choisissez
l’opération à effectuer.

467
Rappel : Si vous cliquez sur la flèche rouge, vous changez le sens de tri.
Question Comment remplir un champ Arbre à partir d’une requête ?
Algorithme :
// Exécution de la requête
HExécuteRequête(NomRequête, hRequêteDefaut,...)
// Parcours de la requête
HLitPremier(NomRequête)
ArbreAjoute(NomChampArbre, Racine+TAB+Branche+TAB+Feuille)
HLitSuivant(NomRequête)
FIN
Exemple 1. Avec une syntaxe plus courte (utilisation de l'opérateur POUR TOUT) :
HExécuteRequêteSQL (RequêteClient, hRequêteDefaut)
POUR TOUT RequêteClient
ArbreAjoute(ChampArbre,Gauche(RequêteClient.NomCli,1) + ...
TAB + RequêteClient.NomCli)
FIN

Cas particulier d'une requête en langage SQL :
RequêteClient est une source de données
HExécuteRequêteSQL (RequêteClient, hRequêteDefaut,...
"SELECT NomCli FROM CLIENT")
POUR TOUT RequêteClient
ArbreAjoute(ChampArbre,Gauche(RequêteClient.NomCli,1) + ...
TAB + RequêteClient.NomCli)
FIN
Question Comment passer des paramètres à une requête ?
Pour passer des paramètres à une requête paramétrée utilisée dans une fenêtre ou dans un
champ (liste, combo, table ...) , le W-Langage offre deux possibilités :
• soit passer les paramètres directement dans la fonction W-Langage HExécuteRequête
• soit utiliser la notation <Nom de la requête>.<Nom du paramètre> , puis la fonction HExécuteRe-
quête .
1. Utiliser HExécuteRequête pour passer les paramètres à une requête

Syntaxe à utiliser
Lors de l'exécution d'une requête avec la fonction HExécuteRequête , les derniers paramètres pas-
sés à la fonction correspondent aux paramètres de la requête.

468
La syntaxe utilisée est la suivante :

<Résultat> = HExécuteRequête(<Nom de la requête> [, <Connexion>] [, <Mode> [, <Paramètres> [,
...]]])
Attention : Dans ce cas :

• Les valeurs des paramètres de la requête doivent être indiquées dans leur ordre d'initialisation
(visible sous l'éditeur de requêtes). Chaque paramètre doit correspondre au type attendu. Les dif-
férents paramètres sont séparés par une virgule.
• Pour spécifier les paramètres de la requête, il est nécessaire de spécifier le mode d'initialisation
de la requête.
2. Notation <Nom de la requête>.<Nom du paramètre>

Syntaxe à utiliser
Pour passer des paramètres à une requête, il est possible de préciser au moteur Hyper File tous les
paramètres de la requête avant d'exécuter la requête. Cette méthode permet de préciser les diffé-
rents paramètres dans n'importe quel ordre (intéressant pour les requêtes nécessitant de nom-
breux paramètres).
La syntaxe à utiliser est la suivante :
<Nom de la requête>.<Nom du paramètre 1> = <Valeur du paramètre 1>
<Nom de la requête>.<Nom du paramètre 2> = <Valeur du paramètre 2>
...
<Nom de la requête>.<Nom du paramètre N> = <Valeur du paramètre N>
<Résultat> = HExécuteRequête(<Nom de la requête> [, <Connexion>] [, <Mode>])
Attention :
• Le nom du paramètre doit être le nom spécifié lors de la création de la requête sous l'éditeur de
requête. Ce nom doit être différent d'un nom de rubrique.
• Il n'est pas possible d'utiliser d' opérateurs d'indirection ou la compilation dynamique (fonction
Compile ) avec cette syntaxe.
• A chaque exécution de la requête avec la fonction HExécuteRequête , les paramètres sont ré-ini-
tialisés (remis à 0).
• Si au moins un paramètre est spécifié dans la fonction HExécuteRequête , tous les paramètres
spécifiés précédemment seront ignorés.
• La valeur du paramètre peut correspondre à NULL.
• Si un des paramètres n'est pas précisé, la condition correspondante ne sera pas prise en
compte.
Pour plus de détails, consultez l’aide en ligne (mot-clé : "Requête paramétrée, Passer des paramè-
tres à une requête")

469
Impression
Question Comment imprimer au format PDF ?
Le résultat d'une impression peut être re-dirigé à l'écran, sur une imprimante (ou un fax) ou dans un
fichier.
Si vous optez pour la re-direction vers un fichier, le format de ce fichier peut être RTF, ASCII, XML,
HTML ou PDF.
La fonction iAperçu associée au paramètre iPDF permet de re-diriger le résultat d'une impression
dans un fichier au format PDF :
iAperçu(iPDF)
Utilisez la fonction iParamètrePDF pour fixer les options de protection du fichier PDF généré.
Communication
Question Puis-je utiliser des assemblages .NET dans une application WinDev ?
WinDev permet de :

• créer des programmes .NET (ou assemblages .NET) depuis une application WinDev.
Ces assemblages .NET sont directement réalisés à partir des classes WinDev (avec tous les avan-
tages de l’éditeur de code, de l’éditeur de dossier, ...).
• utiliser des assemblages .NET (non créés avec WinDev) dans une application WinDev :
• dans une nouvelle application : il suffit de spécifier l’utilisation des assemblages .NET direc-
tement dans l’assistant de création.
• dans une application existante : il suffit de sélectionner le ou les assemblages .NET à utiliser.
L’assemblage .NET utilisé pourra être manipulé comme toute autre classe WinDev.
Pour intégrer des assemblages .NET dans l’application en cours :

1. Sélectionnez l’option "Atelier .. .NET .. Utiliser un assemblage .NET dans ce projet".
2. Sélectionnez les différents assemblages .NET à intégrer dans l’application en cours.
3. Validez (bouton "OK"). L’utilisation d’un assemblage .NET est identique à l’utilisation d’une
classe WinDev.
Rappel : Les classes sont visibles dans le volet "Projet" et dans le volet "Code".
Remarque : Pour créer et utiliser un assemblage .NET, il est nécessaire de :

• installer le Framework .NET sur le poste en cours.
• régler le niveau de sécurité .NET.
• rendre les DLLs nécessaires à l’exécution de l’assemblage .NET accessibles.
Pour plus de détails sur l’utilisation et la création des assemblages .NET, consultez l’aide en ligne.

470
Question Puis-je envoyer des fax avec WinDev ?
Les envois de documents par Fax sont aujourd'hui indispensables.
WinDev permet de simplifier l'envoi de fax en exploitant les possibilités offertes par le serveur de
fax de Windows (depuis les versions 2000 et XP).
Pour que ce type de manipulation soit le plus simple possible à mettre en oeuvre, WinDev permet
de générer un fax à partir de n'importe quel état.
Il suffit d'indiquer par la fonction iAperçu que l'on souhaite envoyer l’état par fax (paramètre iFax).
Pour que l'envoi de l'état commence, une seule fonction : iImprimeEtat !
Il devient ainsi possible d'envoyer par fax à vos clients, un duplicata de facture en utilisant les états
existants : que de temps gagné !
Les principales fonctions Fax disponibles sont les suivantes :

• FaxConnecte : permet de se connecter à l'ordinateur faisant office de serveur de fax
• FaxEtat : permet de connaître l'état d'envoi d'un fax (envoyé, annulé, en cours de transmis-
sion, etc ...)
• FaxEnvoi : permet d'envoyer un fax à partir d'un fichier texte
Consultez l'exemple "WD Fax" pour plus d'informations sur le fonctionnement de ces fonctions.
Consultez l’aide en ligne (mot-clé : "Fax") pour plus de détails sur l’utilisation de ces fonctions.
Question Est-il possible d'accéder aux données contenues dans mon Palm Pilot ?
WinDev permet d'accéder très simplement aux données suivantes d'un Palm Pilot :
• Carnet d'adresse
• Agenda
• Liste des tâches
• Bloc Notes
Pour plus d'informations, consultez l'exemple "WD Palm" livré avec WinDev ou reportez-vous à l'aide
concernant les fonctions PALM*.
Question Comment récupérer des données provenant de mon PALM ?
L'exemple "WD PALM" livré avec WinDev illustre comment effectuer une synchronisation entre un
programme écrit avec WinDev et un Palm.
Vous trouverez dans l'aide en ligne la syntaxe détaillée des fonctions du W-Langage pour les dialo-
gues avec un Palm (mot-clé : "Palm Pilot, Fonctions W-Langage").

471
Question Comment transférer un fichier par FTP ?
FTP (File Transfert Protocol) est un protocole de transfert de fichiers.

L'exemple "WD Transfert de fichier par FTP" fourni avec WinDev illustre comment effectuer un trans-
fert de fichiers.
Question Comment envoyer un email à une personne ?
L'exemple "WD POP3" livré avec WinDev présente comment envoyer ou recevoir des messages.
Vous pouvez gérer l'envoi et la réception des messages en utilisant les protocoles POP3/SMTP ou
au travers de MAPI4 (Microsoft Exchange).
Question Comment communiquer avec Microsoft Outlook ?
L'exemple "WD Outlook" livré avec WinDev illustre comment piloter Microsoft Outlook depuis une
application écrite avec WinDev.

472
Ports
Question Comment lire un code-barres ?
La lecture d'un code-barres peut s'effectuer suivant 2 méthodes :

1. Si vous utilisez un lecteur de code-barres directement interfacé avec le clavier, vous n'avez
aucun code à écrire avec WinDev. Lors de la lecture du code-barres, la valeur est envoyée direc-
tement au clavier comme si vous aviez saisi le code. Il faut juste être positionné dans un champ
de saisie.
2. Si vous utilisez un lecteur de code-barres connecté sur le port série, vous devez utiliser les
fonctions de gestion des ports série. Les fonctions sOuvre, sLit, sEcrit, sFerme, … permettent
de gérer le dialogue avec un port série.
Question Comment lire les données envoyées par un lecteur de carte magnétique ?
Procédez exactement de la même façon que pour les lecteurs de code-barres.
Question Comment gérer un port série ?

4 Utilisez les fonctions W-Langage sOuvre, sLit, sEcrit, sFerme, …

Vous trouverez dans l'aide en ligne la syntaxe de ces fonctions (mot-clé : "Série (port)").
Question Comment gérer un port parallèle ?
Les fonction de gestion des ports parallèles sont les mêmes que les fonctions de gestion des ports
série.
4 Utilisez les fonctions W-Langage sOuvre, sLit, sEcrit, sFerme, …
Vous trouverez dans l'aide en ligne la syntaxe de ces fonctions (mot-clé : "Série (port)").

473
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.
Nous vous conseillons de consacrer une journée supplémentaire à explorer les différents choix de
menu de WinDev, pour chacun des modules.
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 Win-
Dev. 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 des centaines, voire des
milliers !). WinDev offre de nombreuses possibilités non abordées ou non approfondies dans ce
cours :
• groupware utilisateur
• fonctions sockets, 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.
Nous vous souhaitons de bons développements, avec WinDev 10, AGL n°1 en France !
Conclusion

474
ANNEXE
Glossaire des mots principaux
Un rapide rappel de vocabulaire.
Fenêtre Une fenêtre s'appelle également "boîte de dialogue". Nous utiliserons indifférem-
ment les termes "boîte de dialogue", "fenêtre"; que les puristes veuillent bien nous
en excuser.
Une fenêtre peut également être appelée écran.
Bouton Un bouton (texte ou graphique) est une zone matérialisée par un "rectangle" sur
laquelle on peut cliquer et qui déclenche une action. Dans les barres d'icones, on
parle d'icones plutôt que de boutons. Un bouton s’appelle également un "contrôle".
A propos de l'orthographe du mot icone : on parle de un ou une icone, mais sans "^"
sur le "o" (d'après le dictionnaire "le petit Robert").
Projet Un "projet" est un ensemble de fenêtres, d’états, .... Un projet peut faire appel à une
"analyse" réalisée à l'aide de l'éditeur d'analyses.
Analyse Une "analyse" est un ensemble de fichiers (ou tables) créés dans le but de réaliser
une base de données.
Application Une "application" est un ensemble de programmes plus ou moins liés réalisant une
gestion particulière.
Champ / Rubrique Nous emploierons le terme de "champ" pour les zones de l'écran, et le terme de
"rubrique" pour les zones de fichier. Nous parlerons donc du champ "NOM" (qui se
trouve dans la fenêtre) et de la rubrique "NOM" (qui se trouve dans un fichier); il peut
de plus exister une variable de programme "NOM".
Table Une table est un champ permettant de visualiser le contenu d’un fichier ou d’une
zone mémoire sous forme de tableau. Une table s’appelle également "browse" ou
"feuille de données".
Combo / Le terme "combo" ou "combo box" correspond à une "liste déroulante".
Liste déroulante
Barre de défilement / Une "barre de défilement" sera également appelée "ascenseur".
Ascenseur
Sélecteur / Un "sélecteur" peut parfois être appelé "case d'options".
Case d’options
Interrupteur / Un "interrupteur" peut être aussi appelé "case à cocher".
Case à cocher
Fichier Un fichier est parfois appelé une "table". Nous conserverons le terme "table" pour un
objet permettant de visualiser le contenu d'un fichier ou d'une zone mémoire sous
Annexe
forme d'une table.

Enregistrement Un enregistrement est parfois appelé une ligne. Un enregistrement rassemble plu-
sieurs rubriques provenant d’un fichier.
Rubrique Une rubrique est une zone faisant partie d’un enregistrement.
Langage SQL Le langage SQL est un langage qui permet de manipuler les données contenues
dans des fichiers. C’est à la fois un langage d’interrogation et un langage permettant
les mises à jour des fichiers (ajout, modification, suppression). Ce langage peut être
utilisé dans l’éditeur de requêtes ou par programmation.
Toutefois, il est important de noter qu’il n’est pas nécessaire de connaître le langage
SQL pour utiliser l’éditeur de requêtes.

Windev 10 Guide Autoformation 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

Windev 10 Guide Autoformation PDF

Transféré par

Droits d'auteur :

Formats disponibles

GAF WinDev.BOOK Page 1 Mardi, 11.

juillet 2006 5:42 17

Diffusion interdite sans l’accord écrit de PC SOFT

PARTIE 1 : A LA DÉCOUVERTE DE WINDEV

Avant de commencer ...

PARTIE 2 : VOS PREMIÈRES APPLICATIONS

Leçon 2.1. Votre 1ère application

(c) PC SOFT - Version Express - Diffusion interdite

Gérer la saisie d’un numérique pour faire un calcul.............................................................................. 53

Leçon 2.2. Concepts W-Langage

Leçon 2.3. Chaînes et Numériques

Les monétaires ......................................................................................................................................... 81

Leçon 2.4. Dates et heures

(c) PC SOFT - Version Express - Diffusion interdite

Les heures ...............................................................................................................................................................87

PARTIE 3 : FENÊTRES ET CHAMPS

Leçon 3.2. Manipulations des Champs

Leçon 3.3. Éditeurs de fenêtres et de code

Refactoring (propagation des modifications) .......................................................................................106

Leçon 3.4. Les champs

(c) PC SOFT - Version Express - Diffusion interdite

Type de champ : Liste.............................................................................................................................120

Leçon 3.5. Optimisez vos interfaces

Leçon 3.6. Description des Fenêtres

(c) PC SOFT - Version Express - Diffusion interdite

Leçon 3.7. Applications multilingues

PARTIE 4 : BASES DE DONNÉES ET ANALYSES

Rubriques d’un fichier............................................................................................................................173

Leçon 4.2. Définition d’une analyse

(c) PC SOFT - Version Express - Diffusion interdite

Leçon 4.3. Les fichiers Hyper File

Leçon 4.4. Cryptage de données

Leçon 4.5. Les transactions

Leçon 4.6. La Journalisation

Leçon 4.7. La réplication de données

3. Déclaration des bases abonnées......................................................................................................212

Leçon 4.8. Client / Serveur

(c) PC SOFT - Version Express - Diffusion interdite

Leçon 4.9. Accès Distant

Leçon 4.10. Bases externes

Leçon 4.11. Le réseau

Leçon 4.12. Les triggers

Leçon 4.13. Le RAD Projet

PARTIE 5 : LES REQUÊTES

(c) PC SOFT - Version Express - Diffusion interdite

Leçon 5.2. Requêtes avec comptage

Leçon 5.3. Requêtes Somme

Leçon 5.4. Le langage SQL

Leçon 5.5. Utilisation des Requêtes

PARTIE 6 : LES ÉTATS

Leçon 6.2. Etats statistiques

Leçon 6.3. Etats Tableau Croisé

Présentation ......................................................................................................................................................... 298

Leçon 6.4. Champs spécifiques

(c) PC SOFT - Version Express - Diffusion interdite

Leçon 6.5. Exécution des Etats

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

Leçon 7.2. Gestion de fichiers texte

Leçon 7.3. Imprimer en W-Langage

Leçon 7.4. Dessiner en W-Langage

(c) PC SOFT - Version Express - Diffusion interdite

Leçon 7.5. Les Listes Graphiques

Leçon 7.6. Les indirections