TDF Tech 2009 Support de cours - Source : www.pcsoft-windev ...

TDF Tech 2009 

Support de cours 

TDF TECH 2009 - www.pcsoft.fr - 1

2 - TDF TECH 2009 - www.pcsoft.fr

Le document que vous avez entre les mains n’a 

pas la finalité de remplacer les documentations 

techniques ou commerciales livrées avec WinDev, 

WebDev ou WinDev Mobile. 

Ce document n’est pas un cours d’auto-formation, 

mais uniquement un support “papier” à la présentation 

technique que vous avez suivie. 

Ce document a été réalisé par l’équipe de la LST. 


Sommaire 


Sommaire du support de cours 

1 


4 Sommaire 

TDF Tech 2009 Sommaire du support de cours 

9 Présentation 

10 WinDev 

Présentation rapide de WinDev et de ses fonctionnalités 

12 

WinDev Mobile 

Présentation rapide de WinDev Mobile et de ses fonctionnalités 

14 WebDev 

Présentation rapide de WebDev et de ses fonctionnalités 

16 

17 

18 

20 

23 

24 

26 

29 

PC SOFT à votre service 

• Séminaire de formation, 

• Consulting, 

• Assistance Directe,... 

Les graphiques 

Champs Graphe "donuts" 

Utilisation du champ graphe de WinDev 14 : 

Réalisation d'un graphe "donuts" 

Champs graphes Avancés 

Utilisation avancée des champs graphes 

Gestionnaire de sources 


Fonctionnement, historique, différences de sources, fusion de sources et gestion de branches 

Sécurité et GDS 

Définition de droits et d'une politique de réintégration dans le Gestionnaire de Sources 

Bases de données 

30 HyperFileSQL 

Comment optimiser les accès à une base de données HyperFileSQL 

32 

HyperFileSQL Full-text 

Mise en oeuvre d'index full-text dans une application de gestion de contenu 


35 WinDev 

36 

38 

41 

42 

44 

47 

48 

53 

54 

Champ Calendrier 

Personnalisation du champ calendrier 

Champ Table 

Utilisation de nouveautés du champ table 

La réplication 

Réplication assistée 

Mise en place d'une réplication assistée 

Réplication programmée 

Mise en place d'une réplication programmée 

Mobilité et Base de Données 

Base de données 

Applications Mobiles : base de données embarquée, distante ou mobile ? 

Accès à une base tierce depuis un terminal mobile 

Debug et Optimisation 

Programmation et débogueur 

Fonctions de mise au point et de débogage 

56 Analyseurs 

Optimisation d'une application grâce au logs et à l'analyseur de performances 

59 

60 

62 

66 

Gestion de la qualité 

Tests automatiques 

Mise en place de tests unitaires lors d'un "GO" de fenêtre 

Centres de contrôles 

Suivi de projet et des incidents ou suggestions 

Erreurs d'ihm 

Détecter des problèmes d'IHM non visibles 



Sommaire (SUITE) 


Sommaire du support de cours 

67 WebDev 

68 Référencement 

Optimiser le référencement d'un site WebDev 

74 

Paiement sécurisé 

Mise en place d'un système de paiement sécurisé 

76 Mashup 

Mixer des données HyperFileSQL et des données Google 

78 

81 

WebDev PHP 

Création et déploiement d'un site PHP 

Services Web 

82 SOA 

Réalisation d'une application "SOA" (Services Oriented Architecture) 

84 SAAS 

Réalisation d'une application "SAAS" (Software As A Service) 

87 

Déploiement d’applications 

88 Déploiement 

Choisir le type de déploiement adapté à une application 

91 

92 

93 

94 

Déploiement WebDev 

Personnalisation de la page indiquant la mise à jour du serveur 

Déploiement mobile 

Mise à jour d'une flotte de terminaux mobiles 

Fonctionnalités spécifiques 

Robot de surveillance 

Configurer la surveillance d'une application critique 

96 Databinding 

Deux exemples concrets d'utilisation du DataBinding 

98 

Développement spécifique 

Développer une application WinDev pour une utilisation sur Asus EEE-Top 

100 Géolocalisation 

Géolocaliser une flotte de téléphones mobiles 


I 

II 

IV 

Annexes 

Annexe A 

Quelques commandes du WLangage 

Annexe B 

Les principales touches de raccourci 



Abonnez-vous ! 

L90119 

Tarif modifiable sans préavis 

Bulletin d’abonnement à retourner avec 

votre règlement à : 

PC SOFT 

Lettre du Support Technique 

BP 44 408 

34197 MONTPELLIER Cedex 05 

France 

En cas de paiement par carte bancaire, 

vous pouvez nous faxer votre abonnement 

au : 

+33 (0) 4 67 03 07 87 

Vos Nom & Prénom : ........................................................................... 

Votre Société : .................................................................................. 

Votre Adresse précise : ........................................................................ 

..................................................................................................... 

Code Postal : .............................. Ville : ............................................. 

Pays : ........................................ Tel : ............................................... 

Adresse Email : ................................................................................. 

Je choisis un abonnement “LST PC SOFT” pour : 

FRANCE Métropolitaine 

AUTRE (exp. par avion) 

□ 1 an - 4 N°+ 4 DVD : 159 euros HT; 190,16 euros TTC 

□ 2 ans - 8 N°+ 8 DVD : 279 euros HT ; 333,68 euros TTC 

□ 1 an - 4 N°+ 4 DVD : 175 euros HT 

□ 2 ans - 8 N°+ 8 DVD : 299 euros HT 

À partir du numéro : .............. 

Note : une facture acquittée est systématiquement 

adressée. 

Ci joint mon règlement de : ............. Euros TTC 

□ Je règle par chèque. J’autorise PC SOFT à débiter sur ma carte VISA/MasterCard 

la somme de : ..................... Euros 

□ Je règle par Carte Bancaire. 

Cryptogramme : 

□□□ 

Numéro complet de la carte : la carte expire : mois année 

□□□□□□□□□□□□□□□□ □□ □□□□ 

Signature obligatoire du détenteur de la carte : 

Nom du détenteur de la carte : 

.......................................................... 



Présentation 


WinDev 

Présentation rapide de WinDev et de ses 

fonctionnalités 

* accès natif optionnel, ** accès natif 

inclus. 

Les outils 

Des outils facilitant le développement 

sont également fournis (WDMAP, WDOUTIL, 

WDSQL, ...) ainsi que de nombreux exemples 

et assistants réutilisables. 

Des centres de contrôle permettent la 

gestion du cycle de vie de vos applications 

ainsi que leur administration. 

Une aide en ligne vous guide tout au long 

du développement de votre application. 

Cette aide inclut également une aide à la 

correction d’erreurs. 

Les différents éditeurs seront utilisés, 

depuis la définition d’une analyse jusqu’à 

l’installation, en passant par toutes les 

phases du développement (création des 

fenêtres, des états, des traitements...), 

sans oublier les sauvegardes. 

WinDev est un AGL (Atelier de Génie 

Logiciel). 

L’éditeur d’IHM de 

WinDev 

WinDev permet de développer simplement 

tout type d’applications Windows dans les 

domaines de la gestion, de l’industrie, du 

médical, etc. 

Les applications développées peuvent 

inclure l’accès à des bases de données. 

WinDev propose un puissant moteur de 

base de données : HyperFileSQL. 

Il est conseillé d’utiliser HyperFileSQL pour 

vos applications afin d’obtenir les meilleures 

performances dans vos traitements de 

fichiers. Une version HyperFileSQL Client/ 

Serveur est aussi disponible. 

L’environnement de développement intégré 

de WinDev se compose de différents 

éditeurs : 

· Un éditeur de projet permettant de visualiser 

et d’agir sur le graphe du projet. 

· Un éditeur d’analyses permettant l’accès à 

tout type de base de données (HyperFileSQL, 

HyperFileSQL Client/Serveur, xBase, MySQL, 

AS/400*, Oracle*, SQL Server*, Access**, 

ODBC, OLE DB, ... ) 

· Un éditeur UML permettant une modélisation 

objet de vos données et traitements. 

· Un éditeur d’IHM avec correcteur d’interface 

en temps réel. 

· Un éditeur de code évolué (avec assistants, 

vérification du code saisi, coloration 

syntaxique, aide contextuelle …) incluant 

un puissant débogueur. 

· Un éditeur de requêtes pour les sélections 

d’enregistrements dans les fichiers. 

· Un éditeur d’états. 

· Un éditeur d’aide permettant de générer 

des fichiers d’aide au format CHM. 

· Un éditeur d’installation. 

· Un éditeur de dossier technique reprenant 

intégralement toutes les informations 

techniques de votre projet. 

Les bases de 

données 

Le moteur HyperFileSQL sera utilisé pour 

les fichiers de données des applications. 

La base de données HyperFileSQL est disponible 

en mode Classic ou Client/Serveur 

et est librement diffusable avec les applications 

WinDev. 

L’utilisation d’autres moteurs de base de 

données est également possible sur le même 

principe. 


TDF TECH 2009 - www.pcsoft.fr - 11 

Présentation

WinDev Mobile 

Présentation rapide de WinDev Mobile et de 

ses fonctionnalités 

• Un éditeur d’installation. 

• Un éditeur de dossier technique reprenant 




sont également fournis (WDREGISTRE, 

WDCAPTURE, WDSYNCHRO, ...) ainsi 

que de nombreux exemples et assistants 

réutilisables. 

Des centres de contrôle permettent la 

gestion du cycle de vie de vos applications 

ainsi que leur administration. 

Une aide en ligne vous guide tout au long 

du développement de votre application. 

Cette aide inclut également une aide à la 

correction d’erreurs. 

Le moteur HyperFileSQL Mobile sera utilisé 

pour les fichiers de données de l’application. 

WinDev Mobile permet de développer 

simplement tout type d’applications 

destinées à être utilisées sur 

un Pocket PC, un SmartPhone, et 

la plupart des terminaux mobiles 

(Symbol, Psion, ...). 

Présentation 

Les applications développées peuvent 

inclure l’accès à des bases de données. 

WinDev Mobile inclut un puissant moteur de 

base de données : HyperFileSQL Mobile. 

Il est conseillé d’utiliser HyperFileSQL pour 

vos applications afin d’obtenir les meilleures 

performances dans vos traitements de 

fichiers. Une version HyperFileSQL Client/ 

Serveur est aussi disponible. 

WinDev Mobile permet également d’accéder 

aux bases de données CEDB, bases de 

données standards des Pockets PC. 

Environnement 

L’environnement de développement intégré 

de WinDev Mobile se compose de différents 

éditeurs : 

• Un éditeur de projets permettant de 

visualiser et d’agir sur le graphe du projet. 

• Un éditeur d’analyses permettant 

l’accès à tout type de base de données 

(HyperFileSQL, HyperFileSQL Client/ 

Serveur). 

• Un éditeur UML permettant une modélisation 

objet de vos données et traitements. 

• Un éditeur d’IHM avec correcteur d’interface 

en temps réel 

• Un éditeur de code évolué (avec assistants, 


syntaxique, aide contextuelle) incluant 

un puissant débogueur 

• Un éditeur de requêtes pour les sélections 


• Un éditeur d’états. 

L’utilisation d’autres moteurs de base de 

données est également possible sur le même 

principe. 


TDF TECH 2009 - www.pcsoft.fr - 13 

Présentation

WebDev 

Présentation rapide de WebDev et de ses 

fonctionnalités 

la définition d’une analyse jusqu’à l’installation, 

en passant par toutes les phases 

du développement (création de pages, 

traitements, états, etc.), sans oublier les 

sauvegardes. 

Les Concepts 

Internet 

WebDev est un AGL (Atelier de Génie 

Logiciel) orienté développement de 

sites Intranet et Internet. 

WebDev permet de développer tout 

type de sites dynamiques incluant 

l’accès à des bases de données. 

Il permet aussi de développer des 

sites semi-dynamiques et statiques. 

Présentation de 

WebDev 

WebDev est composé de différents éditeurs 

: 

• Un éditeur de projet permettant de visualiser 

et d’agir sur le graphe du projet. 

• Un éditeur de pages. 

• Un éditeur d’analyses permettant 

l’accès à tout type de base de données 

(HyperFileSQL, HyperFileSQL Client/ 

Serveur, MySQL, xBase, AS/400*, Oracle*, 

SQL Server*, Access**, OLE DB, etc.). 

• Un éditeur de code évolué (avec assistants, 


syntaxique, aide contextuelle …) incluant 

un puissant débogueur. 

• Un éditeur de styles incluant police, 

couleur, position, etc. 

• Un éditeur de requêtes pour les sélections 


• Un éditeur d’états. 

• Un éditeur de dossier technique reprenant 



• Un éditeur d’installation. 

* accès natif optionnel, ** accès natif 

inclus 

L’éditeur d’installation assure la mise en 

place des sites créés, ainsi que leur maintenance. 

Cet outil permet de réaliser une 

installation sur le serveur via FTP ou par 

média physique (CD, Zip, etc.). 


sont également fournis (WDMAP, WDOUTIL, 

WDSQL, etc.) ainsi que de nombreux exemples 

et assistants réutilisables. 

Les principaux éditeurs sont utilisés, depuis 

Les différents services de l’Internet 

Le terme Internet regroupe plusieurs services 

d’utilisation différente : 

• FTP (File Transfer Protocol) est un service 

permettant de transférer des fichiers 

d’un ordinateur vers un autre à travers 

Internet. 

• SMTP (Simple Mail Transfer Protocol) 

permet d’envoyer des messages ou mails 

à un utilisateur défini. Chaque utilisateur 

doit disposer d’une adresse Email qui lui 

sert de boîte aux lettres. 

• HTTP (HyperText Transfer Protocol). HTTP 

est un protocole de niveau application qui 

est utilisé pour le transfert de pages sur 

Internet. 

Chacun de ces services nécessite un gestionnaire 

de services installé sur un serveur : 

• Le gestionnaire de services FTP gère l’hébergement 

des fichiers, les droits d’utilisation 

des fichiers et la réponse aux demandes 

en provenance des autres postes. 

• Le gestionnaire de services SMTP prend en 

charge les demandes d’envoi de messages et 

le routage vers les serveurs POP (réception 

des messages) concernés. 

• Le gestionnaire Web (www) permet 

l’hébergement des pages et répond aux 

demandes de consultation de la part des 

postes client. 

Le Web en détail 

Les pages Web sont visualisées sur un poste 

par l’intermédiaire d’un navigateur Web 

(Internet Explorer, FireFox, Opera, etc.). 

Le navigateur interprète le contenu des 

fichiers au format HTML décrivant les pages. 

On parle de pages HTML. 

WebDev génère automatiquement le code 


HTML et JavaScript. 

Il est possible d’afficher directement une 

page dans un navigateur en tapant son URL 

dans la zone adresse du navigateur. 

L’URL (Uniform Resource Locator) correspond 

au chemin d’accès de la page sur le 

serveur qui l’héberge, par exemple : 

http://www.monserveur.com/page3.htm 

Si l’URL ne correspond pas à une adresse 

valide, une erreur de connexion est retournée 

dans l’écran du navigateur. 

Si l’URL est valide, la page demandée s’affiche 

dans le navigateur. L’utilisateur peut 

alors déclencher une action en cliquant 

sur un lien ou un bouton. La requête correspondante 

est alors envoyée au serveur 

qui l’analyse. 

Le lien permet de lancer le chargement 

d’une autre page ou bien de lancer une 

application Web. 

Site statique, 

semi-dynamique ou 

dynamique ? 

· Le site statique est composé de pages 

conçues à l’avance de manière définitive. 

Dans ce cas, le contenu des pages n’évoluera 

pas dynamiquement en fonction d’un 

choix de l’utilisateur. 

• Un site semi-dynamique est un site statique 

composé de pages conçues à l’avance 

mais enrichies par une base de données. 

Dans ce cas, le contenu des pages n’évoluera 

pas dynamiquement en fonction d’un 

choix de l’utilisateur. L’un des meilleurs 

exemples est un catalogue de pièces détachées. 

• Un site dynamique est constitué de pages 

enrichies de données provenant d’une base 

de données. Il est nécessaire d’exécuter 

des traitements d’accès aux données sur 

le serveur permettant de constituer la 

page. 

Fonctionnement 

d’une application 

WebDev 

Une application WebDev hébergée sur un 

serveur peut être exécutée en appelant une 

URL particulière depuis un navigateur. Par 

exemple : http://www.monserveur.com/ 

wd140awp/wd140awp.exe/CONNECT/ 

monappli 

Le lanceur de WebDev ‘wd140awp.exe’ 

permet d’exécuter l’application sur le 

serveur grâce au serveur d’application 

wd140session.exe. 

Le serveur d’application construit 

dynamiquement la première page de l’application 

et l’envoie au navigateur par 

l’intermédiaire du serveur Web. 

Principe de programmation 

WebDev 

Le débit entre le serveur Internet et le poste 

client est plus lent qu’avec un réseau local 

classique. Les échanges de données entre 

le poste client et le serveur doivent donc 

être réduits pour que l’application puisse 

s’exécuter sans ralentissement. WebDev 

permet de différencier les traitements 

exécutés sur le serveur et les traitements 

exécutés sur le poste client. 

1. Les traitements sur le serveur 

Les traitements exécutés sur le serveur sont 

les traitements principaux de l’application. 

Ils concernent la gestion de la base de 

données (HyperFileSQL et HyperFileSQL 

Client/Serveur, xBase, AS/400, Oracle, SQL 

Server, Access, OLE DB, etc.), les traitements 

de calcul. 

Ces traitements sont écrits en 

WLangage. 

2. Les traitements sur le poste client 

Les traitements exécutés sur le poste client 

sont les traitements de contrôle de saisie, 

de vérification qui ne nécessitent pas d’accéder 

au serveur. Ces traitements utilisent 

uniquement les informations contenues 

dans la page. Ces traitements peuvent être 

écrits en JavaScript ou WLangage. Dans ce 

dernier cas, WebDev se charge de convertir 

automatiquement le code WLangage en 

JavaScript pour qu’il puisse être exécuté 

par le navigateur. 

3. Administrateur WebDev 

L’administrateur WebDev est un exécutable 

installé sur le serveur. 

L’administrateur permet de configurer 

le nombre de connexions autorisées en 

même temps pour le serveur, par site, par 

utilisateur. Il permet aussi de fixer le temps 

maximum d’exécution d’une requête et 

le temps limite pour la déconnexion des 

utilisateurs inactifs. 

L’administrateur peut à tout moment afficher 

la liste des utilisateurs connectés 

au site. 

Présentation 

WebDev permet de développer des sites 

dynamiques composés de pages, de traitements 

serveur (accès aux bases de données, 

calculs, etc.) et de traitements exécutés 

par le navigateur (contrôles, traitements 

répétitifs, etc.). 

WebDev permet aussi de développer des 

sites statiques et semi-dynamiques. 


PC SOFT à votre service 

• Séminaire de formation, 

• Consulting, 

• Assistance Directe,... 

N’hésitez pas à nous 

contacter: un assistanat 

est toujours rentable pour 

vos développements. 

Profitez de l’expérience d’un ingénieur 

de PC SOFT sur votre site 

Un consultant PC SOFT peut être délégué 

chez vous, pour une durée de 1 à 5 jours. 

Un ingénieur PC SOFT connaissant à la 

fois votre domaine et les outils que vous 

utilisez. 

L’ingénieur PC SOFT répond directement 

à vos questions, travaille sur votre projet 

réel et votre configuration réelle. Vous 

obtenez les réponses précises qui vous font 

gagner un temps précieux, et vous assurent 

des bonnes orientations technologiques et 

méthodologiques. 

Notre conseil ? Commandez 1 jour de consulting 

pour 100 jours de développement. 

Et, chaque année, prenez l’habitude de 

faire venir (juste 2 jours) chez vous un 

ingénieur PC SOFT, pour profiter d’une 

expertise de toutes les nouveautés. 

Sur votre projet, dans vos locaux, en votre 

présence, l’ingénieur PC SOFT valide l’analyse, 

vous montre des nouveautés utiles 

dans votre cas de figure, vous propose 

des optimisations de votre code, valide 

vos modes d’utilisation, ... 

Vous serez ravi de l’efficacité de son intervention 

! Budgétez d’ores et déjà la prochaine 

intervention ! 

Un assistanat vous fait gagner des 

journées de développement! 

Quelques exemples de sujets traités : 

• Simplification du code et mise en place de 

nouvelles techniques : HyperFileSQL Client/ 

Serveur, Socket, Web Services, Composants, 

Patchs, Configurations, … 

• Transformation de modules développés 

avec WinDev en Services Web. 

• Optimisation de traitements avant la 

recette de l’application, validation d’analyse 

avant de débuter une application. 

Formation 

Séminaires de formation pour 

WinDev et WebDev 

PC SOFT organise à Paris, chaque semaine, 

des séminaires de formation à WinDev et 

WebDev, de différents niveaux : Prise en 

main, Perfectionnement, Expert, Client/ 

Serveur, ... 

Ces séminaires, animés par des ingénieurs 

PC SOFT expérimentés, permettent de 

découvrir et de maîtriser WinDev, WebDev 

et WinDev Mobile selon un plan efficace. 

Consultez le calendrier des séminaires (le 

détail des stages et les contenus pédagogiques 

sont disponibles sur notre site 

Web : www.pcsoft.fr), vous trouverez LA 

formation adaptée à votre expérience et 

à votre besoin. 

Suivre une formation organisée par PC SOFT 

est toujours rentable : c’est se donner les 

moyens de maîtriser WinDev et WebDev 

dans les meilleurs délais, ou d’en découvrir 

la face cachée, encore plus puissante ! 

Inscrivez-vous vite! 

Ces séminaires peuvent également être 

organisés dans vos locaux, en France et 

à l’étranger. 

Le montant de ces formations est déductible 

du “1,5 % Formation”. 

Consulting 

Assistance Directe 

Un complément efficace du 

Support Technique Gratuit 

Tout projet important ou stratégique doit 

bénéficier d’une “Assistance Directe” ! 

L’Assistance Directe permet d’une part 

de bénéficier d’un contact téléphonique 

immédiat avec un ingénieur spécialisé, et 

d’autre part de choisir les sujets à traiter, 

et ce pour une durée que vous définissez 

vous-même. Cela vous permet de résoudre 

immédiatement les sujets qui vous posent 

problème. 

Le contact téléphonique est garanti sous 

8 heures ouvrables, ce qui vous permet 

une meilleure efficacité. 

Ce service est disponible sur abonnement. 

Contactez le service commercial pour 

plus d’informations (Fabrice CHAMBON 

au 04.67.032.032). 





Champs Graphe "donuts" 

Utilisation du champ graphe de WinDev 14 : 

Réalisation d'un graphe "donuts" 

Type de graphe 

L'assistant de création d'un champ graphe propose 

de choisir le type de graphe à générer : 

il est possible de réaliser des graphes de type 

secteurs, donuts, hémicycles, histogrammes, 

courbes, aires, radars, boursiers, ... 

Il suffit de choisir le type "donuts", puis de 

passer au plan suivant. 

Paramètres du graphe 

Il est ensuite possible de modifier les paramètres 

généraux du graphe qui sera créé : 

• Titre du graphe et sa position (par exemple 

"Répartition du chiffre d'affaires par type 

de séjour"), 

• Affichage ou non d'une légende et sa position, 

• Apparence générale du graphe. 

WinDev propose de nouveaux types de graphes : les 

donuts, les radars, les hémicycles, ... 

WinDev met à votre disposition de nombreux types de 

graphes, ce qui vous permet de toujours représenter 

au mieux les données à afficher. 

Projet d'illustration 

Le projet utilisé pour illustrer ce sujet est "WD Champs" (présent 

sur le DVD). 

Création d'un graphe "donuts" 

Ce sujet présente la création d'un graphe de type "donuts" qui 

représente la répartition du chiffre d'affaires par type de séjour. 

Ce graphe se base sur une requête existante de l'exemple "WD 

Champs" : REQ_CAParTypeDeSéjour. 

La création d'un graphe "donuts" s'effectue très simplement, comme 

pour tout type de graphe, à l'aide de l'assistant de création de 

graphe. Pour afficher cet assistant, il suffit de créer un nouveau 

champ de type graphe dans une fenêtre : 

• soit à partir du menu "Insertion .. Champ .. Graphe", 

• soit par le bouton adéquat. 

Séries de données 

Dans un premier temps, il convient de définir 

la source des étiquettes de catégories. 

Les étiquettes de catégories définissent les 

libellés qui seront affichés dans la légende 

du graphe. Pour ce graphe, les étiquettes de 

catégories correspondent au type de séjour et seront remplies par 

une rubrique de la requête. 

Pour cela, il suffit d'indiquer que : 

• la source correspond au "Parcours d'un fichier ou d'une 

requête". 

• les données correspondent à la rubrique TypeSéjour de la requête 

REQ_CAParTypeDeSéjour. 

Ensuite, il faut indiquer la série de données. Les séries de données 

définissent les valeurs du graphe. Selon le type du graphe, il est 

possible de définir une ou plusieurs séries : 

• pour les graphes de type "donuts", hémicycle, secteur : une seule 

série de données doit être définie. 

• pour les autres types de graphes, il est possible de définir autant 

de séries que nécessaire. 

Pour ce graphe, les données correspondent au chiffre d'affaires et 

seront donc remplies par la rubrique CA de la requête. 

Pour cela, il suffit de : 

• ajouter une série en cliquant sur le bouton "+" situé à droite 

de la table. 

• indiquer que la source correspond au "Parcours d'un fichier ou 

d'une requête". 

• indiquer que les données correspondent à la rubrique CA de la 

requête REQ_CAParTypeDeSéjour. 


Sur les graphes en exécution, les utilisateurs disposent de 

FAA (Fonctionnalités Automatiques de l'Application) accessibles 

par un simple clic droit sur le graphe. 

Il est 

possible, 

par exemple, de modifier : 

• le type de graphe. Dans notre exemple, il est possible par 

exemple d'afficher un graphe de type hémicycle ou secteur en 

remplacement du "donuts". 

• les polices du graphe, 

• la légende (visibilité, position), 

• le quadrillage, 

• la position des axes, 

• etc. 


Il suffit enfin de donner un nom au champ graphe qui va être créé 

et de valider l'assistant. Le graphe est automatiquement ajouté 

dans la fenêtre. 

Personnalisation du graphe 

Bien sûr, le graphe est entièrement personnalisable. 

En version 14, il est possible de déplacer, directement dans l'éditeur, 

la légende, le titre du graphe et le graphe lui-même. 

Chaque type de graphe dispose de paramètres spécifiques qu'il 

est possible de modifier. 

Pour un graphe de type donuts par exemple, il est possible de 

modifier : 

• la taille du trou. 

• l'excentrage des parts du donuts. 

Ces paramètres sont accessibles dans la fenêtre de description du 

graphe "donuts", onglet "Général". 

FAA sur les graphes 


Champs graphes Avancés 

Utilisation avancée des champs graphes 

Il est ensuite nécessaire de 

paramétrer le mode 9 images 

pour l'image indiquée. 

Le mode 9 images permet de 

définir la façon dont l'image 

va être redimensionnée. 

Le principe est simple : 

l'image est découpée en 9 

zones distinctes. Pour chaque 

zone, il suffit de choisir 

le comportement à adopter 

lors du redimensionnement 

de l'image : la zone peut être 

répétée, étirée, laissée tel 

qu'elle, rendue invisible. 

Dans notre exemple, la tête 

du palmier doit rester telle 

qu'elle : elle ne doit être ni 

répétée, ni étirée. Il suffit 

donc de la définir comme 

marge haute. 

Le reste du palmier doit lui 

être étiré. 

En plus de nouveaux types de graphes, WinDev propose 

également des nouveautés sur des types de 

graphes existants : personnalisation des images d'un 

histogramme, zoom sur une courbe, ... 



sur le DVD). 

Notre conseil 

Pour obtenir une image qui 

soit propre, bien détourée, lors de l'exécution, il est conseillé 

d'utiliser : 

• soit une image au format BMP, en indiquant comme couleur de 

transparence la couleur du coin haut gauche. 

• soit une image au format PNG, qui inclue directement la transparence 

souhaitée. 

Personnalisation des images d'un 

histogramme 

WinDev permet de personnaliser les graphes de type histogrammes. 

Il est possible par exemple de remplacer les barres habituelles 

par des images différentes. 

Pour utiliser une image en guise de barre, il suffit de : 

• ouvrir la fenêtre de description du champ graphe. Cette fenêtre 

peut être ouverte soit par le menu contextuel, soit par double-clic 

sur le champ graphe, soit par le raccourci "Alt + Entrée", 

• afficher l'onglet "Séries", 

• saisir le chemin de l'image souhaitée dans "images des barres 

d'histogrammes". 



Activation du zoom dans un graphe 

courbe 

L'utilisateur peut maintenant zoomer sur une partie d'un graphe 

courbe. Cela permet d'observer de façon plus précise les variations 

d'une courbe. 

Le zoom sur une partie du graphe s'effectue très simplement : 

• soit en modifiant les ascenseurs horizontal et vertical pour 

réduire la zone d'affichage. 

• soit en dessinant un rectangle de sélection directement sur le 

graphe. 

• soit en utilisant une combinaison de touche : Ctrl + "+" pour 

zoomer, Ctrl + "-" pour dézoomer. 

• soit en utilisant la roulette de la souris en maintenant le bouton 

Ctrl enfoncé. 

Graphe dans un Etat 

Tous les types de graphes disponibles dans les fenêtres sont également 

disponibles dans les états. 

Pour insérer un champ graphe dans un état, plusieurs choix sont 

possibles : 

• créer directement un état sur graphe, ou état sur table et 

graphe 

• insérer un champ graphe par le menu "Insertion .. Nouveau 

champ .. Graphe", ou par le bouton adéquat de la barre d'outils 

contextuelle. 

Tout comme les champs graphes d'une fenêtre, les données d'un 

graphe dans un état peuvent provenir d'un fichier de données, 

d'une requête, ou de la programmation. 

Pour permettre aux utilisateurs de zoomer sur une partie du 

graphe, il suffit de : 

• ouvrir la fenêtre de description du graphe, onglet "Détails", 

• cocher l'interrupteur "Autoriser le zoom horizontal" et/ou l'interrupteur 

"Autoriser le zoom vertical". 


Plus d'informations sur ces sujets ? 

En formation 

"WinDev Perfectionnement" 

Dans WinDev 

Exemples didactiques "WD Grapheur Java", 

"WD Graphe", "WD Graphe Boursier" 

Dans WebDev 

Exemples didactiques "WW_WebBourse", 

"WW_TraceCourbe", "WW_Camembert" 






Fonctionnement, historique, différences 

de sources, fusion de sources et gestion de 

branches 

L'utilisation du GDS (Gestionnaire De Sources) offre des 

avantages non négligeables pour tout développement 

de projets WinDev, WebDev ou WinDev Mobile. Et ce, 

que le projet soit réalisé par un seul développeur ou 

une équipe de développement. 

Principe de fonctionnement 

La version de référence des projets est située sur un serveur : 

c'est la base de source. Chaque développeur possède une copie 

locale des projets sur lesquels il travaille. 

Lorsque le développeur a besoin de modifier un élément, il extrait 

l'élément, c'est-à-dire qu'il indique à la base de source que cet 

élément est en cours de modification. 

Le développeur fait ses modifications et lorsqu'il a terminé, il 

réintègre l'élément, c’est-à-dire qu'il remet l'élément modifié 

dans la base de source.Les autres développeurs peuvent alors se 

mettre à jour. 

Cette fonctionnalité permet aux développeurs de voir les différences 

de sources entre deux versions d'un élément (une fenêtre, 

une classe, etc.) et si nécessaire de fusionner les codes sources 

pour reporter une correction par exemple. 

Historique 

Pour cela, il suffit d'accéder à l'historique de l'élément accessible 

via le menu "GDS .. Historique de l'élément". Depuis cette fenêtre, 

le développeur a accès à toutes les versions de l'élément depuis sa 

création. À côté de chaque version se trouve un commentaire. Ces 

commentaires, ce sont les commentaires saisis par les développeurs 

lors de la réintégration de l'élément dans le GDS. 

Différences et fusion de sources 

De nombreux outils sont livrés en standard avec le GDS pour 

effectuer des opérations avancées. Un des outils indispensables 

est la gestion des différences de sources. 


Note : 

Il est possible d'imposer la saisie d'un commentaire en définissant 

une "politique de réintégration" depuis l'explorateur du GDS. Cette 

fonctionnalité est décrite plus loin dans cet article. 

Récupération et fusion 

Depuis l'historique, il est possible de récupérer l'élément tel qu'il 

était à une date antérieure. 

Pour récupérer un élément il y a plusieurs possibilités : 

• récupérer tout l'élément. C’est-à-dire l'élément complet (une 

fenêtre par exemple). 

Pour récupérer l'élément complet, il suffit de sélectionner la version 

à récupérer et de cliquer sur le bouton "Obtenir". 

Cette option n'est intéressante que si l'élément n'a pas beaucoup 

évolué. En effet, si des évolutions ont été faites, elles sont 

écrasées. 

• récupérer uniquement le bout de code concerné. Il suffit de 

cliquer sur le bouton "Comparer". 

Dans ce cas, WinDev calcule les différences entre la version actuelle 

de l'élément et la version sélectionnée dans l'historique. 

Le développeur visualise alors toutes les différences entre les deux 

éléments (différences de code ou d'interface). 

Créer une branche a posteriori 

La création d'une branche s'effectue par l'option "Créer une branche" 

du menu "GDS .. Branches". 

Mais si la branche a été "oubliée", ce n'est pas grave : il n'est 

jamais trop tard pour créer une branche, puisqu'il est possible de 

le faire a posteriori via l'historique du projet. 

Dans ce cas, il suffit de : 

• Ouvrir l'historique du projet par le menu "GDS .. Gestion du 

projet .. Historique du projet". L'historique du projet permet de 

voir toutes les versions du projet qui ont été réintégrées. 

• Sélectionner la version servant pour faire la branche 

• Valider en cliquant sur "Créer une branche". 

• Nommer la branche (par exemple "Version Cliente"). 

• Indiquer le répertoire pour cette branche sur le poste de développement. 

• Indiquer le répertoire pour cette branche dans la base de 

source. 


Lors d'un clic sur l'icône en forme d'oeil, le développeur visualise 

les deux codes en parallèle : 

• à gauche le code de l'élément actuel, 

• à droite le code de l'élément dans l'historique. 

Il est alors possible de récupérer une partie du code grâce aux 

flèches situés au niveau de chaque différence détectée. 

Gestion des branches 

Autre fonctionnalité du GDS, la gestion des branches. Une branche 

sert à faire évoluer N versions d'un même projet en parallèle. 

Par exemple, lorsque vous déployez une version en clientèle, pour 

garder les sources de la version déployée au cas où vous devriez 

faire des corrections, il est intéressant de créer une branche. En 

parallèle, sur le tronc commun, les développeurs peuvent continuer 

les développements pour la version future. 

Mais la gestion des branches permet également de gérer des 

versions différentes par client. 

En effet, l'avantage des branches avec le GDS, c'est que le 

développeur bénéficie du report assisté des modifications d'une 

branche à une autre. 

Cette nouvelle branche peut maintenant évoluer en parallèle 

du "tronc commun" ! C’est-à-dire que si des corrections sont 

nécessaires dans la version en clientèle, le développeur peut les 

effectuer sereinement sur la branche. 

Report des évolutions. 

Pendant le cycle de vie du projet, il restera à récupérer les 

corrections et les évolutions développées dans le tronc commun. 

Cette opération est réalisée depuis le menu "Branches..Récupérer 

des modifications depuis une branche". 

Il est possible de récupérer toutes les modifications effectuées 

sur un élément ou seulement une partie. 


Sécurité et GDS 

Définition de droits et d'une politique 

de réintégration dans le Gestionnaire de 

Sources 

Un gestionnaire de sources est un élément sensible : 

il contient les sources mais également des comptes, 

des mots de passe, etc. 

Il est donc important que l'accès y soit contrôlé. WinDev 

permet de sécuriser l'accès aux éléments contenus 

dans un projet au travers de deux fonctionnalités : 

• la gestion des droits. 

• la définition de politique de réintégration. 

La gestion des droits 

Les droits peuvent se définir sur un répertoire, c’est-à-dire sur un 

ou plusieurs projets, ou sur des éléments particuliers : fenêtre, 

état, requête, image, etc… 

Pour définir les droits sur une base de sources, il suffit de lancer 

l'Administrateur du GDS (disponible depuis le menu "GDS" de 

WinDev, WebDev ou WinDev Mobile). 

Lors de la sélection d'un répertoire de l'arborescence du GDS (répertoire 

d'un projet ou répertoire autre), il est possible d'accéder à la 

gestion des droits pour ce répertoire depuis le menu contextuel en 

sélectionnant l'option "Propriétés", puis l'onglet "Droits". 

En cliquant sur le bouton "Ajouter", il est possible de définir les 

droits pour ce répertoire et ses sous-répertoires. 

Notre Conseil 

Pour une sécurité optimale, nous vous conseillons d'utiliser le GDS 

en mode Client/Serveur. 

Type de droits 

Les droits sont séparés en trois groupes : 

• les droits de lecture 

• les droits d'écriture 

• le droit de modifier les droits 

Dans les droits d'écriture, un nouveau découpage est disponible 

: 

• extraire et réintégrer un élément 

• ajouter un élément 

• renommer un élément 

• supprimer un élément 

• supprimer définitivement un élément. 

La liste des utilisateurs et des groupes d'utilisateurs est automatiquement 

gérée par le GDS en fonction de son type : 

• Pour un GDS utilisant un serveur HyperFileSQL Client/Serveur, 

il s'agit des utilisateurs et des groupes d'utilisateurs du serveur 

HyperFileSQL. 

• Pour un GDS utilisant une base de données HyperFileSQL Classic, 

il s'agit des utilisateurs et des groupes d'utilisateurs des Centres 

de Contrôle. 

Suppression ou Suppression définitive ? 

Lors de la suppression d'un élément, le GDS demande de choisir 

entre une suppression et une suppression définitive. En effet, la 

suppression "normale" ne fait qu'archiver l'élément. 

C’est-à-dire qu'il n'apparaît plus ni dans le projet ni dans le 

répertoire du GDS, mais il apparaît encore dans l'onglet “Éléments 

supprimés”. 


L'historique de l'élément est alors conservé, ce qui permet de le 

restaurer en cas de fausse manipulation. 

En revanche, la suppression définitive supprime l'élément et son 

historique : l'élément ne pourra pas être restauré et son historique 

est perdu. La suppression définitive est donc une opération 

spécifique très "dangereuse". 

Droits sur un élément 

Il est également possible de définir des droits spécifiques sur un 

élément, une fenêtre par exemple. 

Il est ainsi possible de donner des droits sur un élément d'un projet 

(un élément partagé par exemple), sans pour autant donner 

des droits sur un projet complet. Ce type de définition de droits 

peut être notamment utile lors de l'intégration des nouveaux 

développeurs ou de stagiaires. 

Pour modifier les droits sur un élément, la définition des droits 

s'effectue également depuis le menu contextuel en sélectionnant 

cette fois l'élément. 

Par défaut, un élément hérite des droits du répertoire parent, 

mais il est possible de définir un droit spécifique à cet élément 

en cochant l'option "Droits spécifiques". 

La définition des droits se fait alors sur le même principe que la 

définition des droits sur un répertoire, les droits "locaux" étant 

prioritaires sur les droits des niveaux supérieurs. 

Comme pour la définition de droits "windows" sur un répertoire, 

il est conseillé de donner un minimum de droits à la racine du 

Gestionnaire De Source et d'ajouter au cas par cas, les droits en 

écriture par groupe d'utilisateurs. 

Note : Il est tout à fait possible de définir un utilisateur "invité", 

membre du groupe "utilisateur du GDS" au niveau du serveur 

HyperFileSQL, mais ne disposant que de droits en lecture sur 

l'ensemble des projets. 

Important : Les utilisateurs et les groupes ont des droits sur le 

serveur HyperFileSQL lui-même. Il est donc important d'utiliser le 

groupe d'utilisateurs "Utilisateurs du GDS" ou de limiter les droits 

accordés (par exemple, il est inutile et dangereux qu'un utilisateur 

du GDS dispose de droits pour arrêter le serveur HyperFileSQL). 

Politique de réintégration 

Une politique de réintégration est un ensemble de règles qui 

doivent être respectées pour pouvoir réintégrer un élément dans 

le GDS. 

Par exemple, il est possible de décider que chaque développeur 

doit faire au moins un Go de l’élément qu’il a modifié avant de 

le réintégrer dans le GDS. 

Une politique de réintégration se définit soit : 

• dans WinDev par le menu "GDS .. Politique de réintégration" 

• dans l’administrateur du GDS. 

Dans le cas ci-dessus, ce qui a été défini pour ce projet, c’est que 

tous les éléments réintégrés ne doivent contenir : 

• aucune erreur, 

• aucun warning, 

• et que le projet ait été lancé au moins 1 fois. 

Un peu de souplesse... 

Il est possible d'utiliser la politique de réintégration juste comme 

un garde-fou, par exemple pour prévenir le développeur qu’il n’a 

pas fait Go, mais sans le bloquer. Dans ce cas, il suffit d'activer la 

case "ces règles peuvent être ignorées" . 

Cette possibilité doit être utilisée à bon escient car définir une politique 

de réintégration est un gage de qualité des applications. 

Notre astuce 

Il est possible de partager une même politique de réintégration 

entre plusieurs projets : 

• soit en partageant dans le GDS le fichier "PolitiqueDeRéintégration. 

gds" . 

Ce fichier est situé à la racine du projet dans le GDS. 

• soit directement en plaçant ce fichier dans le répertoire parent 

de vos projets, dans le GDS. 


Dans ce cas, un nouveau projet créé dans ce répertoire héritera 

automatiquement de cette politique de réintégration. 

Note : 

Pensez à définir des droits sur ce fichier "PolitiqueDeRéintégration. 

gds", il ne doit être modifiable que par le chef de projet. 



L90119 




PC SOFT 


BP 44 408 


France 



au : 

+33 (0) 4 67 03 07 87 

Vos Nom & Prénom : ........................................................................... 

Votre Société : .................................................................................. 


..................................................................................................... 


Pays : ........................................ Tel : ............................................... 

Adresse Email : ................................................................................. 










adressée. 






□□□ 


□□□□□□□□□□□□□□□□ □□ □□□□ 



.......................................................... 





hyperfilesql 

Comment optimiser les accès à 

une base de données HyperFileSQL 

HyperFileSQL est la base de données SQL livrée en 

standard avec WinDev, WebDev, et WinDev Mobile. 

Cette base est disponible en mode classique et en 

mode Client/Serveur. 

En version 14, des statistiques avancées sur l'utilisation 

des serveurs HyperFileSQL sont disponibles et permettent 

d'évaluer les traitements et requêtes à optimiser. 

Ce sujet présente les différents moyens d'optimiser les 

accès et traitements sur un serveur HyperFileSQL. 

Logs et Statistiques 

Les statistiques sur l'utilisation des serveurs sont accessibles dans le 

Centre de Contrôle HyperFileSQL. Il suffit de sélectionner la base 

de données souhaitée et d'accéder à l'onglet "Logs et Statistiques". 

Depuis cet onglet, il est possible d'accéder aux logs du serveur et 

aux statistiques d'activités. 

Logs du serveur 

Les logs du serveur contiennent des informations sur les appels 

au serveur, c’est-à-dire sur les requêtes envoyées par les applications. 

Les logs vont permettre de monitorer les applications qui utilisent 

un serveur HyperFileSQL. Par exemple, il est possible de détecter 

des requêtes qui sont exécutées un nombre anormal de fois, des 

requêtes qui sont longues, ... 

Statistiques d'activités 

Les statistiques d'activité permettent d'avoir des informations 

sur la machine serveur HyperFileSQL. Par exemple la quantité 

d'informations envoyée par le réseau, la quantité d'information 

lue sur le disque,... 

Les statistiques d'activités permettent de voir si le serveur est 

correctement dimensionné pour supporter les charges qui lui sont 

demandées : est-ce que la carte réseau est assez rapide, est-ce 

que les disques sont assez rapides, ... 

Activation 

L'activation des logs et des statistiques d'activités se paramètre dans 

l'onglet "Configuration" du Centre de Contrôle HyperFileSQL. 

Pour activer les logs, il suffit de : 

• sélectionner "Logs", 

• cocher la case "Activer l'enregistrement des appels au serveur 

dans le fichier de log". Avec cette option, tous les appels au serveur 

sont enregistrés avec la fonction qui a effectué l'appel (par 

exemple, un HExécuteRequête ou un HLitRecherche). 

Il est également possible d'enregistrer tous les paramètres des 

appels pour avoir un log encore plus détaillé. Par exemple, 

pour savoir quelle requête a été exécutée, les paramètres de la 

recherche, ... 

Pour activer les statistiques d'activités, il suffit de : 

• sélectionner "Statistiques d'activités", 

• cocher "Activer les statistiques d'activités du serveur". 

Remarque : 

Pour que les modifications soient prises en compte, il est nécessaire 

de cliquer sur le bouton "Appliquer". 

Une fois les logs d'exécution activés, il est possible d'afficher : 

• les requêtes les plus utilisées, 

• les requêtes les plus longues, 

• les appels de fonctions les plus longs, 

• les applications les plus consommatrices, 

• tous les logs. 

Il suffit de sélectionner l'information à afficher et la plage de date 

souhaitée, puis de cliquer sur le bouton "Afficher". 

Optimisation des requêtes 

À l’aide des logs du serveur HyperFileSQL, il est possible de détecter 

les requêtes qui sont très utilisées et les requêtes qui prennent 

du temps. Ces requêtes doivent être optimisées. 

Pour optimiser une requête, WinDev dispose de l'optimiseur de 

requêtes, accessible via le menu "Projet .. Performances et améliorations 

.. Optimiser les requêtes du projet". 


L'optimiseur de requêtes permet en quelques clics de voir s'il 

manque des clés dans les différents fichiers de données d'une 

base pour optimiser l'exécution des requêtes. 

Il suffit de sélectionner les requêtes à vérifier, et de cliquer sur 

le bouton "Lancer l'analyse de performance". WinDev affiche 

alors les clés à ajouter aux fichiers de données pour optimiser 

les requêtes. 

Si des clés manquantes ont été détectées, il suffit de cliquer sur 

le bouton "Appliquer toutes les modifications" pour que WinDev 

crée automatiquement les clés nécessaires. 

Il suffit enfin de regénérer l'analyse avec modification automatique 

des fichiers. 

Remarque : 

Lorsqu'une requête est créée, WinDev effectue automatiquement 

cette analyse de performance. Si une optimisation est possible, 

une AAD (Aide Au Développement) sera affichée dans l'éditeur 

de requêtes. 

Optimisation des accès 

WinDev, WebDev et WinDev Mobile permettent de manipuler des 

données HyperFileSQL de plusieurs manières : 

• par le code WLangage, avec les fonctions Hxxx, les POUR 

TOUT, ... 

• par des requêtes, qu'elles soient définies sous l'éditeur ou saisies 

directement en SQL. 

Selon les cas d'utilisation, il est préférable d'utiliser l'une ou 

l'autre des manières. 

En mode classique avec une base locale ou réseau 

: 

• Pour une recherche unitaire, par exemple rechercher un enregistrement 

précis, il est conseillé d'utiliser les fonctions Hxxx. 

• Pour une recherche qui doit récupérer plusieurs enregistrements, 

il est possible d'utiliser indifféremment les ordres Hxxx, les POUR 

TOUT ou les requêtes. 

En mode Client/Serveur : 

• Pour une recherche unitaire, il est conseillé d'utiliser les fonctions 

Hxxx. 

• Pour une recherche multiple, il est conseillé de privilégier les 

requêtes. 

En effet, en mode Client/Serveur, c'est le transit des informations 

sur le réseau qui prend du temps. 

Avec l'utilisation des requêtes, seul un aller-retour sur le réseau 

est effectué : l'envoi de la requête à exécuter et la récupération 

des résultats. 

Les requêtes présentent également l'avantage de remplacer de 

nombreuses lignes de code. Par exemple, une simple requête 

permet de remplacer deux boucles imbriquées; le code sera plus 

lisible et plus rapide. 

Utilisation de procédures stockées 

Les procédures stockées sont des procédures écrites en WLangage 

qui s'exécutent directement sur le serveur de base de données. Ces 

procédures permettent d'optimiser la vitesse de traitements. En 

effet, comme tous les accès à la base de données sont effectués 

depuis le serveur, aucune information ne transite par le réseau. 

Les procédures stockées sont particulièrement adaptées aux 

traitements qui ne nécessitent pas l'intervention de l'utilisateur, 

par exemple des traitements statistiques. 

Création de procédures stockées 

Pour créer une procédure stockée, il suffit de faire un clic-droit 

dans le treeview de l'analyse et de choisir l'option "Nouvelle collection 

de procédure". 

Pour créer une nouvelle procédure dans cette collection, il suffit 

de faire clic droit, option "nouvelle procédure". 

Les procédures stockées sont codées en WLangage, dans l'éditeur 

de code de WinDev. 

Remarque : 

• Si des requêtes sont utilisées dans des procédures stockées, il 

est nécessaire de les ajouter à l'analyse en tant que "Requêtes 

stockées". 

• Les contextes (variables globales, contexte HyperFileSQL) ne 

sont pas partagés entre l'application et les procédures stockées. 

Une procédure stockée n'a pas la moindre information sur le projet 

et inversement. 

Déploiement des procédures stockées 

Pour mettre des procédures stockées sur le serveur, il est possible 

: 

• soit de lancer la modification automatique. En effet, la mise 

à jour auto ne fait pas QUE mettre à jour les fichiers. Elle met 

également à jour les contraintes d'intégrité, les procédures et 

les requêtes stockées. 

• soit de ne mettre à jour que les procédures stockées. Pour cela, 

il suffit de faire un clic droit dans le treeview de l'analyse, et de 

choisir "Mettre à jour les éléments stockés". 

Remarque : 

Pour appeler une procédure stockée depuis un projet, il suffit 

d'utiliser la fonction HExécuteProcédure, avec en paramètre : 

• le nom de la connexion vers le serveur qui doit exécuter la 

procédure, 

• le nom de la procédure à exécuter, 

• les paramètres à passer à la procédure stockée. 

Compression de trames 

En mode Client/Serveur, le transfert réseau prend du temps. 

HyperFileSQL Client/Serveur dispose de la compression de trames : 

les paquets de données qui circulent entre les applications et le 

serveur sont compressés. Le volume de données qui transite est 

donc moins important et les données circulent plus rapidement. 

Pour activer la compression des trames, il suffit de : 

• utiliser la propriété ..Compression sur la connexion en 

WLangage. 

• cocher la case "Compresser les données" dans la description de 

la connexion de l'analyse. 

Remarque : 

Cette compression de trames n'est à utiliser que sur des réseaux 

lents : Internet, GPRS, ... Sur un réseau très rapide, le temps passé 

à compresser et à décompresser les trames peut être plus important 

que le temps de transfert de la trame non compressée. 



HyperFileSql Full-text 

Mise en œuvre d'index full-text dans une 

application de gestion de contenu 

La recherche full-text de HyperFileSQL permet de rechercher 

un mot ou une expression contenue dans des 

rubriques de type texte ou mémo. 

Il est ainsi possible de mettre en place rapidement un 

"moteur de recherche" dans une application WinDev, 

WebDev ou WinDev Mobile. 

Pour bénéficier de cette fonctionnalité, le serveur 

HyperFileSQL doit être en version 14. 

Cette fonctionnalité est disponible sur les bases de 

données Classic ou Client/Serveur. 

Définition d'un index full-text 

Dans l'analyse du projet se trouve un fichier "Document". Ce fichier 

contient plusieurs rubriques : 

• l'utilisateur qui a créé ce document, 

• la date de création, 

• le format du document, 

• le document en lui même (contenu binaire), 

• le contenu du document au format texte. 

Pour indexer complètement le contenu, et obtenir des résultats 

complets, un index full-text a été défini. Cet index est basé sur 

le titre, le contenu au format texte et le nom du fichier. 

Pour créer un index full-text, il suffit de : 

• cliquer sur le bouton "Créer un Index Full-text" dans la fenêtre 

de description d'un fichier. 

• choisir les rubriques qui vont composer cet index full-text. 

Ensuite, il est possible de spécifier différentes options d'indexation 

: 

• la taille minimale des mots qui doivent être indexés, 

• la gestion des balises RTF, 

• la gestion des balises HTML, 

• la gestion de la casse et de l'accentuation. 

Cet index full-text est automatiquement rempli par HyperFileSQL au 

moment de l'ajout ou de la modification d'un enregistrement. 


Le projet utilisé pour illustrer ce sujet est "WD GestionContenu" 

(présent sur le DVD). Ce projet est une application de gestion de 

contenu : elle permet de stocker le contenu de documents électroniques 

(PDF, Emails, etc.). Le contenu de chaque document est 

indexé pour ensuite être recherché très simplement. 

Ce projet exploite le composant "Extraction", détaillée dans la 

LST 75. Ce composant permet d'extraire le contenu texte de 

fichiers classiques (PDF, DocX, XLSX, etc.). Reportez-vous à cette 

LST pour plus de détail sur le fonctionnement et l'utilisation de 

ce composant. 


Recherche par index full-text 

Pour rechercher des enregistrements dans la base de données à 

partir d'un index full-text, il suffit d'utiliser une requête. Dans 

l'exemple, il s'agit de la requête REQ_RECHERCHEDOCUMENT_ 

FULLTEXT. 

Dans la description de la requête, il suffit d'ajouter la rubrique index 

full-text qui a été définie dans l'analyse. Il suffit alors d'indiquer 

la valeur de recherche, soit une valeur fixe, soit un paramètre 

de requête. Il est enfin possible de trier les résultats par ordre 

de pertinence. En effet, pour chaque enregistrement trouvé, la 

recherche associe un indice de pertinence 

Il suffit de lui donner en paramètre : 

• le nom du fichier 

• les pages que l'on souhaite extraire 

• le mot de passe d'ouverture du PDF si besoin. 

Pour les autres documents, l'exemple "WD GestionContenu" 

utilise un composant livré dans la LST 75 : le composant 

"ExtractionTexte". 

Ce composant permet d'extraire le texte brut des fichiers DOCX, 

OpenOffice Writer, Word, PDF, ... 


Ensuite, pour effectuer la recherche, il suffit d'exécuter la requête 

comme n'importe quelle autre requête. 

Indexation de document. 

HyperFileSQL gère automatiquement l'indexation des textes HTML 

et RTF, sans indexer les balises. 

Pour le format PDF, WinDev dispose en standard de la fonction 

PDFVersTexte qui permet de convertir un fichier PDF en texte 

brut. 

// Récupération du contenu texte 

// d'un fichier PDF 

sTexte = PDFVersTexte(… 

"C:\Mes documents\MonFichier.pdf") 



En formation 

"HyperFileSQL Client/Serveur" 

Dans la LST 75 

p18-19 : Comment le Faire ? Configuration 

avancée d'un serveur HyperFileSQL 

p12-13 : Indexation full-text et composant 

"ExtractionTexte" 



WinDev 


CHAMP Calendrier 

Personnalisation du champ calendrier 

Le calendrier peut également être activé 

par programmation avec la propriété 

BoutonCalendrier du WLangage. 

// Active le bouton calendrier 

du champ 

SAI_SaisieDate.. 

BoutonCalendrier = Vrai 

Utilisation de la 

FAA du champ 

date 

Si le développeur n'a pas pensé à activer 

le calendrier sur un champ date, l'utilisateur 

peut le faire lui-même. Il suffit, 

lorsque l'application est en exécution, 

de faire un clic droit sur le champ date 

et de choisir l'option "Calendrier". Cette 

fonctionnalité est une des nouvelles 

FAA, Fonctionnalité Automatique des 

Applications. 

La version 14 propose un nouveau type de champ 

avancé : le champ "Calendrier". 

Ce champ est disponible pour WinDev 14, WebDev 14 

et WinDev Mobile 14. 

Ce sujet présente la mise en place et la personnalisation 

d'un calendrier. 



sur le DVD). 

Activation du calendrier sur un 

champ date 

Le calendrier peut être mis en place très simplement sur un champ 

de type date existant. 

Pour activer le calendrier, il suffit de cocher l'option "Afficher un 

bouton calendrier" dans la description du champ. 

L'utilisateur peut alors sélectionner la date directement dans 

le calendrier, par simple clic sur le bouton situé à droite du 

champ. 

Personnalisation du champ 

Calendrier 

La personnalisation d'un champ calendrier est simple et s'effectue 

comme pour n'importe quel autre champ de WinDev : il suffit de 

paramétrer des styles. 

Pour personnaliser un calendrier, il suffit de cliquer sur le bouton 

"Editer le calendrier" dans la fenêtre de description du champ 

date souhaité. 

Onglet "Détail" 

Dans l'onglet "Détail", il est possible de paramétrer : 

• le premier jour de la semaine (par défaut, il s'agit du lundi). 

• le format d'affichage du mois. Ce format peut évidemment être 

défini pour chaque langue du projet. 

• la visibilité et le libellé du bouton "Aujourd'hui". 

Onglet "Style" 

L'onglet "Style" permet de personnaliser le style à proprement 

parlé du calendrier : couleurs, images, polices, etc. 

La gestion du style d’un calendrier est un peu particulière puisqu’elle 

est basée sur le principe d’héritage et de surcharge. 


WinDev 

Cela signifie que la définition d'un style pour un 

élément donné est prioritaire sur le style défini 

par défaut. 

Pour définir le style global du calendrier, il suffit 

de modifier les différents styles présents de la 

fenêtre en modifiant du style par défaut à l'aperçu 

final, dans cet ordre. 

Par exemple, pour personnaliser le calendrier 

avec un fond bleu, le samedi et dimanche en gris 

et le jour sélectionné en gras, cela se déroule 

en 3 étapes. 

Il convient d'abord d'appliquer le fond bleu au 

calendrier. Il suffit pour cela de : 

• sélectionner le "Style par défaut". 

• choisir une couleur de fond; par exemple pour un fond bleu 

clair : D7E7FF. 

• choisir la couleur "Transparent" pour les lignes paires et impaires. 

Ensuite, pour griser les jours du week-end, il suffit de : 

• sélectionner le style "Samedi". 

• choisir une couleur de fond et de police de couleur grise ("Gris 

clair" par exemple). 

• appliquer les mêmes couleurs au style "Dimanche". 

Enfin, pour mettre en évidence le jour sélectionné, il suffit de : 

• sélectionner le style "Sélection". 

• indiquer que la police est grasse. 

Évidemment, une fois le style défini, il est possible de l'enregistrer 

pour le réutiliser dans les autres calendriers de l'application. 

Pour enregistrer le style du calendrier, il suffit de cliquer sur le 

bouton "Ajouter" de l'option "Ajouter ce style au projet". 

Manipulation d'un champ 

calendrier 

Il est également possible de créer un champ calendrier directement 

dans la fenêtre, indépendamment d’un champ date. 

Ce champ calendrier peut également être personnalisé sur le même 

principe qu'un calendrier associé à un champ date. 

Par exemple, il est possible de modifier la bulle d'aide affichée 

au survol d'un jour donné : 

// Affiche une bulle personnalisée 

// pour le 2 mai 2009 

CAL_MonCalendrier["20090502"]..Bulle = … 

"Anniversaire de Melle Cokilyne" 

Le champ calendrier dispose de différents événements (pcode) 

pour lesquels un traitement spécifique peut être défini : 

• affichage d'un mois, 

• sélection d'un jour, 

• clic sur le bouton aujourd'hui. 

Le WLangage dispose également des familles de fonctions 

CalendrierXXX et JoursFériéXXX pour manipuler un calendrier 

par programmation : 

• CalendrierOuvre, CalendrierSelectPlus, etc. 

• JourFériéAjoute, JourFériéSupprimeTout, etc. 

// Ajoute le jour de Pâques comme férié 

JourFériéAjoute(jfJourDePâques) 

// Ajoute le 16 Mars comme jour férié 

JourFériéAjoute("1603") 

Les différentes options du calendrier peuvent être paramétrées 

par programmation. 


Champ Table 

Utilisation de nouveautés du champ table 

de la barre d'outils, soit par le menu 

"Insertion .. Champ .. Table". 

Si la table doit afficher des enregistrements 

(table fichier), il est nécessaire 

de paramétrer cette table comme étant 

une table de type "fichier mémoire". 

En effet, pour que WinDev puisse organiser 

les enregistrements selon les 

ruptures, les données doivent être 

en mémoire. 

Rappel sur les tables fichiers 

mémoires 

Une table fichier mémoire permet de 

bénéficier de : 

• tous les avantages des tables mémoires 

: le tri sur toutes les colonnes, la 

recherche avec la loupe, ... 

• tous les avantages des tables 

fichiers : la modification en cascade 

par exemple. 

En version 14, le champ table offre de nouvelles possibilités 

: ruptures, colonne conteneur, ... 

Ces fonctionnalités ajoutent encore plus à l'ergonomie 

et donc au confort de l'utilisateur. 

Ce sujet présente la mise en place de rupture et de 

conteneur sur un champ table. 



sur le DVD). 

Création d'une table avec rupture 

Une rupture permet de regrouper des données qui possèdent 

un ou plusieurs éléments communs. Par exemple, il est possible 

de regrouper les clients par pays et par ville ou des commandes 

par date. 

Les ruptures sont disponibles sur les champs tables, les champs 

zones répétées et les états. 

Pour créer une table contenant une ou plusieurs ruptures, il suffit 

simplement de créer une table, soit par le bouton "Champ Table" 

Pour utiliser une table fichier mémoire, 

il suffit de : 

• spécifier "Fichier chargé en 

mémoire" 

• renseigner un nombre maximum d'enregistrement affiché. En 

effet, si le fichier contient 10 millions d'enregistrements, tous 

ne pourront pas être affichés. Il est conseillé de filtrer les enregistrements 

qui vont être affichés, dans un souci de confort pour 

l'utilisateur final. 

Définition d'une rupture 

La définition d'une rupture sur table est effectuée dans la description 

de la table, dans l'onglet "Contenu". 

Il suffit de cliquer sur le bouton "Éditer les ruptures" : la fenêtre de 

gestion des ruptures s'affiche. Dans cette fenêtre est affiché : 

• la liste des ruptures possibles. Cette liste correspond aux différentes 

ruptures considérées comme valides. 

• la liste des ruptures définies pour la table. 

Pour ajouter une rupture à la table, il suffit : 

• soit de double cliquer sur la rupture voulue dans la liste des 

ruptures possibles. 

• soit de sélectionner la rupture voulue et de cliquer sur le bouton 

"Ajouter une rupture". 


Pour supprimer une rupture, il suffit : 

• soit de double cliquer sur la rupture dans la liste des ruptures 

définies. 

• soit de sélectionner la rupture à supprimer et de cliquer sur le 

bouton "Supprimer la rupture sélectionnée". 

Remarque : 

Il est important de ne jamais supprimer une colonne qui est source 

d'une rupture. Si la colonne ne doit pas être affichée, il suffit de 

la rendre invisible. 

Personnalisation d'une rupture 

Par défaut, les utilisateurs peuvent enrouler/dérouler les ruptures. 

Cette fonctionnalité peut être désactivée. 

Pour désactiver le bouton enroulé/déroulé, il suffit de décocher 

l'option "Ruptures avec bouton enroulé/déroulé" dans la description 

de la table (onglet "Détails"). 

Il est possible d'ajouter une image de fond à la rupture, pour 

la mettre plus en avant par rapport aux lignes de la table. Pour 

cela il suffit de : 

• ouvrir la fenêtre de description de la rupture, onglet "Style". 

• choisir une image comme cadre pour la rupture. 

De la même manière, il est possible de personnaliser le bas de 

rupture. 

Pour ajouter des champs dans une colonne conteneur, il suffit 

simplement de faire un Drag and Drop d'un champ depuis la barre 

d'outils ou de rubriques depuis le treeview de l'analyse. Une fois 

les champs ajoutés dans la colonne conteneur, il est possible de 

définir un champ principal de ce conteneur. C'est sur ce champ 

que seront effectuées les recherches, les tris, les filtres, .... 

FAA sur les tables 

Sur les champs tables (avec ou sans ruptures), les utilisateurs 

bénéficient des FAA (Fonctionnalités Automatiques de l'Application). 

Les utilisateurs peuvent : 

• ajouter des calculs de somme, de moyenne,etc. sur les colonnes 

de table. 

• générer un graphe sur les données. 

• exporter les données vers Word, XML, Open Office, Excel. 

• effectuer des tris, sur une ou plusieurs colonnes. 

• rechercher des éléments. 

• choisir les colonnes à afficher. 

• mettre en place des filtres. 

WinDev 

Si une rupture permet de regrouper des éléments, il peut être 

judicieux d'afficher le critère de regroupement au sein même de 

la rupture, par exemple en utilisant un champ libellé. 

Pour que ce champ affiche automatiquement le critère de la 

rupture à chaque itération de la rupture, il suffit de le lier à la 

rubrique qui définit la rupture. 

Enrouler / Dérouler par programmation 

Si l'utilisateur peut enrouler et dérouler les ruptures grâce au 

bouton de la rupture, il est également possible d'effectuer ces 

opérations par programmation. 

Il suffit d'utiliser les fonctions WLangage TableEnroule/ 

TableEnrouleTout et TableDéroule/TableDérouleTout 

// Enroule toutes les ruptures 

TableEnrouleTout(TABLE_SEJOURS) 

// Enroule la première ligne de rupture 

TableEnroule(TABLE_SEJOURS, 1) 

Colonne de type Conteneur 

Une colonne de type conteneur permet d'inclure, dans une seule et 

même colonne, différents champs de différents types. Il est ainsi 

possible de regrouper dans une seule colonne des informations qui 

auraient été affichées dans plusieurs colonnes. La lisibilité s'en 

retrouve ainsi améliorée. 

La création d'une colonne Conteneur s'effectue exactement de 

la même façon que pour une colonne d'un autre type : il suffit 

simplement d'indiquer Conteneur en type. 

Notre astuce 

Par défaut, la loupe de recherche présente dans les colonnes de 

table effectue une recherche de type "Commence par". 

Il est possible de spécifier que la loupe doit faire une recherche 

de type "Contient". Il suffit pour cela d'utiliser la propriété 

..ModeLoupe sur la colonne de table et d'affecter la constante 

filtreContient. 

// Définit une recherche de type "contient" 

TABLE_SEJOURS.COL_Titre..ModeLoupe = … 

filtreContient 

Remarque : 

Tous les types de recherche peuvent ainsi être définis par défaut : 

filtreCommencePar, filtreTerminePar, filtreContient, filtre- 

NeContientPas, etc. 



En formation 

"WinDev Perfectionnement" 

Dans WinDev 

Exemple didactique "WD Tables Ruptures" 

Exemple complet "CRM" 

Dans WebDev 

Exemple complet "Rewali" 





Réplication assistée 

Mise en place d'une réplication assistée 

Que ce soit entre un matériel nomade avec base 

embarquée et une base de données au siège, 

que l’on veuille répliquer 2 bases HyperFileSQL 

ou une base HyperFileSQL avec un autre type 

de base, il est conseillé d’utiliser la réplication 

universelle assistée. 

Réplication universelle 

assistée 

Cette réplication s’effectue via l’éditeur de réplication 

de WinDev. Cet outil est accessible par le 

menu "Outils .. Gestionnaire de réplication .. 

RéplicEdit". 

La réplication permet de synchroniser plusieurs bases 

de données qui évoluent en parallèle. 

Ces bases doivent bien sûr avoir des structures identiques. 

WinDev vous permet de réaliser facilement des réplications 

entre plusieurs bases de données. 

Exemple associé 

Pour tester les différentes manipulations décrites dans ce sujet, 

il est possible d'utiliser le projet "CRM" livré en standard avec 

WinDev, ou tout autre projet contenant une analyse. 

Méthodes de réplications 

Pour définir une réplication avec WinDev, il est possible de : 

• définir la réplication par programmation avec les fonctions 

WLangage ReplicaXXX. 

• définir la réplication via l’éditeur de réplication de WinDev. 

Ces 2 types de réplication sont des réplications "universelles", ou 

"hétérogènes". 

C'est-à-dire que la réplication peut s’effectuer entre des bases 

HyperFileSQL ou entre des bases HyperFileSQL et des bases tierces : 

Oracle, SQL Server, ... 

Description de la réplication 

L'éditeur de réplication est pour l'instant vierge, 

il faut commencer par créer une nouvelle réplication, 

c'est-à-dire indiquer les caractéristiques 

de la réplication : 

• Un nom pour la réplication, par exemple 

"Réplication CRM". 

• Une description (facultative). 

• L'analyse du projet contenant les fichiers de la base de données 

à répliquer. 

• Les options de la réplication. 

Options de la réplication 

Il existe de nombreux modes de réplication, les options de réplication 

permettent de définir rapidement celui concerné : 

• La réplication est-elle mono-directionnelle (donc une extraction 

en lecture de la base) ou bi-directionnelle (les modifications sur 

le réplica seront reportées dans la base maître) ? 

• Comment sont gérés les conflits de réplication ? Par défaut, 

c'est la modification la plus récente qui est prioritaire, mais il est 

possible de vouloir un fonctionnement différent. 

Fichiers à répliquer 

Une fois les options de réplication définies, il faut définir les 

fichiers à répliquer. Les fichiers peuvent être en HyperFileSQL, 

Oracle, MySQL, SQL Server, AS 400, Progress, … 

Pour chaque fichier répliqué (par le bouton "Ajouter"), il est 

possible d'indiquer si le fichier doit être répliqué entièrement 

ou partiellement. 

Prenons par exemple, un fichier "Client". Il peut ne pas être nécessaire 

d'avoir l'ensemble des clients sur une base répliquée, notamment 

s'il s'agit d'une base locale pour un collaborateur itinérant. Il 



est alors possible de filtrer les enregistrements du fichier "Client" 

à répliquer. Par exemple les clients d'un département donné. 

Pour définir un filtre, il faut utiliser l'option "Filtrer les enregistrements" 

et définir à l'aide de l'assistant les conditions de sélection 

du filtre. Pour reprendre l'exemple des clients d'un département, 

le filtre sera alors de la forme "Code_Postal commence par '34'". 

Note : il est possible d'indiquer les conditions du filtre de façon 

paramétrée en ne spécifiant pas une valeur mais un paramètre 

grâce au bouton "Nouveau paramètre". 

Fichiers reliés 

Une fois les différents fichiers à répliquer sélectionnés, la liste des 

fichiers apparaît dans la table principale de l'éditeur de réplication 

avec une marque "répliqué" (c'est le cas du fichier "Client" dans 

notre exemple). 

Mais d'autres fichiers sont également apparus, comme le fichier 

"Commande" toujours dans notre exemple. 

En fait, tous les fichiers reliés aux fichiers sélectionnés dans la 

liste des fichiers à répliquer sont apparus. 

Et tous les fichiers reliés sont alors marqués en "non répliqués" 

(l'icone de réplication est en gris). 

Bien entendu, pour que l'application fonctionne sur la base répliquée, 

certains de ces fichiers sont nécessaires : avoir le fichier 

"Client" sans les commandes associées peut ne pas être utile ... 

Dans ce cas, il est possible d'inclure les fichiers liés dans la réplication 

grâce au menu contextuel (clic droit) par l'option "Inclure 

dans la réplication". 

Et automatiquement l’assistant de réplication ne récupérera que 

les commandes des clients sélectionnés dans la réplication. Il est 

alors possible de définir des filtres supplémentaires, pour n'avoir 

qu'une partie des commandes du client (par exemple les commandes 

de l'année en cours). Le filtrage s'effectue de la même façon que 

pour le fichier "Client". 

Et ainsi de suite 

Une fois le fichier "Commande" ajouté à la réplication, le fichier 

"LignesCde" apparaît automatiquement. 

De même, il est alors possible de répliquer les lignes de commandes 

reliées aux commandes. 

etc, etc. 

Notre astuce 

Lors de la description de la réplication, il est possible de définir 

le sens de la réplication et la gestion des conflits au niveau global 

pour toute la réplication. Il est possible de le gérer plus finement 

au niveau de chaque fichier à répliquer. 

Pour cela, il suffit de faire clic droit sur le fichier, dans l'option 

"Propriétés". 

Notre astuce 

Il est possible de définir pour chaque fichier s’il y a des rubriques 

ne devant pas être répliquées. Ce paramétrage s'effectue dans 

l'onglet "Rubriques". 

Sauvegarde de la description 

Une fois la description de la réplication terminée, il suffit de la 

sauvegarder. 

L’éditeur de réplication génère alors un fichier ".wer" qui contient 

la description de la réplication. 

Bien sûr à tout moment, il est possible de revenir dans cet éditeur 

pour consulter ou modifier la description d'une réplication. 

Lancement d'une réplication 

Pour exécuter une réplication générée par l'éditeur de réplication 

: 

• soit les utilisateurs lancent eux-mêmes la réplication via l’outil 

"Réplic Synchro". Cet outil est librement redistribuable avec les 

applications. 

• soit l'application possède une option, un bouton, ..., qui permet 

de déclencher la réplication. Il suffit pour cela d’utiliser les 

fonctions WLangage RéplicInitialise et RéplicSynchronise. 


Réplication programmée 

Mise en place d'une réplication programmée 

Pour gérer une réplication de façon plus minutieuse, 

par exemple, pour gérer les cas de conflit particuliers, 

gérer le sens de votre réplication au niveau des 

rubriques des fichiers, ..., il est possible de définir une 

réplication par programmation sans passer par l’éditeur 

de réplication. 

Principe de la réplication par 

programmation 

Prenons par exemple le cas d’une réplication entre le siège d’une 

société et ses agences distantes. Cette réplication permet d’éviter 

une connexion en temps réel entre les deux sites. 

La base de données de référence, appelée "Réplica Maître", se 

trouve par exemple au siège de la société, à San Francisco. 

Les bases de données secondaires, ou bases distantes, appelées 

"Réplica abonné" se trouvent dans des agences à travers le monde : 

Paris, Nice, New Delhi, Sydney, ... 

Lors de chaque modification d’un enregistrement (ajout, suppression, 

modification, etc.), HyperFileSQL horodate automatiquement 

l’enregistrement dans la base, à l’heure GMT. 

Ensuite, lors de la demande de réplication et grâce à cet horodatage 

automatique, WinDev va simplement créer un fichier d’extraction, 

le réplica transportable. Ce réplica contient tous les enregistrements 

qui ont été modifiés depuis la dernière réplication. 

Ce fichier est alors ensuite envoyé aux abonnés pour mettre à 

jour leur base de données. 

Mise en place d'une réplication 

programmée 

Côté maître 

La mise en place de la réplication est l'étape qui définit les rôles 

de chaque base : maître ou abonnée. La mise en place ne doit 

être effectuée qu'une seule et unique fois. 

Pour mettre en place la réplication, il suffit de : 

• indiquer à la base de données maître qu'elle va être répliquée 

avec la fonction HGèreRéplication. 

// Gestion de la réplication hétérogène 

HGèreRéplication(rplRéplicationHétérogène) 

• spécifier à la base de données maître qu'elle est maître, par la 

fonction HCréeRéplicaMaitre. Cette fonction attend en paramètre 

le répertoire dans lequel sera créé le fichier réplica maître 

.RPM. 



// Création du réplica Maître 

HCréeRéplicaMaître(gsRepRéplicaMaître) 

• inscrire chaque abonné auprès du maître par la fonction 

HCréeRéplicaAbonné. Cette fonction permet de créer le fichier 

réplica abonné .RPL. Cette fonction définit également un identifiant 

pour l'abonné, les fichiers à répliquer et la rubrique d'horodatage. 

// Inscription de l'abonné auprès du maître 

HCréeRéplicaAbonné(gsRepRéplicaMaître,"",… 

"BASEPARIS",0,"CLIENT"+TAB+"IDDATEHEURE") 

L’inscription d’un abonné peut se faire à tout moment, mais il ne 

faut bien sûr inscrire un même abonné qu’une seule fois. 

Remarque : 

Si la base n’est pas une base HyperFileSQL, il est nécessaire 

d'ajouter à la main la rubrique d'horodatage dans l’analyse et 

dans les fichiers de données. 

L’avantage d’utiliser HyperFileSQL est que cet horodatage est 

géré automatiquement. 

• mettre à jour les abonnés à partir de la base maître, par la 

fonction HCréeRéplicaTransportable. Cette fonction va créer 

un fichier réplica transportable .RPA. Il suffit de lui indiquer le 

répertoire du réplica maître et l'identifiant de l'abonné. 

de passer en paramètre le nom d’une procédure callback. Cette 

procédure permet de gérer par programmation les cas de conflits, 

filtrer les enregistrements à ne pas répliquer par exemple. 

C’est le principal intérêt de cette méthode de réplication par 

programmation. 

// Création du réplica Transportable 

HCréeRéplicaTransportable(gsRepRéplicaMaître,… 

"BASEPARIS","") 

Côté abonné 

Il est nécessaire de récupérer : 

• le fichier RPL, le réplica abonné. Ce fichier ne doit jamais être 

supprimé. 

• le fichier RPA , le réplica transportable. Il s'agit du fichier qui 

sera reçu à chaque fois qu'une réplication doit être effectuée. 

Synchronisation des données 

Pour synchroniser des données à partir d'un réplica transportable 

(.RPA), il suffit d'utiliser la fonction HSynchroniseRéplica. Cette 

fonction attend en paramètre : 

• le nom du fichier RPA 

• le nom du fichier RPL 

• le sens de la réplication. 

// Synchronise les données reçues du maître 

HSynchroniseRéplica("To_BASEPARIS_001.RPA",… 

fRepExe()+["\"]+"Replica_BASEPARIS.RPL",… 

rplVersAbonné) 

Remarque : 

La seconde syntaxe de la fonction HSynchroniseRéplica permet 



En formation 

"WinDev Avancé" 

Dans la LST 74 (p22-23) 

Exemple "WD Réplication Universelle" 

Dans WinDev 

Exemples didactiques "WD Réplica Maître" et 

"WD Réplica Abonné" 





Base de données 

Applications Mobiles : base de données 

embarquée, distante ou mobile ? 

Lors du développement d'une application mobile, la 

question du stockage de données est une question 

récurrente. 

Ce sujet met en avant les avantages et inconvénients 

des deux solutions principales : 

• embarquer les données sur le terminal mobile. 

• accéder à distance aux données sur le serveur de 

l'entreprise. 

Avec WinDev Mobile, il est possible de : 

• utiliser une base HyperFileSQL Mobile embarquée sur le terminal 

mobile. 

• manipuler les données d'une base tierce mobile grâce aux accès 

natifs : Oracle Lite, SQLServerCE,etc. 

• accéder à une base HyperFileSQL Client/Serveur du serveur de 

l'entreprise. 

• accéder à une base tierce sur le serveur de l'entreprise : Oracle, 

Informix, SQL Server, AS/400, etc. 

Données embarquées sur le mobile 

Les avantages 

Le fait d'embarquer les données sur le terminal mobile propose 

plusieurs avantages : 

• la performance : il n'y a pas de communication distante, donc 

aucun temps de transfert. 

• la disponibilité de la base : les données sont toujours accessibles, 

que le mobile dispose ou pas d'une connexion. 

Les inconvénients 

• Il est nécessaire de gérer la synchronisation entre les données 

du mobile et celle de l’entreprise. 

Cette synchronisation peut s’effectuer lorsque le mobile est posé sur 

son socle et connecté au PC via ActiveSync ou alors à distance grâce 

à l’éditeur de réplication détaillé dans ce support de cours. 

Pour synchroniser des fichiers HyperFileSQL via ActiveSync, il 

suffit d'utiliser l'outil "WDSynchro", accessible via le menu "Outils 

.. WDSynchro" de WinDev Mobile. Il suffit de : 

• indiquer le nom de l'application. 

• indiquer l'emplacement du fichier d'analyse (.WDD) sur le PC 

et sur le Pocket PC. 

• préciser les fichiers qui doivent être synchronisés et l'ordre de 

leur synchronisation. 

• indiquer l'emplacement des fichiers de données sur le PC et 

sur le Pocket PC. 

• En cas de perte ou de vol du terminal mobile, la confidentialité 

des données doit être protégée. Pour ce point, HyperFileSQL 

permet de crypter les fichiers de données soit depuis l'éditeur 

d'analyse via l'onglet "Détails" de la description d'un fichier, soit 

par programmation avec la propriété ..Cryptage. 



Accès à distance depuis le 

mobile aux données centrales de 

l'entreprise 

L’accès distant s’effectue à travers une liaison de type Wifi ou 

3G par exemple. 

Les avantages 

• Les données manipulées sur les terminaux mobiles sont toujours 

à jour puisque les terminaux accèdent en temps réel à la base centrale. 

Il n'est donc pas nécessaire de gérer de synchronisation. 

• Les données sont sur le serveur, elles ne peuvent donc être ni 

volées ni perdues avec le terminal mobile. Un simple système 

d'identification ("login-mot de passe") dans l’application est alors 

suffisant. 

Les inconvénients 

• Les déconnexions intempestives liées aux micro-coupures de 

réseau peuvent être pénalisantes. Pour palier ce problème, WinDev 

Mobile dispose de la reconnexion automatique sur HyperFileSQL. 

En cas de déconnexion, l'application repropose automatiquement 

de se reconnecter et reprend un comportement standard : nul 

besoin de redémarrer l'application. 

• La performance liée au support de communication (Wifi, GPRS, 

etc.) peut également être un problème si les données sont nombreuses. 

Nos astuces : 

• Éviter au maximum les aller/retour inutiles au serveur. 

• Limiter au maximum le nombre d’informations à récupérer. 

• Utiliser au maximum des requêtes, des vues. Il faut que celles-ci 

soient les plus ciblées possibles et qu’elles renvoient le minimum 

de lignes possible sur le Pocket. De même, il est conseillé de ne 

rapatrier que les rubriques nécessaires : les requêtes de type 

"Select *" sont donc à proscrire. 

• Désactiver le mécanisme de cache de HyperFileSQL Client/ 

Serveur avec la fonction HGèreCache. Ainsi chaque lecture ne va 

rapatrier que le nombre d’enregistrements spécifié. Cela permet 

de limiter le temps de transfert. Par défaut pour les Pocket PC, 

c’est 10 enregistrements par lecture. 

• Désactiver la gestion des mémos avec la fonction HGèreMémo, 

encore une fois dans le but de minimiser la taille des infos transférées. 

En effet, en général sur un Pocket, il n'est pas nécessaire 

de rapatrier un mémo de 10 Méga. 

• Activer la compresser des trames, grâce à la propriété .. 

Compression. Une trame est un paquet de données qui transite 

sur le réseau qu’il soit local, Wifi, GPRS. Avec une communication 

à distance, la compression des trames est un avantage surtout si 

la vitesse de connexion est faible. 

Pour un accès rapide, de bonnes performances, une sécurité 

optimale des données, un bon compromis est de : 

• accéder à distance aux données sensibles, 

• avoir en local les données les moins sensibles. 


Accès Distant 

Accès à une base tierce depuis un terminal 

mobile 

L'accès à une base tierce depuis une application 

mobile peut être effectué : 

• par le serveur RPC fourni en standard avec WinDev 

Mobile. 

• par une page AWP créée avec WebDev. 

• par programmation (utilisation de sockets par exemple). 

L'accès à une base de données HyperFileSQL peut être 

effectué de façon native. 

Les bases tierces ne fournissent pas de couches client pour les 

terminaux mobiles. Seule exception : l’accès natif AS/400. Il est 

donc nécessaire de mettre en place une solution pour qu'un terminal 

mobile puisse accéder à une base de données. 

Utilisation d'une page de rebond 

AWP 

La première méthode consiste à utiliser une page de rebond AWP 

créée avec WebDev. 

L’avantage de cette méthode est que la page AWP se comporte 

en fait comme un WebService, qui peut être réutilisé par toute 

autre application. 


Le principe est de créer une page sans interface (sans champ) 

permettant de récupérer ou d'effectuer une opération sur la 

base de données (à l'aide d'un accès OLE DB ou d'un accès natif 

par exemple). 

En effet, cette page se comporte comme un Service Web : 

• elle attend des paramètres en entrée, 

• elle renvoie une information en retour (une liste d'informations 

extraites de la base de données par exemple). 

Réalisation 

Le code d'initialisation du projet contient le code de connexion à 

la base de données souhaitée. 

Le code “important” de cette page va se trouver dans le code 

d’ouverture de la page. Le code est alors de la forme suivante : 

• Récupération du paramètre passé à la page avec la fonction 

PageParamètre, c’est le nom sur lequel devra se faire la recherche. 

// Récupération du paramètre passé à la page 

sParamètreNom = PageParamètre("NOM") 

• Parcours du fichier par une boucle Pour Tout. Les informations 

de chaque enregistrement sont affectées dans une chaîne à l'aide 

de la fonction HRécupèreEnregistrement. 

// Parcours des contacts dont le nom 

// commence par le paramètre récupéré 

POUR TOUT CarnetAD AVEC Nom[=sParamètreNom 

// Récupération des informations sur le client 

// dans la chaîne qui va être affichée 

sChaineRetour += HRécupèreEnregistrement(… 

CarnetAD) + RC 

FIN 

• Le renvoi du résultat par la fonction ChaineAffiche. La fonction 

ChaîneAffiche permet d’afficher dans une page HTML le résultat 

de la recherche? 


Affiche la chaîne contenant les informations 

ChaîneAffiche(sChaineRetour) 

La page affichée dans un navigateur n’est alors pas très lisible, 

mais ce n’est pas ce qui est important ici. Ce qui nous intéresse, 

c’est le code source HTML de cette page qui est de la forme : 

216BANQUEN1ABBOU622TRIL 

OGET2ABONDANCE... 

Ce code source est très lisible et facilement accessible par une 

application. Il contient un client par ligne, avec les informations 

du client séparées par des tabulations. Il suffit alors d'exploiter 

cette page depuis une application WinDev ou WinDev Mobile. 

Exploitation par une application WinDev Mobile 

À partir d’une page ainsi conçue, le traitement et l'intégration des 

résultats dans une application WinDev Mobile sont très simples. 

Nous allons dans cette fenêtre tout simplement remplir la table 

avec les données récupérées sur la page AWP. 

1. Première étape : Envoi de la requête 

Il faut tout d’abord envoyer la requête au site avec le paramètre 

qui sera la lettre ou la chaîne de caractères des clients à 

rechercher. Ce paramètre est saisi dans le champ de recherche 

de la fenêtre. Le code de cette requête se trouve dans le code 

du bouton “Rechercher”. 

Pour réaliser cette requête, il suffit d’utiliser la fonction 

HTTPRequête et de construire l’URL qui sera composée de 

l’adresse de la page et du paramètre de recherche. 

Les paramètres sont séparés de l’adresse de la page par un point 

d’interrogation; le code est alors de la forme : 

// Demande à la page AWP 

HTTPRequête("http://localhost/ANNUAIREAWP_WEB/FR/ 

PAGE_RechercheClient.awp?NOM=T") 

Ensuite, il suffit de récupérer le résultat grâce à la fonction 

HTTPDonneRésultat. La fonction HTTPDonneRésultat permet 

de récupérer deux choses : 

• L’en-tête de la page : c’est dans l’entête que sont contenues 

les informations concernant la page en elle-même. 

Par exemple c’est dans l’en-tête que l’on sait si la page existe 

encore ou non. 

• Le contenu de la page : c’est le code HTML de la page. 

Bien entendu, l'application doit ici récupérer le code source HTML 

de la page. Le code devient : 

// Récupération du résultat 

ListeClient = HTTPDonneRésultat(HTTPRésultat) 

2. Deuxième étape : Analyse du résultat 

Le code source de la page est formaté : un client par ligne avec 

un retour chariot (RC). 

Il suffit donc de parcourir la variable ListeClient pour récupérer 

les informations d’un client. 

POUR TOUTE CHAINE UnClient DE 

ListeClient SEPAREE PAR RC 

TableAjoute(TABLE_Table1, UnClient) 

FIN 

Utilisation du serveur RPC 

Un serveur RPC est fourni en standard avec WinDev Mobile. 

Ce serveur RPC sert de relais entre une application et une base de 

données. Le serveur RPC re-route les commandes qu’il reçoit vers 

un serveur de base de données et renvoie le résultat. 

La commande peut être une requête SQL ou un ordre Hxxx 

(HLitPremier, HLitSuivant,etc.). 

La seule chose qui change dans l’application mobile est l'utilisation 

de la fonction hConnecteAccesDistant dans le code d'initialisation 

du projet. Cette procédure accepte en paramètres : 

• l’adresse IP ou le nom de la machine où se situe le serveur 

RPC, 

• le nom et le mot de passe qui va permettre à l’application de 

s’identifier auprès du serveur RPC. 

// Connexion au serveur RPC 

HConnecteAccèsDistant("MonServeurHFSQL",… 

"Utilisateur","MotDePasse") 

WinDev Mobile génère automatiquement l'installation du serveur 

RPC pour l'accès à une base tierce depuis un Pocket PC. Il suffit de 

cliquer sur le menu "Atelier .. Serveur RPC .. Créer la procédure 

d'installation du serveur RPC" et de suivre l'assistant pas à pas. 

L’avantage de la solution du serveur RPC est qu'il s'agit d'une solution 

sécurisée. En effet, les applications doivent être déclarées 

auprès du serveur RPC. Les applications sont des utilisateurs, au 

sens réseau, du serveur RPC. 

Il est également possible d’installer le serveur RPC en tant que 

service. 

Notre astuce 

Pour des raisons de performance, il est conseillé de privilégier 

l'utilisation de requêtes SQL. 



L90119 




PC SOFT 


BP 44 408 


France 



au : 

+33 (0) 4 67 03 07 87 

Vos Nom & Prénom : ........................................................................... 

Votre Société : .................................................................................. 


..................................................................................................... 


Pays : ........................................ Tel : ............................................... 

Adresse Email : ................................................................................. 










adressée. 






□□□ 


□□□□□□□□□□□□□□□□ □□ □□□□ 



.......................................................... 





Programmation et débogueur 

Fonctions de mise au point et de debogage 

WinDev dispose en standard de plusieurs outils et 

fonctionnalités pour aider le développeur à mettre au 

point et optimiser les applications. 

Dans cet article, nous allons étudier les principales 

fonctionnalités offertes par WinDev sur ce domaine afin 

de vous aider à choisir lesquels sont les plus adaptés 

selon vos projets. 

Principales fonctionnalités 

Les principales fonctionnalités offertes par WinDev en termes de 

mise au point sont les suivantes : 

• Les assertions 

• Les traces 

• Les logs d'exécution 

• Le débogueur 

Les assertions 

Une assertion permet de vérifier une condition lors de l'exécution 

de l'application. 

• Si la condition n'est pas vérifiée, une boîte d'information s'affiche 

avec le détail de la vérification. 

Pour définir une assertion, il suffit d'utiliser la fonction dbgAssertion 

du WLangage avec en paramètre la condition à vérifier, 

et le message à afficher si jamais elle ne l'est pas. 

Par défaut, les assertions sont actives uniquement en mode test. 

Il est possible de les activer en déploiement, il suffit d'utiliser la 

fonction dbgactiveAssertion, avec le paramètre Vrai. 

Différence fondamentale 

La condition utilisée dans l'assertion n'est exécutée par le WLangage 

que lorsque les assertions sont actives. Le fonctionnement peut 

donc être différent en mode test et en mode exécutable. 

Il faut être particulièrement vigilant lors de l'utilisation de fonctions 

dans la condition fournie à la fonction dbgAssertion. En effet, 

si la fonction utilisée réalise une initialisation ou une connexion, 

cette opération ne sera pas réalisée dans l'application utilisée en 

mode "exécutable". 

En revanche, cela permet de mettre "plus de tests" sans ralentir 

l'application en exploitation et ainsi permet d'accélérer la mise 

au point des applications. 

Notre conseil 

Les assertions peuvent servir pour des cas "spécifiques" ou vérifier 

les "pré-requis" d'une fonction. C’est-à-dire le cas qui ne devrait 

jamais arriver mais qui arrive toujours un jour : une chaîne vide 

alors que l'on attend un nom logique, un chemin vers un fichier 

inexistant, etc. 

Les assertions ne peuvent pas remplacer la gestion classique des 

erreurs : il faut gérer le cas, mais mettre une assertion permet 

d'être prévenu et de retrouver pourquoi c'est arrivé grâce à la 

pile d'exécution. 

Le développeur a alors accès à la pile d'exécution, c’est-à-dire 

tous les appels qui ont abouti à ce résultat. 

// Variable CClient 

clClient est un CClient 

// Création du client 

CréerClient(clClient) 

// L'objet clClient doit avoir été instancié 

dbgAssertion(clClientNull, ... 

"L'objet n'a pas été instancié") 

L'utilisation des assertions permet également de guider l'utilisation 

d'une fonctionnalité lors d'un développement à plusieurs 

développeurs : le code "appelant" ne doit pas provoquer d'assertion 

dans le code "appelé". 

Les traces 

La fonction WLangage Trace permet d'afficher des informations 

pendant l'exécution de l'application. Cette fonction est très 

couramment utilisée lors des phases de développement d'une 

application. 

En revanche, beaucoup moins de développeurs connaissent la 

possibilité de personnaliser le fonctionnement des traces. Cette 


personnalisation est effectuée grâce à la fonction TraceDébut 

du WLangage. 

// La fenêtre de trace est affichée 

//par-dessus les autres fenêtres 

// et un fichier de trace est sauvegardé 

TraceDébut(trFenêtre+trDessusTout+trFichier, 

fRepExe()+["\"]+"TraceExecution.txt") 

Il est alors possible de : 

• Afficher les traces dans une fenêtre, c'est le fonctionnement 

par défaut avec la constante trFenêtre 

• Enregistrer les traces dans un fichier avec la constante trFichier. 

• Désactiver les traces par programmation avec la constante 

trDésactivée 

• Déboguer directement sur un terminal mobile 

• Déboguer un composant, depuis le projet hôte, ou depuis un 

exécutable 

• Déboguer des procédures et des triggers stockés 

Le débogueur permet alors de : 

• Faire du débogage multithread 

• Évaluer des variables dynamiquement 

• Définir l'instruction suivante à exécuter 

• Modifier le code à la volée, c'est le Edit and Continue 

• Visualiser le contexte HyperFileSQL d'un fichier ou d'une source 

de données 

• Faire des points d'arrêts conditionnels.... 


Le volet du débogueur 

Il est également possible de retrouver les assertions, et les traces 

directement dans l'éditeur dans le volet du débogueur. 

Ce volet est très pratique, notamment pour le débogage distant 

car les traces et les assertions apparaissent aussi sur votre poste 

dans WinDev. De plus, un simple double-clic sur une assertion ou 

une trace affichée dans ce volet positionne automatiquement le 

code sur la ligne ayant provoqué cet affichage. 

Le développeur dispose également dans ce volet de toutes les 

erreurs non fatales rencontrées par l'application ce qui peut 

permettre de fiabiliser l'application. 

Le débogueur 

Dans WinDev, le débogueur permet de déboguer dans différentes 

configurations : 

• Déboguer le projet en mode test 

• Déboguer un exécutable, en local ou à distance (en lançant 

l'application WDDebug sur le poste distant). 

• Déboguer un site, en local ou à distance 


Analyseurs 

Optimisation d'une application grâce au logs 

et à l'analyseur de performances 

Les logs d'exécution permettent d'enregistrer tous 

les traitements qui ont été effectués par l'utilisateur. 

Cette fonctionnalité est non seulement pratique pour 

l'optimisation d'une application (le développeur sait 

ce que l'utilisateur exploite le plus en terme de fonctionnalité 

de l'application), mais aussi pour la mise au 

point de l'application. 

Grâce aux logs d'exécution, le développeur voit le 

déroulement complet de l'application : 

• toutes les fonctions qui ont été appelées, 

• tous les paramètres qui ont été passés, 

• tous les résultats des fonctions, 

et ce dans tous les threads... 

Logs et Interactions entre threads 

Pour ouvrir un fichier log d'exécution (fichier .wlog), il suffit 

d'ouvrir le projet puis d'effectuer un drag & drop du fichier .wlog 

dans WinDev. 

En effet, les threads ne s'exécutent pas tout à fait en parallèle les 

uns des autres. Le processeur ne peut faire qu'une seule chose à la 

fois. Dans le log d'exécution, on voit dans l'exemple que pendant 

qu'une instruction s'exécute dans un thread, il n'y a rien dans les 

autres threads. 

Logs et analyse d'utilisation 

Le rôle premier des logs n'est pas de servir au débogage mais d'en 

déduire un certain nombre de statistiques… 

Notamment sur les actions qui ont été le plus souvent exécutées 

par les utilisateurs. Cela permet aux équipes de développement de 

concentrer leurs efforts sur les fonctionnalités les plus utilisées. 

// Activation des logs 

// Le log d'exécution va récupérer : 

// - les fonctions WLangage 

// - les paramètres des fonctions 

// - les traitements 

dbgActiveLog("[%RepExe%][%Date%][%Heure%]", 

LogTout+LogActif) 

En plus de leur utilisation classique, les logs d'exécution sont 

efficaces pour déboguer des applications multithreads. 

Pour cela, il suffit d'activer l'option "Voir les interactions entre 

les threads". Il est alors possible de sélectionner les threads pour 

lesquels on souhaite visualiser les logs. 

Le développeur a alors accès à toutes les instructions dans l'ordre 

où elles ont été exécutées. Cela permet de comprendre plus 

facilement les cas de conflits entre les threads. 

Les logs d'exécution s'activent par la fonction dbgActiveLog du 

WLangage en indiquant,en paramètre, le chemin du fichier de log 

à générer et les options d'enregistrements. 

Vous pouvez demander à enregistrer : 

• Les traitements. 

• Les appels aux fonctions WLangage. 

• Les paramètres qui sont passés. 

Note : L'activation des logs ralentit un peu l'application, car il faut 

enregistrer tous les traitements. Il est donc préférable de ne pas 

activer les logs d'exécution en permanence. Cette fonctionnalité 

est à activer en cas de besoin pour déboguer un projet, ou en 

phase de recettage pour savoir quelles sont les options les plus 

utilisées ! 


Stockage des fichiers logs 

Le stockage des logs se fait sur disque, il faut donc prévoir la place 

nécessaire. Pour gérer le stockage des logs, un composant est livré 

en standard : "WD Gestion Logs". Le composant "WD Gestion Logs" 

permet de définir la taille maximum d'un log. 

Lorsque le fichier de log arrive à cette taille, un nouveau log est 

recréé. Et bien entendu le développeur peut spécifier le nombre 

de logs à conserver sur le disque. 

Optimisation avec le profiler 

Avec WinDev vous disposez des outils pour déboguer efficacement 

vos applications. Mais le débogage d'une application ne se limite 

pas à la correction de dysfonctionnements, c'est aussi l'optimisation 


Comment détecter les traitements qui prennent du temps dans vos 

applications ? La solution la plus rapide est le profiler intégré de 

WinDev. Le profiler liste les traitements effectués, avec le temps 

passé dans chaque traitement. 

Le profiler peut être utilisé de deux façons différentes : 

1 - Pour profiler toute l'application, depuis son lancement jusqu'à 

sa fermeture. 

2 – Pour profiler une partie de l'application, un traitement long 

ou spécifique par exemple. 

Performances et améliorations .. Analyser les performances". 

Dans ce mode de fonctionnement, WinDev lance automatiquement 

l'application en activant le profiler. Le développeur peut alors 

utiliser "normalement" l'application. Lors de la fin de l'application 

WinDev affiche le compte-rendu du profiler. 

Cette utilisation du profiler est très pratique pour vérifier l'existence 

de traitements qui sont exagérément longs avant de livrer 

une nouvelle version d'une application. 

Profiler et code ciblé 

Second cas d'utilisation du profiler : profiler une partie de l'application 

ou un traitement spécifique. 

Pour profiler seulement une partie de l'application, il suffit d'utiliser 

les fonctions AnalyseurDébut et AnalyseurFin du WLangage. 

Ces fonctions permettent de démarrer et d'arrêter le profiler. 

En général cette fonctionnalité est utilisée suite à une demande 

d'optimisation d'un traitement donné. 

Note : Cette fonctionnalité de profiler est également disponible 

en exécution sur une application déployée. Cependant,il est 

déconseillé d'activer cette fonctionnalité tout le temps : la collecte 

d'informations réalisée par le profiler prend du temps et ralentit 

un peu l’application... 


Profiler et application complète 

Premier cas d'utilisation du profiler : profiler l'ensemble d'une application. 

Pour cela, il suffit de lancer le projet par le menu "Projet.. 



L90119 




PC SOFT 


BP 44 408 


France 



au : 

+33 (0) 4 67 03 07 87 

Vos Nom & Prénom : ........................................................................... 

Votre Société : .................................................................................. 


..................................................................................................... 


Pays : ........................................ Tel : ............................................... 

Adresse Email : ................................................................................. 










adressée. 






□□□ 


□□□□□□□□□□□□□□□□ □□ □□□□ 



.......................................................... 





TESTS AUTOMATIQUES 

Mise en place de tests unitaires lors d'un 

"GO" de fenêtre 

Lorsque la génération du test est validée, il 

est possible de visualiser le code du test. 

WinDev 14 permet de mettre en place des tests unitaires 

automatisés sur les applications. Pour cela, les équipes 

de développement disposent en standard d'un éditeur 

de tests totalement intégré à l'environnement. 

Cet éditeur de tests est utilisé, dès la phase de développement, 

par les développeurs, pour enregistrer des 

tests autos sur les fenêtres, les procédures.. 

L’avantage, c’est que les tests sont intégrés le plus tôt 

possible dans le cycle de vie de l’application. 

Les bugs éventuels sont donc détectés à la source. 

Dans le cycle de vie, le temps consacré à la création 

de test automatisé est cependant souvent sacrifié au 

profit de nouveaux développements. 

L’avantage avec WinDev 14, c’est qu'à chaque test 

d'un élément (un simple GO)WinDev enregistre les 

manipulations effectuée et permet d’enregistrer le test 

unitaire correspondant à ces manipulations. 

PiloteSouris(FEN_Contacts.SAI_ 

Recherche, ... 

psClicGauche, 29,18) 

PiloteSaisie(FEN_Contacts.SAI_ 

Recherche, "WE") 

PiloteSouris(FEN_Contacts.ZR_ 

Contacts, ... 

psDoubleClicGauche, 101,30) 

//Scénario à exécuter lors de l'ouverture de la 

fenêtre FEN_FicheContact 

SUR FEN_FicheContact FAIRE 

PiloteSouris(FEN_FicheContact.IMG_ZoneIdentitié, 

psRelacheBoutonGauche, 274,145) 

PiloteSouris(FEN_FicheContact.BTN_Annuler, 


FIN 

PiloteSouris(FEN_Contacts.BTN_Quitter, 


Rappel : Le code des tests dans WinDev est directement réalisé 

en WLangage, ce qui permet de personnaliser simplement le 

code généré. 

Il est alors possible à tout moment de retester la fenêtre en sélectionnant 

le test correspondant et en faisant un "GO"de ce test. 

Création d'un test sur "GO" 

Pour illustrer la mise en place d'un test unitaire lors d'un GO, nous 

allons utiliser ici le projet "WD Gestion Contacts" : 

• Ouvrir le projet "WD Gestion Contacts". 

• Ouvrir la fenêtre FEN_Contacts 

• Faire un GO de la fenêtre 

• Rechercher "WE" 

• Double cliquer sur " WERENFRID" 

• Annuler la modification 

• Cliquer sur quitter 

Et à partir de ce Go, WinDev me propose automatiquement 

d’enregistrer le test correspondant aux manipulations réalisées 

(un bouton "Générer le test" est apparu). 

Bien entendu, dans ce cas, le code vient d'être généré, donc le 

test passe avec succès. 


Modification de la fenêtre 

L'intérêt, c'est qu'une fois le test mis en place et validé, en cas 

d'erreur ou d'un effet de bord lors d'une modification de l'application, 

le test permettra de détecter la régression. 

Pour illustrer ce cas, nous allons modifier la fenêtre "FEN_Contacts" 

sur laquelle nous venons de créer un test : 

• Ouvrir la fenêtre "FEN_Contact". 

• Ouvrir la fenêtre de description de la zone répétée. 

• Sélectionner l'onglet "IHM" 

• Désactiver l'option de double clic automatique 

• Valider 

• Sélectionner le test "TESTS_Contacts". 

• Démarrer le test (Go du test). 

(menu "Tests automatiques") ou de l'exécuter en autonome sur une 

machine dédiée au test (en copiant l'exécutable "WDAutomate" 

depuis le répertoire "Programmes" de WinDev). 

Il suffit alors de cocher les tests à exécuter et de valider.Les tests 

sélectionnés vont alors automatiquement s’enchaîner. 


Désormais, le test ne passe plus avec succès : la régression a été 

détectée. En effet, avec la modification réalisée, l'utilisateur ne 

peut plus ouvrir la fiche du contact par un double clic. 

Automatisation des tests 

Un des avantages des tests, est qu'il est ensuite possible de faire 

rejouer ces tests générés automatiquement sur l’application 

finale, sur le ".exe". 

Pour passer les tests sur un exécutable, il suffit de générer la 

bibliothèque de tests depuis le menu "Test automatiques .. Générer 

la bibliothèque de tests". 

Ensuite, il suffit d'utiliser l’automate de tests livré en standard 

avec WinDev. Il est possible de lancer l'automate depuis WinDev 


CENTRES DE Contrôles 

Suivi de projet et des incidents ou 

suggestions 

Comment savoir sur un projet quelles sont les fonctionnalités 

validées et livrables en clientèle ? 

Comment garder la traçabilité de ce qui a été développé 

? par qui ? de ce qui a été testé .. par qui ? Où 

en est l'avancement du projet ? 

Toutes ces problématiques sont communes au développement 

logiciel et WinDev répond à ces questions 

par ses différents centres de contrôle. 

Les centres de contrôle permettent de gérer les fonctionnalités 

des projets, les tâches nécessaires pour 

réaliser les fonctionnalités, le suivi des plannings, les 

incidents remontés sur les fonctionnalités. 

Et tout ça est relié, interconnecté, ce qui permet 

d’offrir au chef de projet une vision globale de l’état 

d’avancement et de la qualité du projet et de chaque 

fonctionnalité. 

place d’un système de promotions". 

• Indiquer si l'exigence nécessite une tâche de test ou de documentation 

en plus de la tâche de développement. 

• Compléter les informations décrivant plus précisément l'exigence. 

Gestion des fonctionnalités 

Premier concept.. c’est la gestion des fonctionnalités.. la gestion 

des exigences. 

On peut définir les exigences comme le cahier des charges.. les 

fonctionnalités à développer. 

La gestion des exigences se passe par le centre de suivi de projets, 

depuis le menu "Gestion - Gestion des exigences". 

Avant même le début du développement, dès la phase de conception 

de l’application,les exigences, les fonctionnalités demandées 

sont renseignées, généralement par le chef de projet. Lorsqu'il y 

a une fonctionnalité à développer, il suffit de : 

• Créer une nouvelle exigence (création simple) en cliquant sur 

le bouton "+". 

• Donner un titre explicite à l'exigence, par exemple " Mise en 

• Valider la création de l'exigence. 

À ce stade, L’exigence n’a pas encore donné lieu à des tâches 

pour les collaborateurs. 

Elle est donc dans l’état "non débutée" et "non planifiée". 

Bien sûr.. chaque exigence donne lieu à des réunions, des études 

de faisabilité, à de la recherche. Une fois cette phase d’analyse 

terminée, le chef de projet est alors en mesure de définir les 

tâches de développement, de tests, de documentation qui vont 

être nécessaires pour la réalisation de cette exigence, de cette 

fonctionnalité. Et bien sûr.. il affecte ces tâches aux collaborateurs 

concernés. 

Pour créer une nouvelle tâche associée à une exigence donnée, 

il suffit de : 

• Faire un clic droit sur l’exigence – Lier une nouvelle tâche à 

l’exigence. 

• Donner un titre explicite à la tâche, par exemple " Création de 

la page promotion". 

• Définir le type de tâche (par exemple du développement) depuis 

la combo "Type". 

• Indiquer le projet concerné. 

• Indiquer l'intervenant chargé de réaliser cette tâche. 

• Indiquer la durée estimée pour la réalisation de la tâche. 

• Valider. 


Et ainsi de suite pour les autres tâches de développement mais 

aussi les tâches de test et de documentation. 

En effet, lorsqu'un développeur est plongé dans son développement, 

il ne pense pas toujours à renseigner la tâche sur laquelle il travaille. 

C'est là que l'aide à la gestion du temps intervient puisqu'elle 

demande quelle tâche activer.. aux moments opportuns : lors de 

l’ouverture d’un nouveau projet, à interval régulier, etc. 

Chaque développeur peut alors personnaliser cette gestion du 

temps depuis le bouton "options" afin de la rendre la plus efficace 

par rapport à sa méthode de travail. 


Planning de développement 

À ce stade, le développeur retrouve dans son planning la tâche 

créée pour lui par le chef de projet. Lorsque le développeur débute 

la tâche, il lui suffit de l'indiquer dans le centre de suivi de projet 

(ou le volet correspondant intégré à WinDev). 

Dès cet instant, la gestion des exigences, le chef de projet visualise 

à tout moment l’état des tâches dans la gestion des exigences. 

WinDev donne alors automatiquement un état à l'exigence en 

fonction de l'état des différentes tâches la constituant. 

Par exemple, si la tâche de développement est passée en "En cours" 

par le développeur, l’exigence passe dans l'état "débutée. 

Le chef de projet dispose également du taux de réalisation des 

tâches. Grâce à ces informations, le chef de projet peut à tout 

moment repenser les plannings au besoin ! 

Note : En cas d'inactivité prolongée sur le poste (réunion, téléphone, 

etc.) une fenêtre apparait pour demander la tâche correspondant 

à cette période. En effet, lorsqu'un développeur part 

en réunion par exemple.. il ne pense pas toujours à changer de 

tâche en cours. 

Gestion du temps 

Le développeur bénéficie non seulement de la gestion du temps 

mais également d'une aide à la gestion du temps. 


CENTRES DE Contrôles (SUITE) 

Suivi de projet et des incidents ou 

suggestions (Suite) 

Bien entendu, ces fonctionnalités sont facultatives, vous pouvez 

désactiver la gestion du temps de WinDev ! 

Phase de test 

Une fois le développement du système de promotion terminé, 

le développeur passe tâche de développement dans l'état "terminé". 

Bien évidemment .. dans la gestion des exigences.. le chef de 

projet visualise que du point de vue développement l’exigence 

est "Terminée". 

test pour l’exigence de mise en place du système de promotions, 

le centre de contrôle qualité lui proposera automatique d’associer 

l’incident à l’exigence. 

• Indiquer le développeur auquel l'incident est affecté. Si le 

développeur reçoit des fiches d'incidents qui ne lui sont pas destinés, 

il pourra les réaffecter. En attendant, il est "responsable" 

de cette fiche. 

• Décrire les circonstances de l'incident. 

• Indiquer si l'incident est prioritaire ou non 

• Valider 

Et d’un point de vue "Test", l’exigence est planifiée mais le testeur 

n’a pas encore commencé le test donc la fonctionnalité est 

encore en "non testée". 

Pour le chez de projet, dans la fenêtre de gestion des exigences, 

les informations ont été mises à jour : 

• le testeur a commencé ses tests. 

• des incidents sont en attente de traitement par le 

développeur. 

Le chef de projet peut intervenir auprès du testeur affecté à 

cette exigence pour qu’il commence le test. Durant cette phase, 

le testeur va renseigner les incidents qu'ils rencontrent dans le 

"Centre de contrôles Qualité" : 

• Créer un nouvel incident en cliquant sur le bouton "+". 

• Indiquer l'exigence associée. Si le testeur est sur la tâche de 

L'état de développement est bien sûr passé dans l’état "à déboguer". 

Le chef de projet sait donc exactement où en est une 


exigence, tant au niveau qualité qu’au niveau développement.. 

et documentation. 

Messagerie intégrée 

Les centres de contrôle sont également reliés à la messagerie 

intégrée de WinDev. 

C'est-à-dire que dès qu’un incident est créé pour un développeur 

donné, le développeur reçoit automatiquement dans sa messagerie 

une notification. 

Il est bien sûr possible de prévenir également automatiquement 

le chef de projet par exemple en l'indiquant dans les options du 

centre de contrôle qualité. 

Le développeur et le chef de projet sont alors prévenus en temps 

réel des incidents sur les modules qui les concernent. 

Analyse d'impact 

Les versions 14 intègrent également une puissante gestion de la 

qualité des applications, et des fonctionnalités , ce qui permet 

• aux chefs de projet de connaître à tout moment l’état d’avancement 

des projets tant au niveau temps passé qu’au niveau 

validation des fonctionnalités ; 

• aux développeurs de connaître l’état de leurs modules. 


Et pour disposer de la vision globale de l’état des projets, le chef 

de projet dispose également de statistiques sur les projets et sur 

chacune des exigences. 

Notre astuce 

Il est également possible d’enregistrer un nouvel incident automatiquement 

lors de l’envoi d’un message. Le développeur ou le 

testeur saisit son message décrivant l'incident et coche l'option 

"enregistrer en tant qu'incident". 


Erreurs d'ihm 

Détecter des problèmes d'IHM non visibles 

En version 14, WinDev signale, durant le développement 

des applications, les erreurs d’IHM : les 

images non trouvées sur le disque, les libellés tronqués, 

des textes non traduits, le même raccourci 

clavier utilisé pour 2 champs différents, etc … 

Une erreur de compilation d'IHM 

Tout comme les erreurs de compilation, les erreurs de compilation 

d'IHM informe le développeur d'un problème au sein du projet. 

Ces erreurs concernent les interfaces à proprement parlé de 

l'application. 

Il existe différents types d'erreur de compilation d'IHM : 

• une image utilisée dans un champ image (ou tout autre champ) 

dont le chemin est erroné. 

• un libellé de champ tronqué dans une ou plusieurs langues. 

• un libellé de champ non renseigné dans une ou plusieurs langues. 

• une table ancrée dans la fenêtre/page mais pour laquelle aucune 

colonne n'est ancrée. 

• un raccourci clavier qui existe plusieurs fois au sein d'une même 

fenêtre. 

• ... 

Exemple de détection d'erreurs 

d'IHM 

Pour corriger ce type d'erreur, il suffit de double cliquer sur l'erreur 

affichée dans le volet. 

WinDev ouvre alors automatiquement la fenêtre sur laquelle 

porte l’erreur, ainsi que la fenêtre de description de l’élément 

qui pose problème. 

Dans le cas d'une erreur d'IHM indiquant une image manquante, 

la fenêtre de description du champ concerné va être ouverte et 

WinDev surligne en rouge le chemin incorrect. 

Il suffit alors de corriger le chemin de l'image et de sauvegarder 

la modification. 

Dans le cas d'une erreur de libellé tronqué, la fenêtre contenant 

le libellé est ouverte et le libellé concerné est sélectionné. 

Il suffit alors de corriger la taille du libellé, par l'option "Adapter 

la taille" du menu contextuel. 

Ces erreurs sont signalées à chaque sauvegarde de fenêtre ou page, 

mais également à chaque recompilation du projet. 

Activation des erreurs d'IHM 

Pour activer les erreurs d'IHM, il suffit de cliquer sur le bouton 

"Activer les erreurs d'IHM dans le volet "Erreurs de compilation". 

WinDev propose alors de recompiler le projet afin de détecter 

directement les erreurs d'IHM présentes dans le projet. 



WebDev 


Référencement 

Optimiser le référencement d'un site 

WebDev 

• L'intégration d'une solution de paiement sécurisé (chapitre 

suivant de ce support de cours). 

• Les spécificités de développement du mode AWP. 

L'exemple "Galerie" correspondant aux manipulations décrites ici 

est fourni sur le DVD. 

Rappel sur le mode AWP 

Le mode AWP (Active WebDev Page) permet de créer des pages 

autonomes et adressables directement. 

La principale caractéristique technique du mode AWP, c’est qu’il 

n’y a pas de contexte automatique. L’URL d’une page donnée reste 

toujours la même, donc elle est référençable par les moteurs de 

recherche. 

Le développement d'un site en mode AWP nécessite une programmation 

spécifique du fait qu'il n'y ait pas de contextes 

automatiques. 

WebDev permet de créer des sites Internet, Intranet, 

et Extranet. Les équipes de développement disposent 

dans WebDev de plusieurs technologies intégrées : 

• Le mode standard, avec la gestion des sessions 

100% automatiques, 

• Le mode AWP, qui gère les pages individuellement, 

• La génération PHP, qui permet de développer en 

WLangage et de générer du PHP. Ce mode est détaillé 

dans ce même chapitre quelques pages plus loin. 

Selon l'objectif et les contraintes du site à réaliser, 

il est important de choisir la bonne technologie. Or 

pour réaliser un site Internet référençable et indexable 

efficacement par les moteurs de recherche, il est 

nécessaire d'utiliser le mode AWP. 

Remerciements à Patrice Vermeille. Tous droits réservés sur ses 

œuvres. 

Mise en œuvre 

Dans cet article, nous allons détailler la création pas à pas d'un site 

Catalogue en ayant pour objectif qu'il soit référençable à 100%. 

Tout au long du développement de ce site, les points suivants 

seront mis en avant : 

• des points importants pour optimiser le référencement. 

• des menus créés dynamiquement à partir de la base de données. 

Rappel sur le référencement 

Le référencement d'un site c'est l'indexation de ce site par les 

différents moteurs de recherche. 

Il ne faut pas confondre le référencement avec le positionnement 

d'un site qui est le fait de retrouver ce site dans les premiers 

résultats du moteur de recherche. 

Pour référencer un site, les moteurs de recherche utilisent un 

principe simple. L'administrateur du site donne l'URL de la page 

d'accueil au moteur de recherche. 

Le moteur de recherche va appeler cette page régulièrement et 

la parcourir pour en indexer le contenu. Toujours à partir de cette 

page, le moteur de recherche va ressortir tous les liens présents 

dans la page. 

Pour chaque lien, il va ensuite appeler la page qui est pointée par 

le lien et en indexer le contenu. Et ainsi de suite. 

Normalement, si toutes vos pages sont liées entre elles et que vous 

n'avez pas de pages orphelines, toutes les pages de votre site sont 

référencées rien qu'en donnant l'adresse de la page d'accueil. 

Développement pas à pas 

Création du projet 

Tout commence par la création du projet en lui donnant un nom, 

ici "Galerie". 

Avec WebDev, il est possible de créer des sites dynamiques avec 

contextes automatiques, des sites AWP, des sites PHP, on le verra 

en détail tout à l'heure, et également des sites statiques et semidynamique. 


Pour cet exemple, il s'agit d'un "Site dynamique AWP". 

Note : un point important pour le référencement : il faut nommer 

la page de manière intelligible car le nom de la page est généralement 

référencé. Dans notre exemple, nous avons utilisé des 

caractères underscores ("_") entre les mots pour que le moteur 

de recherche sépare "Familles" et "Produits" et référence chacun 

des mots. 

WebDev 

Il est également important de définir un titre, car cette information 

est aussi utilisée par les moteurs de recherche. Dans notre 

exemple, nous avons indiqué "Bienvenue sur le site de vente de 

la Galerie d'art Tagnan". 

Les autres étapes de l'assistant permettent de configurer le projet : 

travail en équipe, charte de programmation, etc. 

Au niveau de la base de données, nous allons utiliser ici une base 

de données existante (au format HyperFileSQL) correspondant à 

l'analyse de l'exemple "Galerie". 

Modèle de page 

Une fois le projet créé, il est intéressant d'en définir rapidement 

l'aspect. La solution la plus simple est d'utiliser un modèle de 

page (importer d'un site précédent ou créer à cette étape). Dans 

l'exemple "Galerie", c'est le modèle PAGEMOD_Charte. 

Page principale 

Une fois le modèle principal défini, il est possible de créer la page 

principale du site à partir de ce modèle. Cette page "page_familles_ 

produits" contiendra le menu principal du site et présenteras les 

produits classés par catégorie. 

Page AWP 

Notez dans la description de la page, en bas, que pour spécifier 

qu'une page va être générée en mode AWP, il suffit de cocher la 

case : "Génération en mode AWP". 

Dans le cas de notre exemple, l'option est cochée par défaut, car 

le projet est défini comme un site AWP. 

Bien entendu, il est possible de mixer les deux dans un même site, 

c'est à dire des pages en mode classique, avec gestion automatique 

du contexte, et des pages en mode AWP. 

Menu Principal 

Le menu principal va donner l'accès à toutes les pages de mon 

site. Dans l'exemple "Galerie", nous allons créer deux entrées de 

menu : 

• une entrée de menu "Familles" : cette entrée va contenir toutes 

les catégories d'oeuvres d'art. 

• une entrée de menu "Contactez-nous" : pour permettre aux 

internautes de contacter, par email, le service commercial de 

la galerie d'art. 

Page de contact 

Commençons par créer la page de contact. Cette nouvelle page 

"page_contact" sera également basée sur le modèle MDL_Catalogue 

et aura également un titre explicite "Contactez-Nous". 

Cette page va contenir : 

• Un champ de saisie simple avec le libellé " Sujet : " afin que 

l'internaute puisse indiquer un titre à sa demande de contact 

• un champ de saisie HTML qui va contenir le message de l'inter- 


Référencement (suite) 


WebDev (SUITE) 

naute. Afin de le rendre plus lisible, je veux offrir la possibilité 

aux internautes de saisir du texte mis en forme. 

Pour que l'internaute voit immédiatement qu'il pourra mettre en 

forme sa demande, nous allons demander à "toujours afficher la 

barre de mise en forme". 

Une fois les champs de saisie mis en place,il faut ajouter deux 

liens : 

• Un lien "Envoyer" pour envoyer effectivement la demande de 

contact. 

• Un lien "Retour" (optionnel) pour retourner à la page d'accueil. 

Le lien "envoyer" sert ici à envoyer le mail correspondant. Le 

code est alors très simple puisqu'il suffit d'utiliser les fonctions 

EmailXXX du WLangage. 

// Préparation de l'email 

EmailRAZ() 

Email.Expéditeur = "pagecontact@magallerie.com" 

Email.Destinataire = "contact@magallerie.com" 

Email.Sujet = SAI_Sujet 

Email.HTML = SAI_SaisieTexteHTML 

// Envoi du message 

SI EmailEnvoieMessage(gsUtilisateur)= Faux ALORS 

// Affichage d'un message d'erreur 

Erreur("Le message n'a pas pu être envoyé",... 

"Merci de réessayer ultérieurement.") 

RETOUR 

FIN 

Lien référençable 

Pour qu’un lien soit référençable par les moteurs de recherche, 

il faut que l’adresse du lien soit connue et définie au moment de 

l'affichage de la page dans le navigateur. 

Pour définir un lien ainsi référençable : 

• Soit la page à appeler n'attend pas de paramètres, auquel cas, 

dans la description du lien ou du bouton, il suffit de sélectionner 

l'action "Afficher la page" et de choisir la page à afficher. 

// Accès aux détails d'un produit 

LIEN_Envoyer..URL = ... 

"details.awp?idproduit="+gnIdProduit 

Dans notre cas, sur le lien retour, on veut simplement retourner 

à la page d'accueil. La page d'accueil n'attend pas de paramètres, 

il suffit donc de définir la page destination dans la description 

du lien. 

Notre conseil : essayer d'avoir le maximum de liens "référençables" 

dans vos sites Internet. Vérifiez également que chaque page est 

accessible par au moins un lien référençable. 

Ajout de la page de contact dans le menu 

Dans le menu, nous allons demander à afficher la page de contact. 

Comme précédemment, la page de contact n'attend pas de paramètres, 

nous allons donc simplement définir la page à afficher 

dans la description de l'option de menu. 

Page principale 

Une fois la page de contact terminée, nous allons maintenant 

définir la page principale du site. 

Cette page va contenir la liste de toutes les oeuvres classées par 

famille. Et pour que l'internaute puisse filtrer par famille, nous 

allons créer le menu dynamiquement à partir des familles stockées 

dans la base de données. 

1. Recherche des produits 

Les produits seront affichés dans une zone répétée, et pour 

pouvoir filtrer simplement par famille de produits, nous allons 

utiliser une requête : 

1. Créer une nouvelle requête de sélection avec l'éditeur de 

requête. 

2. Sélectionner tout le fichier "Produit". 

3. Donner un nom à la requête : REQ_ProduitParCatégorie. 

4. Ajouter le libellé de la catégorie dans le fichier famille (pouri 

afficher la famille du produit). 

5. Ajouter un tri sur le libellé de la famille. 

Pour que l'internaute puisse filtrer sur la famille, nous allons 

ajouter une condition sur l'identifiant de la famille. 

• Soit la page à appeler attend des paramètres, auquel cas, il est 

nécessaire de donner la cible du lien par programmation avec la 

propriété ..URL. 


WebDev 

La requête est définie, il suffit maintenant de créer la zone répétée 

qui va afficher les produits issus de cette requête. 

2. Définition de la zone répétée 

Il faut maintenant créer la zone répétée basée sur la requête 

créée précédemment. Cette zone répétée va afficher les rubriques 

suivantes : 

• le libellé du produit, 

• la description, 

• la photo, 

• le prix, 

• et le libellé de la famille. 

Cette zone répétée n'aura pas d'interaction Ajax avec le reste 

de la page, nous allons décocher le mode Ajax et profiter de la 

possibilité d'afficher les données sur plusieurs colonnes : ici 3 

colonnes sur 3 lignes. 

Une fois la rupture définie, il suffit de personnaliser le haut de 

rupture (style, couleur) et d'ajouter le libellé de la famille dans 

le haut de rupture. 

Dans cet exemple, nous n'avons pas besoin du bas de rupture, il 

suffit donc de le rendre invisible. 

4. Filtrage des produits 

À cette étape, il faut que le menu des familles de produits permette 

à l'internaute de filtrer les produits sur les familles. 

Pour cela, la famille de produits à afficher va être donnée en 

paramètre à la page : 

1. Déclarer un paramètre à la page 

2. Donner en paramètre l'identifiant de la famille. 

PROCEDURE PAGE_Familles_Produits(... 

gnIDFamille = PageParamètre("famille")) 

Nous utilisons ici la fonction PageParamètre du WLangage pour 

récupérer l'identifiant de la famille. 

C'est simplement pour mieux référencer le site puisque les paramètres 

sur les urls sont également indexés. Donc ici, le mot "famille" 

sera indexé pour ma page. 

3. Activer le filtre en spécifiant en paramètre la famille à la 

requête. Ce code est à placer, par exemple, dans le code la zone 

répétée. 

Une fois la zone répétée créée, il suffit d'organiser un peu les 

champs, définir la couleur des lignes, etc. 

3. Mise en place d'une rupture 

Pour avoir les produits séparés par famille, nous allons ajouter une 

rupture sur la zone répétée. L'ajout d'une rupture s'effectue depuis 

la description de la zone répétée : il suffit d'indiquer l'attribut 

servant de rupture. Dans notre exemple, il s'agit bien entendu de 

l'attribut contenant le libellé de la famille de produits. 

//Paramètres de la requête REQ_ProduitParFamille 

SI gnIDFamille = "" ALORS 

MaSource.pIDRecherche = Null 

SINON 

MaSource.pIDRecherche = gnIDFamille 

FIN 

Rappel : Lorsqu'on passe un paramètre null à une requête, toutes 

les conditions définies sur ce paramètre sont ignorées. Donc si le 

paramètre passé à la page est vide, toutes les familles de produits 

seront affichées. 

4. Filtrage des produits depuis le menu 

La page accepte maintenant un paramètre pour filtrer le contenu 

par famille. Il faut maintenant créer les options de menu correspondantes. 


Référencement (suite) 


WebDev (SUITE) 

Première étape : l'affichage de tous les produits. 

• Créer une option de menu avec pour libellé "Toutes les 

familles". 

• Indiquer l'action à effectuer : afficher la page sans paramètres, 

donc directement dans la fenêtre de description. 

Seconde étape : la création d'une option de menu pour toutes les 

familles de produits. 

Toutes ces familles sont stockées dans la base de données, il est 

donc intéressant d'utiliser la création dynamique de menu (nouveauté 

des versions 14). 

5. Remplissage dynamique du menu 

Pour définir un menu dynamiquement, il suffit d'utiliser les fonctions 

MenuXXX. Dans le code de déclaration global de la fenêtre, nous 

allons appeler une procédure AjouterCatégories qui va ajouter 

les options de menu correspondant aux familles de produits. 

Le principe est simple : parcourir les familles de la base de données, 

et pour chaque famille, ajouter une option de menu. 

Ici, point important, le site doit être référencable. Il faut donc 

utiliser la fonction MenuAjouteOptionURL du WLangage et non 

MenuAjouteOption. 

En effet, la fonction MenuAjouteOptionURL permet de définir un 

lien statique pour l'option de menu, donc un lien que les moteurs 

de recherche pourront suivre. 

La fonction MenuAjouteOptionURL prend en paramètre : 

• le menu parent dans lequel il doit ajouter l'option; ici, c'est 

"familles". 

• le nom de l'option qu'il doit créer, c'est le nom logique de l'option 

de menu. 

• le libellé de l'option de menu 

• et l'URL qui doit être appelée lors du clic sur l'option de 

menu. 

Dans notre cas, cela ne va pas être la même adresse pour chaque 

catégorie, il faut donc construire l'URL dynamiquement. 

L'URL, c'est l'URL de la page actuelle, que l'on récupère avec 

la fonction PageAdresse du WLangage, à laquelle on ajoute le 

paramètre indiquant l'identifiant de la famille. 

// Parcours des familles 

POUR TOUT FAMILLE 

// URL pour cette famille 

sURL = PageAdresse() + ["/"] + ... 

"?famille=" + FAMILLE.IDFamille 

// Ajoute une option de menu 

MenuAjouteOptionURL(OPT_Famille, ... 

"FAMILLE" + FAMILLE.IDFamille, ... 

FAMILLE.LibelleFamille, ... 

sURL) 

FIN 

Le caractère "?" dans une URL indique au serveur que ce qui suit 

sont des paramètres. 

Astuce : l'opérateur crochet permet de faire de la concaténation 

optionnelle de chaîne. Dans notre exemple, le caractère "/" sera 

ajouté uniquement si l'adresse renvoyée par la fonction PageAdresse 

ne se termine pas le caractère "/". 

À cette étape, le menu est défini et les liens sont définis. 

Définition de mots-clés par page 

Afin d'améliorer le référencement, il est possible de définir les 

mots-clés des pages. Les moteurs de recherche indexent les motsclés 

d'une page en plus du contenu même de la page. Il est donc 

important de les spécifier. 

Dans notre exemple, ce que nous allons faire, c'est ajouter les 

libellés des familles en mots-clés dans la page. 

En version 14, il est possible d'ajouter dynamiquement des mots-clés 

dans une page grâce à la propriété ..MotsClé du WLangage. 

// Ajoute le libellé de la famille 

// en mot-clé de la page 

MaPage..MotsClés += [","] + 

FAMILLE.LibelleFamille 

L'opérateur "+=" permet d'ajouter les mots-clés dynamiques à ceux 

déjà définis en statique dans l'éditeur. 

Rappel : la définition des mots-clés statiques s'effectue dans 

l'onglet "Détail" de la fenêtre de description de la page (bouton " 

Éditer les expressions et les mots-clés"). 

Fichier SiteMaps 

La fréquence de mise à jour d'une page et sa priorité permettent 

également d'améliorer le référencement d'un site. Certains moteurs 

de recherche, dont Google, recherchent et analysent un fichier 

associé au site, un fichier "SiteMaps". 

Ce fichier “SiteMaps” sert principalement à indiquer la fréquence 

de mise à jour de chaque page et l'importance de chaque page 

d'un site. 

Ce fichier "SiteMaps" sera généré automatiquement par WebDev 

à partir des informations indiquées dans la zone "Référencement" 

de la fenêtre de description de la page (onglet "Détail"). 


Parcours des familles 

POUR TOUT FAMILLE 

// Ajoute une page pour la famille 

CMOD_Plan.LienAjoute("Familles", ... 

FAMILLE.LibelleFamille, ... 

"./page_familles_produits.awp?famille="+... 

FAMILLE.IDFamille) 

FIN 

WebDev 

Pour cela, il suffit de parcourir toutes les catégories et pour chaque 

catégorie, d'ajouter un lien dans le modèle de champs. 

C'est le même principe que précédemment, avec l'adresse de la 

page et le paramètre à passer à la page. 

Ici, c'est l'identifiant de la famille. 

Plan du site 

Autre point important pour le référencement : disposer d'une page 

contenant le plan du site. 

Le plan du site est pratique pour deux raisons : 

1. Il permet aux internautes de trouver les informations simplement 

sur le site. 

2. Il permet d'améliorer le référencement : toutes les pages sont 

présentées dans le plan du site et sont donc référençables. 

Pour mettre en place ce plan du site, nous allons donc créer une 

nouvelle page "PAGE_plan" avec "Plan du site de la galerie d'art 

Tagnan" comme titre. 

WebDev dispose d'un champ spécifique : le champ "plan du site". 

Le champ plan du site de WebDev est extrêmement pratique pour 

les sites statiques et semi-dynamique. 

Il permet de créer automatiquement le plan du site sans code à 

partir des pages décrites sous l'éditeur. 

Notre exemple, lui, a seulement deux pages sous l'éditeur, mais 

a potentiellement autant de pages que de familles plus la page 

contacts. 

Afin de pouvoir référencer toutes ces pages, nous allons utiliser 

un modèle de champs permettant de faire un plan du site complètement 

dynamique : 

• Importer le modèle de champs MDLC_PLANDESITE dans le 

projet 

• Ajouter un champ "modèle de champs" dans la page "page_ 

plan". 

• Initialiser le modèle de champs avec la page "page_contacts" 

dans le code d'initialisation de la page "page_plan". 

// Ajoute la page des contacts 

CMOD_Plan.NiveauAjoute("Contactez-nous",... 

"./page_contact.awp") 

• Ajouter la page des familles (toujours dans le code d'initialisation 

de la page "page_plan". 

// Ajoute la page de familles 

CMOD_Plan.NiveauAjoute("Familles",... 

"./page_familles_produits.awp") 

• Ajouter toutes les familles de produit sprésentes dans la base 


Plan du site depuis la page principale 

Il ne reste plus qu'à ajouter un lien dans la page principale pour 

avoir accès au plan du site. Pour cela, il suffit d'ajouter une option 

de menu "plan" et d'indiquer dans la fenêtre de description de 

l'option qu'il faut afficher la page "page_plan". 

Le site dispose désormais d'un plan du site complètement dynamique 

qui sera donc automatiquement "à jour", et ce même lors d'ajout, 

modification ou suppression de familles de produits. 


paiement sécurisé 

Mise en place d'un système de 

paiement sécurisé 

Composant PaiementSécurisé 

Pour gérer le paiement sécurisé, le composant PaiementSécurisé 

livré sur le DVD du support de cours est utilisé. 

Ce composant permet de gérer le paiement sur différentes plateformes 

bancaires : 

• Paybox, 

• CyberMut (CIC, Crédit mutuel, OBC), 

D'autres plateformes de paiement seront disponibles dans les 

prochaines versions de ce composant. 

Pour plus d'informations sur la solution de paiement sécurisé 

CYBERMUT, consultez le site http://www.cmcicpaiement.fr 

Paiement externalisé : principes 

Il existe différents types de paiement sur Internet. Un type de 

paiement sécurisé particulièrement intéressant est le paiement 

externalisé : le paiement est géré par un prestataire de confiance 

qui s’occupe de tout. 

L’avantage de ce principe de paiement réside dans le fait que les 

aspects de sécurité, cryptage, certificat,etc. ne sont pas gérés 

par le développeur de l'application. 

Lors du développement d'un site de vente en ligne, la 

partie concernant le paiement est souvent délicate à 

mettre en œuvre. Il est nécessaire de s'interfacer avec 

la solution proposée par un prestataire bancaire et 

chaque prestataire propose une solution différente. 

Le composant "PaiementSécurisé", disponible sur le 

DVD de ce support de cours, permet d'intégrer rapidement 

et simplement les solutions de paiement de 

différents prestataires. 

Note : Le composant "PaiementSécurisé "est un exemple d'intégration 

de différentes solutions de paiement sécurisé dans un site 

WebDev. Il ne s'agit pas d'une préconisation de ces systèmes de 

paiement par la société PC SOFT. 

Il est rappelé que l'utilisation d'un système de paiement nécessite 

la souscription d'un contrat auprès du prestataire bancaire. 

Le principe de ce paiement est très simple : 

• le client remplit son panier et valide sa commande. 

• le site va envoyer la demande de paiement au serveur du prestataire 

spécialisé. 

• le prestataire sécurisé affiche à l’internaute une page contenant 

le formulaire de saisie des informations bancaires. 

• l’internaute saisit son n° de carte bleue. 

• le prestataire fait une demande d’autorisation auprès du groupement 

carte bancaire. 

• le prestataire renvoie le n° de l’accord au site marchand. 

• le site marchand est payé et peut valider la commande de 

l’internaute. 

Utilisation du composant 

Pour utiliser le composant PaiementSécurisé, il est nécessaire de 

l'importer dans l'application WebDev souhaitée. 

Pour importer un composant, il suffit d'utiliser le menu "Atelier .. 

Composant .. Importer un composant dans le projet". 

À la fin de l'import, WebDev affiche la fenêtre de documentation 

du composant. Cette documentation fournit les différentes 

fonctions, variables et constantes disponibles pour effectuer un 

paiement en ligne. 


WebDev 

Définition d'un paiement 

Dans un premier temps, il est nécessaire de déclarer un paiement. 

Pour l'exemple, le paiement s'effectuera auprès de CyberMut 

Crédit Mutuel. 

// Crée un objet de paiement sécurisé 

// dédié à Cybertmut Crédit Mutuel 

MonPaiement est un … 

PaiementSécurisé(CréditMutuel) 

Exemples de gestion de panier 

WebDev propose, en standard : 

• un composant "Composant Panier". Ce composant permet de 

gérer de "A à Z" un panier de site de vente. 

• deux exemples de site vitrine qui gèrent un panier : "WW_ 

VitrineAWP" et "Catalogue Internet". 

Lors de l'utilisation du composant de paiement, il est nécessaire 

de spécifier les paramètres du contrat défini avec le prestataire 

bancaire. Ces paramètres sont fournis par le prestataire lors de 

la souscription d'un contrat auprès de leurs services. Dans le cas 

d'un paiement CyberMut, les paramètres sont : 

• le numéro du contrat, 

• le code de la société, 

• une phrase clé, 

• une clé calculée. 

• le numéro de commande. Ce numéro de commande doit absolument 

être unique (par exemple, la dateheure courante). 

• l'adresse des pages à appeler lorsque le paiement est validé, 

refusé ou abandonné. 

// Données du contrat (test) 

MonPaiement:Contrat = 1234567 

MonPaiement:CodeSociété = "TESTSOC" 

MonPaiement:PhraseClé = "Phrase clé" 

MonPaiement:CléCalculée = "abcdef1234" 

// Définit le numéro de commande (unique) 

MonPaiement:NuméroCommande = … 

DateDuJour + Maintenant 

// Page à appeler lors de la validation 

MonPaiement:SurValidationPaiement = … 

"./ValidationPaiement.awp" 

Le paiement se lance ensuite par la procédure Paiement du 

composant. Cette fonction attend en paramètres : 

• les informations du paiement rempli précédemment, 

• le montant à payer, 

• l'adresse email à laquelle le site de paiement doit envoyer la 

confirmation de paiement. Il s'agit donc de l'adresse du client. 

// Lance la procédure de paiement 

Paiement(MonPaiement, ATT_PrixHT, … 

"celine.dalmosso@gmail.com") 

Remarque : 

Pour tester le composant, il est possible d'utiliser des informations 

de test (numéro de carte, numéro de contrat, etc.). Cela permet 

de valider le fonctionnement sans effectuer de transaction 

bancaires en réel. 


MASHUP 

Mixer des données HyperFileSQL et des 

données Google 

Le Mashup est un concept qui consiste à mettre en 

commun des informations provenant de sources différentes. 

Cela permet de créer une véritable liaison entre des 

logiciels différents. 

WinDev et WebDev disposent de fonctionnalités pour 

simplifier le mashup : le databinding, mais également 

les différentes fonctions en lien avec Google. 


Les projets utilisés pour illustrer ce sujet sont : 

• "WW Mashup". Pour utiliser cet exemple, il est nécessaire de 

renseigner les informations de connexion (compte et mot de passe) 

dans le code d'initialisation de projet. 

• "WD Google". 

Manipulation d'agendas Google en 

WinDev 

L'exemple "WD Google" est une application qui permet de visualiser 

les rendez-vous de la journée d'un commercial donné, et d'ajouter 

de nouveaux rendez-vous. 

Connexion au compte Google 

Dans un premier temps, il est nécessaire de se connecter au compte 

Google du commercial. 

Pour établir une connexion à un compte Google, le WLangage 

dispose d'un type de variable spécifique : gglConnexion. Ce type 

de variable permet de paramétrer la connexion à un compte très 

simplement. 

// Objet de connexion au compte Google 

MaConnexion est un gglConnexion 

Il suffit ensuite de spécifier les informations de connexion à cette 

variable : adresse email, mot de passe. 

// Spécifie les informations de connexion 

MaConnexion.Email = "email@societe.fr" 

MaConnexion.MotDePasse = "motdepasse" 

Il suffit enfin d'établir la connexion à proprement parlé, à l'aide de 

la fonction gglConnecte, en lui passant en paramètre la variable 

contenant les informations de connexion. 

// Etablit la connexion 

GglConnecte(MaConnexion) 

Remarque : 

La connexion est nécessaire pour utiliser différentes familles de 

fonctions Google : les agendas, les cartes, les contacts, picasa, 

les documents. 

Récupération d'un agenda 

Pour afficher les rendez-vous d'un agenda donné, il est nécessaire 

de récupérer l'agenda. Pour récupérer un agenda, il suffit d'utiliser 

la fonction WLangage gglRécupèreAgenda. Cette fonction prend 

en paramètres : 

• la connexion google à utiliser. 

• le nom de l'agenda à récupérer. En effet, il est possible qu'un 

même compte Google dispose de plusieurs agendas différents. 

Cette fonction renvoie une variable de type gglAgenda. Cette 

variable est en fait une structure contenant des informations sur 

les rendez-vous. 

// Objet Agenda 

MonAgenda est un gglAgenda 

// Récupère l'agenda "Agenda professionnel" 

MonAgenda = GglRécupèreAgenda(… 

MaConnexion, … 

"Agenda Professionnel") 

Affichage des rendez-vous dans une table 

Une fois l'agenda récupéré, les rendez-vous sont affichés dans 

une table. 

Cette table utilise le databinding : les informations affichées sont 

directement issues de la variable MonAgenda, et plus précisément 

du tableau Evénement de cette variable. 

Les colonnes sont reliées aux différentes variables : 

• le titre du rendez-vous, 


• la date de début, 

• la date de fin, 

• le contenu descriptif. 

Remarque : 

Il est possible de remplir la table par programmation, en parcourant 

le tableau Evénement de la variable MonAgenda. 

// Objet Evénement 

MonRendezVous est un gglEvénement 

// Parcours des rendez-vous de l'agenda 

POUR TOUT ELEMENT MonRendezVous DE … 

MonAgenda.Evénement 

// Ajoute le rendez-vous dans la table 

TableAjouteLigne(TABLE_Evénement, … 

MonRendezVous.Titre, 

MonRendezVous.DateDébut, 

MonRendezVous.DateFin, 

MonRendezVous.Contenu) 

FIN 

Ajout d'événements dans un agenda 

Pour ajouter un événement dans un agenda, il est requis d’avoir 

préalablement établi la connexion et récupéré l'agenda dans une 

variable gglAgenda. 

Un événement peut être manipulé par une variable gglEvénement. 

Pour ajouter un événement à un agenda, il suffit donc de : 

• déclarer un objet gglEvénement. 


MonRendezVous est un gglEvénement 

• remplir les informations qui définissent cet événement. Pour 

faciliter le remplissage, l'exemple "WD Google" dispose d'une 

fenêtre "FEN_AjoutRDV". Cette fenêtre utilise le databinding : 

les champs de cette fenêtre sont liés directement aux membres 

de la variable MonRendezVous. Il suffit alors d'utiliser la fonction 

EcranVersSource qui permet de récupérer les valeurs des champs 

directement dans la variable. 

// Récupération des informations 

EcranVersSource() 

• ajouter l'événement défini dans le tableau des événements de 

l'agenda. Cet ajout est réalisé par la fonction Ajoute. 

// Ajout du rendez-vous à l'agenda 

Ajoute(MonAgenda.Evénement, MonRendezVous) 

• mettre à jour l'agenda chez Google par la fonction gglEcrit. 

Cette fonction permet de mémoriser les informations des variables 

gglXXX sur le serveur. Cette fonction prend en paramètres 

un objet gglConnexion et l'objet à mettre à jour (gglAgenda, 

gglContact, etc.). 

// Mémorise l'agenda 

GglEcrit(MaConnexion,MonAgenda) 

simplifiée. 


La page WebDev va chercher les informations de rendez-vous dans 

l’agenda Google, grâce aux fonctions WLangage. Chaque rendezvous 

est associé à une adresse email d'un contact. 

// Récupère l'agenda professionnel 

Agenda = GglRécupèreAgenda(MaConnexion,… 

"Agenda Professionnel") 

// Définit les dateheures de récupération 

DateDébut..PartieHeure = "080000" 

DateFin..PartieHeure = "230000" 

// Récupération des événements qui composent 

l'agenda pour le jour courant 

GglRemplitAgenda(MaConnexion,MonAgenda, … 

DateDébut, DateFin) 

Pour chaque rendez-vous, les informations du contact sont récupérées 

directement dans une base de données HyperFileSQL, à l'aide 

de l'adresse email du contact, et affichées dans une table. 


MonEvenement est un gglEvénement 

// Parcours des événements de l'agenda 

POUR TOUT MonEvenement DE Agenda.Evénement 

// Mémorise l'email de l'invité 

EmailInvite = MonEvenement.Invité[1].Email 

// Recherche ce contact dans la base 

HLitRecherchePremier(Client,EMail, EmailInvite) 

// Ajoute une ligne pour ce rendez-vous 

TableAjouteLigne(TABLE_RDV, … 

MonEvenement.DateDébut,… 

EmailInvite, 

Client.NumClient, 

Client.NomContact +" "+ Client.PrénomContact, 

Client.Latitude, Client.Longitude, 

Client.Ville, 

MonEvenement.Titre) 

FIN 

Enfin, le trajet à effectuer pour voir tous les contacts est affiché 

dans la carte. Lors la sélection d'une ligne de rendez-vous dans 

la table, un marqueur est ajouté sur la carte pour localiser le 

lieu du rendez-vous. 

WebDev 

Exemple de MashUp en WebDev 

L'exemple "WW Mashup" est un exemple de mashup sur une page 

web. La page "PAGE_Mashup" contient : 

• une table WebDev qui affiche les rendez-vous de la journée, 

• une carte "Google Map" qui affiche l'itinéraire de la journée. 

Cette page permet à une secrétaire de gérer les rendez-vous 

d’une équipe de commerciaux. Il s'agit d'une gestion de planning 


WebDev PHP 

Création et déploiement d'un site PHP 

dépend de la version fournie par l'hébergeur. 

• Une base de données MySQL et si nécessaire la 

couche cliente MySQL. De même que pour PHP, il est 

conseillé d'utiliser la même version de MySQL que 

celle fournie avec l'hébergement. 

Configuration du projet 

Pour spécifier qu’un site WebDev est un site PHP, il 

suffit de l'indiquer dans l’assistant de création de 

projet. Nous vous conseillons d'indiquer le plus tôt 

possible la nature du projet afin de permettre au 

compilateur d'indiquer les éventuelles indisponibilités 

d'un champ ou d'une fonction en PHP. 

WebDev permet de générer des sites dynamiques PHP 

avec ou sans session accédant à une base MySQL. Il est 

alors possible de réaliser un site PHP et de l'héberger 

sur un site mutualisé "classique" à moindre coût (par 

exemple OVH ou même un hébergement personnel 

chez Free). 

Mise en œuvre 

Pour illustrer le développement et le déploiement d'un site WebDev 

PHP, cet article utilise le projet "Extranet_Precilia". Les paramètres 

de connexion à la base de données doivent être renseignés dans 

le "code d'initialisation de session PHP". 

Configuration du poste de 

développement 

Lors d'un développement de site PHP, il est nécessaire d'installer 

quelques modules spécifiques sur le poste de développement : 

• Un serveur web : Apache ou IIS par exemple. Normalement, un 

développeur WebDev dispose déjà ce type de logiciel. En revanche, 

lors de la réalisation d'un site PHP, il peut être intéressant d'utiliser 

un serveur Web sensible à la casse (un hébergement mutualisé 

sous linux sera sensible à la casse). 

• Un moteur PHP en version 4 ou 5. La version minimale supportée 

par WebDev est la version 4.3.2. La version de PHP à utiliser 

Configuration de l'analyse 

Lors de la réalisation d'un site PHP, l'éditeur d'analyses 

propose une connexion spécifique "Accès Natif PHP 

MySQL" qui est la connexion entre le site PHP et la 

base MySQL. 

Pour bénéficier du mode test "en simulation" et ainsi 

disposer du débogueur de WebDev, il est également 

nécessaire d'installer l'accès natif MySQL pour WebDev. Cet accès 

natif permet au moteur WebDev d'accéder à la base de données 

MySQL. Cette seconde connexion peut être décrite depuis l'analyse 

ou par programmation. 

Note : Avec WebDev 14 et l’accès natif AS/400, il est possible 

d'accéder directement à des bases AS/400 depuis des sites PHP. 

Grâce à ces accès natifs, la manipulation de la base de données 

(MySQL ou AS/400) s'effectue par les fonctions Hxxx : 

HLitRecherche, HAjoute, etc. 

Dans les autres cas (bases tierces ou HyperFileSQL), l'accès aux bases 

de données depuis PHP s'effectue grâce aux fonctions SQLxxx. 

Le projet exemple 

La création des pages se fait de façon classique, comme avec 

un projet WebDev classique. Le projet "Extranet_Precilia" est 

constitué de : 

• Un modèle de page principale correspondant à la charte graphique 

du site : PAGEMOD_IHM. 

• Un modèle de page correspondant à la gestion de la popup de 

détail d'un produit : PAGEMOD_POPUP. Cette popup est gérée 

par programmation Ajax. 

• Un modèle de champ correspondant à la gestion du panier : 

MDLC_ModelePanier. Le panier est ici affiché sous la forme d'une 

zone répétée Ajax. 


Ensuite, les différentes pages sont des pages "PHP" avec contexte. 

Cela signifie que les variables et les positions dans la base de données 

sont automatiquement gérées par WebDev, ce qui simplifie 

la programmation. 

Connexion à la base de données 

La connexion à la base de données peut être décrite : 

• soit dans l'analyse, 

• soit par programmation grâce aux fonctions hDécritConnexion 

et hChangeConnexion du WLangage. 

Dans la majorité des hébergements PHP (hors serveur dédié), la 

base de données MySQL n'est accessible que depuis le site et non 

depuis Internet. Il est donc nécessaire de disposer d'une base de 

données "locale" et d'une connexion spécifique vers cette base de 

données locale lors du mode test. 

Note : pour remplir la base de données locale avec les mêmes 

données que la base en production, il est généralement possible 

de récupérer le contenu de la base MySQL de production par 

PhpMyAdmin. 

// Définition de la connexion 

SI EnModeTest() ALORS 

// Connexion en mode test 

HDécritConnexion("MaConnexion", 

UTILISATEUR_BASE_TEST, 

MOTDEPASSE_BASE_TEST, 

SERVEUR_BASE_TEST, 

BASE_DONNEES, 

hAccèsNatifMySQL) 

SINON 

// Connexion sur le serveur de production 

HDécritConnexion("MaConnexion", 

UTILISATEUR_DISTANT, 

MOTDEPASSE_DISTANT, 

SERVEUR_DISTANT, 

BASE_DONNEES, 

hAccèsNatifMySQL) 

FIN 

// Changement de la connexion 

HChangeConnexion("*","MaConnexion") 

// Ouverture et/ou création de la base 

HCréationSiInexistant("*") 

La fonction WLangage HCréationSiInexistant créera les fichiers 

dans la base de données s'ils n’existent pas déjà. 

Lors du premier lancement, il suffit d'indiquer les paramètres FTP 

fournis par l'hébergeur : 

• l'adresse du serveur FTP (et éventuellement le port), 

• le nom d'utilisateur et le mot de passe, 

• le nom de répertoire correspondant au site visible (par exemple 

"www" chez OVH). 

Ensuite, le déploiement s'effectue en deux étapes : 

• une phase de préparation où "WDDéploie" analyse le répertoire 

local du site et le compare au site déployé. A la fin de cette phase, 

l'outil "WDDéploie" affiche au développeur les éléments à déployer 

pour mettre à jour le site. 

• une phase de déploiement pendant lequel "WDDéploie" réalise 

le transfert effectif des fichiers sur l'hébergement. 

Note : La première page du site chez OVH, ou même sur un hébergement 

personnel comme Free, doit obligatoirement s’appeler 

"index.html" ou "index.php". 

WebDev crée automatiquement ces pages à partir de la page 

d’accueil définie dans le projet. 

WebDev 

Déployer un site PHP 

Une fois le site créé et testé, l’étape suivante est le déploiement 

du site chez un hébergeur. 

Le déploiement peut s'effectuer de deux manières : 

• manuellement à l'aide d'un client FTP (FileZilla par exemple). 

• automatiquement grâce à l'outil "WDDéploie" livré en standard 

avec WebDev. 

L'avantage de cette seconde solution, c'est que l'outil "WDDéploie" 

"connait" l'architecture du site et peut donc aider lors de sa mise 

à jour en : 

• vérifiant les fichiers modifiés. 

• filtrant les projets par langue. 



L90119 




PC SOFT 


BP 44 408 


France 



au : 

+33 (0) 4 67 03 07 87 

Vos Nom & Prénom : ........................................................................... 

Votre Société : .................................................................................. 


..................................................................................................... 


Pays : ........................................ Tel : ............................................... 

Adresse Email : ................................................................................. 










adressée. 






□□□ 


□□□□□□□□□□□□□□□□ □□ □□□□ 



.......................................................... 



Services Web 


SOA 

Réalisation d'une application "SOA" (Services 

Oriented Architecture) 

SOA est l'acronyme de Services Oriented Architecture 

(Architecture orientée services). 

Une application est dite de type SOA lorsqu'elle utilise 

des services externes pour offrir des fonctionnalités 

aux utilisateurs. Ces services peuvent être des web 

services, des composants, des pages AWP, … 

Ce sujet présente comment importer et utiliser un web 

service dans une application existante. 


Le projet utilisé pour illustrer ce sujet est "WD CRMServices" 

(présent sur le DVD). 

Le web service présenté dans ce sujet est disponible à cette 

adresse : http://ec.europa.eu/taxation_customs/vies/api/ 

checkVatPort?wsdl. 

WinDev permet de : 

• générer des web services 

• utiliser des web services, générés avec WinDev ou non. 

Utilisation d'un web service 

L'application exemple "WD CRMServices" permet de gérer des 

clients. Dans cette application, la TVA Intracommunautaire doit être 

vérifiée. Il existe un web service, mis à disposition gratuitement 

par l'Union Européenne, qui permet de vérifier si un numéro de 

TVA intracommunautaire est valide ou non. 

Ce web service est disponible à cette adresse : http://ec.europa. 

eu/taxation_customs/vies/api/checkVatPort?wsdl. 

Importation du web service 

Pour importer un web service, il suffit de cliquer sur le menu 

"Atelier .. Services Web .. Importer et utiliser un service dans ce 

projet" et de se laisser guider par l'assistant : 

• Adresse du fichier WSDL. 

Le fichier WSDL est le fichier de description du service web. Dans 

ce fichier sont décrites les différentes procédures que le web 

service exporte avec leurs différents paramètres. Il s'agit donc 

des points d'entrées et de sorties du web service. 

• Type de web service. 

Le web service peut en effet posséder des spécificités J2EE ou 

dotNet. Si aucune information n'est connue quand à la plateforme 

de génération du web service, il est conseillé de choisir "SOAP 

Générique". 

• Type de génération et nom 

Les accès au web service qui va être utilisé peuvent être définis soit 

sous forme de classe, soit sous forme de collections de procédures. 

Le nom de l'objet généré peut ensuite être modifié. 

Une fois le web service importé, les éléments générés (classes ou 

collections) sont ajoutés au projet, avec toutes les procédures qui 

permettent d'appeler le web service. 

Remarque : 

Dans la collection de procédures (ou classe) générée, il existe 

des procédures publiques (picto vert) et privées (picto rouge). 

Pour utiliser le web service dans un projet, il suffit d'utiliser les 

procédures publiques. 

Utilisation du web service 

Dans l'application exemple "WD CRMServices", le web service importé 

va permettre de contrôler le numéro de TVA d'une société. 

L'appel se fera sur le bouton "Vérifier le numéro de TVA 

Intracommunautaire" de la fenêtre FEN_FicheSociete. 

Notre conseil : 

Il est conseillé d'appeler les web services sur des actions utilisateurs; 

par exemple dans "WD CRMServices", sur le clic d'un bouton 

"Vérifier le numéro de TVA". 

Tout simplement parce qu'un web service peut être indisponible. 

La fonction à utiliser pour ce web service est la fonction checkVAT. 

Cette fonction attend le code ISO du pays et le numéro de TVA à 

vérifier et renvoie une variable de type checkVATResponse. 

// Variable de résultats de contrôle de TVA 

stMonRésultat est un STcheckVatResponse 

Pour accéder aux détails de la structure (les variables qui la 

composent), il suffit de faire F2 sur la déclaration. La structure 

checkVATResponse contient : 

• le code du pays, 

• le numéro de TVA, 

• la date de la requête, 

• un booléen qui indique si le numéro est valide ou pas, 

• le nom de la société à laquelle correspond ce numéro, 

• l'adresse de la société. 

Pour contrôler le numéro de TVA la société courante affichée dans la 

fiche, il suffit d'appeler la fonction checkVAT du web service. 


Services Web 

// Contrôle le numéro de TVA pour le pays 

stMonRésultat = checkVat(... 

COMBO_Pays, ... 

SAI_TVAIntraCommunautaire) 

La variable booléen m_valid indique maintenant si le numéro de 

TVA est valide ou non. Il est donc possible d'afficher un message 

à l'utilisateur, ou de changer la couleur de fond du champ selon 

la validité du numéro de TVA par exemple. 

// Si le numéro de TVA est valide 

SI stMonRésultat.m_Valid = Vrai ALORS 

// Colorise le fond du champ en vert 

SAI_TVAIntraCommunautaire..CouleurFond = … 

VertPastel 

SINON 

// Colorise le fond du champ en rouge 

SAI_TVAIntraCommunautaire..CouleurFond = … 

RougePastel 

FIN 


SAAS 

Réalisation d'une application "SAAS" 

(Software As A Service) 

SaaS est l’acronyme de "Software as a Service". Il 

s'agit d'une manière de commercialiser, de distribuer 

un logiciel. 

Le logiciel se vend non plus sous la forme d'un produit 

que le client installe en interne, mais sous forme 

d'une application accessible à distance par le biais 

d'Internet. 

WebDev dispose de nombreux avantages qui permettent 

de mettre en place simplement et rapidement des 

applications sur le modèle SaaS. 

SaaS : principes 

Le SaaS est un mode de livraison des applications où le fournisseur 

héberge le service. 

Les clients accèdent à ce service via Internet : on parle alors 

d'application de type "client léger". 

La facturation d'un tel service se fait en général par abonnement, 

par exemple par nombre d’utilisateurs et par mois. 

Le groupware utilisateur 

Le groupware utilisateur de WebDev permet, par exemple, de 

maîtriser la facturation grâce à l’identification des utilisateurs 

et à l'historique des connexions. 

Pour activer le groupware utilisateur, il suffit d'ouvrir la fenêtre 

de paramètres du groupware accessible via le menu "Atelier .. 

Paramètres du groupware" et de cocher l'option "Activer". 

La base HyperFileSQL gratuite 

En général, avec un contrat SaaS, chaque société cliente a sa base de 

données dédiée sur les serveurs du fournisseur de l’application. 

Mais il est également possible de mettre en place un Saas avec 

une seule base de données pour tous les clients; il faut juste le 

gérer dans la structure de l'analyse. 

Comme la base de données HyperFileSQL est entièrement gratuite, 

quel que soit le nombre de serveurs, de connexions, de 

sites, d’utilisateurs, aucun frais de déploiement supplémentaire 

n'est à craindre. 

La duplication de base 

La duplication automatique de base HyperFileSQL, disponible 

à partir des versions 14, facilite a mise en place d'une base par 

société cliente, à partir d'une base générique. 

Pour dupliquer une base, il suffit de : 

• ouvrir le Centre de Contrôle HyperFileSQL. 

• faire un clic-droit sur la base de données à dupliquer. 

• choisir l'option "Dupliquer la Base de Données sélectionnée". 

Les fichiers, liaisons, triggers, procédures stockées et droits sont 

automatiquementdupliqués, en un clic. 

Il suffit alors de spécifier le nom de la nouvelle base à créer. 

Pour une application en mode SaaS, c’est une fonctionnalité très 

pratique. 

La sécurité des données 

WebDev permet de gérer facilement le mode sécurisé "HTTPS" et 

"SSL", indispensable à toutes transactions sécurisées. 

Il suffit d'utiliser la fonction SSLActive du WLangage dans les 

pages du projet. 

// Active le mode sécurisé SSL 

SSLActive(Vrai) 

Le cryptage et la protection par mot de passe des fichiers de 

données HyperFileSQL assurent également un niveau de sécurité 

supplémentaire pour les clients. 

L'installation multiple de sites 

identiques 

L'intérêt de l'installation multiple est d'avoir un projet unique et 

donc une maintenance unique pour tous les clients. 

Autrement, il faudrait dupliquer le code source autant de fois 

qu'il existe de clients. 

L'installation multiple de sites identiques sur un même serveur 

facilite donc la mise en place en mode SaaS. 

Pour déployer un site plusieurs fois sur un même serveur, il suffit 

de lancer l'assistant de création de la procédure d'installation. 

Cet assistant est accessible via le menu "Atelier .. Créer la procédure 

d'installation". 

WebDev génère dans un premier temps la bibliothèque du site. 

La bibliothèque contient tous les éléments nécessaires au bon 


Services Web 

fonctionnement du site. 

Il suffit ensuite de sélectionner le type de déploiement, par 

exemple FTP, et de renseigner les informations de connexions 

de ce serveur. 

Il est ensuite possible de spécifier le nom du site qui sera utilisé sur 

le serveur. Il suffit alors d'indiquer un nom spécifique au client. 

Pour chaque site, le paramétrage du nombre de connexions 

simultanées et du nombre de connexions maximum par utilisateur 

est disponible. 

Il est conseillé d'autoriser plus d'une connexion par internaute. 

En effet, l'identification d'une connexion est faite par l'adresse 

IP. Si un client utilise un proxy, tous les collaborateurs de cette 

entreprise auront la même adresse IP. 



En formation 

"WinDev Expert" 


Exemple "WW_SOA" et "WW_SOA_DEMO" 


Exemple "WWServiceWeb" 



Déploiement d'applications 


Déploiement 

Choisir le type de déploiement adapté à une 

application 

Une fois l'application WinDev développée, les tests 

passés et l'exécutable créé : comment gérer simplement 

et efficacement le déploiement d'une application 

WinDev et les mises à jour futures ? 

WinDev propose la création de différents types d'installation. 

WinDev offre toutes les fonctionnalités nécessaires à 

un déploiement facilité et une exploitation simplifiée 

des applications ! 

Que ce soit une installation autonome, réseau ou 

internet, avec WinDev vous créez une procédure 

d'installation complètement adaptée à votre type de 

déploiement. 

Création de la procédure 

d'installation 

La création de la procédure d'installation s'effectue très simplement 

à l'aide d'un assistant. Cet assistant est accessible via le menu 

"Atelier .. Créer la procédure d'installation". 

Les étapes de l'assistant se découpent en deux parties : 

• la création de l'exécutable. Cette partie reprend les plans de 

l'assistant de création de l'exécutable. Si l'exécutable à déployer 

a déjà été généré, il est possible d'accéder directement aux 

options d'installations. Il suffit de cliquer sur le lien "Installation" 

à gauche de l'assistant. 

• le paramétrage de l'installation. Cette partie permet de choisir le 

type d'installation à utiliser et de choisir les options souhaitées. 

Installation autonome 

Le premier type d'installation est l'installation autonome. 

La particularité de l'installation autonome est qu'il n'y a pas de 

mises à jour automatiques, pas de live update. Dans ce cas, il 

est nécessaire de réinstaller totalement l'application dès que 

nécessaire. 

Dans quel cas utiliser cette installation ? 

Ce type d'installation est recommandé pour les applications qui 

sont diffusées sur un nombre de postes restreint ou pour lesquelles 

peu de mises à jour sont prévues. 

Installation réseau 

WinDev permet également de créer une installation réseau, c’està-dire 

une installation avec un live update automatique. 

Lors du déploiement de l'application, une installation "serveur" 

est réalisée : il s'agit de l'installation de référence. 

Ensuite tous les postes clients installent l'application depuis cette 

installation de référence. Lors des prochains lancements de l'application, 

celle-ci va automatiquement vérifier si une mise à jour 

est disponible sur le serveur. Si une mise à jour est disponible, 

l'application va se mettre à jour automatiquement. 

L'installation avec live update automatique peut être faite : 

• par réseau local. Dans ce cas, l'installation de référence sera 

réalisée dans un répertoire partagé. 

• par Internet. Dans ce cas, il suffit de copier l'installation référence 

et la page HTML générée sur un serveur HTTP, un serveur 

Web. Les utilisateurs installent et mettent à jour l'application 

depuis ce serveur Web. 

Pour ces installations, plusieurs paramétrages sont possibles. 

Dans quel cas utiliser cette installation ? 

Ce type d'installation est recommandé pour les applications qui 

sont largement diffusées et pour lesquelles les mises à jour sont 

régulières. 

Contrôle des versions 

Le contrôle de version permet de spécifier : 

• l'exécutable de référence pour l'installation. En effet, si le projet 

génère plusieurs exécutables différents, il est nécessaire d'indiquer 

quel exécutable servira de référence pour la mise à jour. 

• la version minimale autorisée. Cette option permet notamment 

de force une mise à jour. Par exemple, si une mise à jour automatique 

des fichiers a été effectuée, il faut que les applications 

clientes se mettent à jour pour bénéficier de la nouvelle structure 


des fichiers. Pour forcer cette mise à jour, il suffit de définir la 

version en cours de déploiement comme étant la version minimale 

autorisée à fonctionner. Lors du lancement de l'application client, 

l'utilisateur sera forcé de se mettre à jour. 

Gestion des utilisateurs connectés 

La gestion des utilisateurs connectés permet d'administrer les applications 

très simplement. Lors du déploiement de l'installation de 

référence, une application spécifique est déployée : WDAdminExe. 

Cette application est présente dans le sous-répertoire INSTALL du 

répertoire d'installation référence. 

Cette application permet de : 

• afficher les utilisateurs qui utilisent actuellement l'application. 

Pour chaque utilisateur, différentes informations sont disponibles : 

machine, adresse IP, date et heure de connexion, version utilisée. 

Ces informations sont disponibles dans l'onglet "Utilisateurs" de 

WDAdminExe. 

• contrôler l'application à distance. Le contrôle distant de l'application 

permet d'interdire la connexion, d'avertir d'un arrêt 

imminent de l'application ou de forcer l'arrêt. L'utilisateur est 

ainsi averti, par un message personnalisable, qu'il doit sauver ses 

modifications avant arrêt. Le contrôle à distance est particulièrement 

utile lors d'une mise à jour critique de l'application ou de 

la base de données attenante. 

Fichiers installés 

Le paramétrage des fichiers installés permet de définir les fichiers 

qui seront ajoutés à l'installation et surtout où ils seront installés. 

Le répertoire des différents fichiers peut être défini en utilisant 

des constantes prédéfinies : 

• : chemin d'installation de l'application, 

• : lecteur d'installation, 

• : chemin de Windows, 

• : chemin d'installation des fichiers de données, 

• : répertoire "Program Files". 

Par défaut, WinDev liste et intègre les fichiers nécessaires pour 

l'application : exécutables, fichiers de configuration (.ini), dépendances, 

etc. 

Il est possible d'ajouter d'autres fichiers dans la liste des fichiers 

installés : par exemple, si l'application utilise une dll particulière, 

il est possible d'inclure ce fichier pour qu'il soit automatiquement 

installé avec l'application. 

Pour chaque fichier, il est possible de définir si : 

• un raccourci doit être créé lors de l'installation. Les options 

de création de raccourci sont disponibles dans la fenêtre de 

propriétés d'un fichier. 

• le fichier doit être installé sur le poste client. 

• le fichier doit être installé sur le poste serveur. 


Répertoire d'installation 

Le répertoire d'installation définit le répertoire par défaut dans 

lequel l'application sera installée. 

Différentes options d'utilisation plus avancées sont également 

proposées. Il est par exemple possible d'écrire des informations 

dans un fichier .INI, dans la base de registre, etc. 

Paramètres des bases de données 

Ces options permettent d'intégrer des éléments optionnels pour 

paramétrer les bases de données. 

Il est possible de paramétrer la modification automatique des 

fichiers. Cela permet de modifier les fichiers de données directement 

chez le client. Lors de l'installation ou de la mise à jour de 

l'application, l'installation va vérifier si la structure des fichiers 

en exploitation est la même que celle définie dans l'analyse. Si 

la structure diffère, la modification automatique des fichiers est 

lancée. 

Il est également possible de choisir d'indexer les fichiers HyperFileSQL 

présents dans l'installateur uniquement lors de l'installation. Cela 

permet d'offrir une installation moins volumineuse. 

L'accès à la base de données peut être configuré directement 

depuis l'installateur, en cochant l'option "Configurer l'accès à la 

base de données de l'application". 

L'assistant affiche alors toutes les connexions qui ont été définies 


Déploiement (SUITE) 

Choisir le type de déploiement adapté à une 

application (SUITE) 

dans l'analyse. Pour chacune de ces connexions, il est possible 

de : 

• conserver les paramètres tels qu'ils ont été définis dans l'analyse. 

• utiliser les paramètres donnés dans le fichier .wer. Le fichier 

.wer est le fichier de description d'une réplication. Tous les paramètres 

de connexion à la base de données sont donc spécifiés 

dans ce fichier. 

• définir les paramètres de connexion. 

• proposer la saisie des paramètres lors de l'installation. Dans ce 

cas, c'est l'utilisateur ou l'administrateur qui spécifiera la localisation 

des données pendant l'installation de l'application. Il est 

possible de spécifier des valeurs par défaut. 

• indiquer que les paramètres correspondent aux paramètres du 

serveur HyperFileSQL installé, si l'installation d'un serveur a été 

autorisée dans l'installateur. 

Look de l'installateur 

Pour que l'installateur soit un peu plus personnalisé, il est possible 

d'y inclure une image, un logo. Pour cela, il suffit, sur le plan 

"Titre et Décor", de cliquer sur le bouton "Décor" et de renseigner 

l'image souhaitée. 

Si l'installation doit effectuer des opérations vraiment spécifiques, 

il est possible d'adapter et de personnaliser totalement 

l'installation. Les sources de l'installateur sont disponibles dans le 

répertoire "Exemples" de WinDev. Ce projet est bien évidemment 

en WLangage. 

Live update par programmation 

La mise à jour d'une application par le live update s'effectue lors 

du relancement de l'application. Mais il est possible qu'une application 

s'exécute en permanence et ne soit jamais relancée. Dans 

ce cas, le WLangage dispose des fonctions AppliXXX permettant 

de savoir si une mise à jour est disponible et d'appliquer cette 

mise à jour : 

• la fonction AppliMajDisponible indique si une mise à jour est 

disponible pour l'application. 

• la fonction AppliDéclencheMAJ lance la mise à jour de l'application. 

// Une mise à jour est-elle disponible ? 

SI AppliMAJDisponible() ALORS 

// Lancement de la mise à jour 

AppliDéclencheMAJ() 

FIN 

Astuce : 

La fonction AppliChangeParamètre permet de changer les paramètres 

de l'installation automatique : par exemple le chemin de 

l'installation de référence. 

WDInst 

Pour paramétrer plus précisément encore une installation, il est 

possible d'utiliser l'outils WDInt. Cet outil est accessible via le 

menu "Outils .. WDInst". 

Il est possible de proposer à l'utilisateur une installation complète, 

minimale ou personnalisée avec certaines fonctionnalités obligatoires 

et des fonctionnalités optionnelles. 


Déploiement WebDev 

Personnalisation de la page indiquant la 

mise à jour du serveur 

Un site internet évolue, tant au niveau du contenu 

que de l'interface. La mise à jour est donc un élément 

fréquent et récurrent de la vie d'un site. 

Ce sujet montre deux aspects de la mise à jour que 

WebDev simplifie : 

• la mise à jour de pages à chaud. 

• la personnalisation de la page indiquant une mise 

à jour. 

Mise à jour de pages à chaud 

La mise à jour à chaud de pages d'un site WebDev permet de modifier 

une page ou plusieurs pages alors que le site reste accessible 

pour les internautes. 

Par exemple, une page affichant la promotion du jour se doit 

d'être mise à jour de façon quotidienne, sans pour autant mettre 

le site en maintenance à chaque fois. 

Personnalisation de la page 

de mise à jour 

La page affichée lors de la mise à jour d'un site WebDev 

est entièrement personnalisable. Il est donc possible de 

la mettre au gabarit du site, d'afficher un logo de société 

ou encore d'afficher un message personnalisé. 

Pour personnaliser ce message, il suffit d’utiliser l’administrateur 

WebDev depuis le serveur. Cet administrateur 

est installé par défaut avec le serveur d'applications 

WebDev. 

Dans l'onglet "Administration", un clic sur le bouton "Erreurs" permet 

d'afficher la fenêtre de personnalisation des messages d'erreurs. 

La personnalisation des messages d’erreurs peut se faire pour 

tous les sites ou site par site. Il est également possible de choisir 

d'afficher toujours la même page d’erreur quelle que soit l’erreur 

ou alors de gérer indépendamment chaque erreur. 

Pour personnaliser un message d’erreur, il est possible de : 

• afficher un message personnalisé, 

• indiquer une page HTML à afficher en cas d’erreur. 

Pour personnaliser le message indiquant que le serveur est en 

cours de mise à jour, il suffit de : 

• sélectionner l'erreur "ERR_UPDATING_SERVER", 

• indiquer la page qui devra être affichée en cas de mise à jour 

du site, 

• appliquer les modifications. 


Pour mettre à jour à chaud une page d'un site WebDev, il suffit 


• sélectionner les pages souhaitées dans le treeview, 

• sélectionner l'option "Déployer" du menu contextuel, accessible 

via le clic droit. 

Remarque : 

Si une modification intervient dans un code global (projet, collection 

de procédures, ...) il est nécessaire de redéployer l'intégralité 

du site. 

Le site est alors obligatoirement rendu momentanément indisponible 

pour les internautes. 

Dans ce cas, WebDev affiche automatiquement une page aux 

internautes qui tente d’accéder au site indiquant que le serveur 

est en cours de mise à jour. 


Déploiement mobile 

Mise à jour d'une flotte de terminaux 

mobiles 

l'application par Internet". Plusieurs paramètres doivent ensuite 

être renseignés : 

• la fréquence de vérification des mises à jour. Pour que l'application 

contrôle la présence de mise à jour à chaque lancement, 

il suffit d'indiquer 0 en nombre de jours. 

• l'adresse à laquelle la mise à jour est disponible. 

Ce sujet présente la mise en place d'une solution de 

mise à jour automatique de terminaux mobiles. 

Déploiements mobiles 

Le déploiement d'applications mobiles est accessible via le menu 

"Atelier .. Créer la procédure d'installation". 

WinDev Mobile propose 3 types de déploiement : 

• copie de l'exécutable et de ses dépendances directement sur 

le Pocket PC. Cette option est surtout utile en phase de tests en 

réel, pour tester l'exécutable sur le terminal. 

• création de l'installation MSI pour PC. L'installation s'effectue 

depuis un PC et installe l'application mobile sur le terminal via 

ActiveSync ou via le gestionnaire d'appareil mobile si le PC est 

sous Vista. Le Pocket PC doit donc être relié au PC pendant l'installation 


• génération d'une installation pour appareil mobile au format 

CAB.Il est nécessaire de copier l'install sur le Pocket PC, soit par 

une SDCard, soit via le câble USB, soit par téléchargement direct 

depuis Internet par exemple. 

L'installation au format .cab apporte deux avantages : 

• il est possible d'installer l'application sans que le terminal mobile 

ne soit relié au PC. Il est par exemple possible de télécharger un 

fichier .cab sur un SmartPhone. 

• si le matériel a une connexion Internet, il est possible de 

mettre en place le live update dans les applications mobiles. Ce 

live update sera alors géré automatiquement comme pour une 

application WinDev. 

Mise en place du live update 

Dans un premier temps, il convient de générer l'installation de 

l'application mobile au format .cab. Pour activer le live update, il 

suffit simplement de cocher l'option "permettre la mise à jour de 

Serveur de mise à jour 

Le serveur qui héberge la mise à jour doit bien sûr disposer de : 

• un accès FTP pour transférer depuis WinDev Mobile la mise à 

jour générée. 

• un accès HTTP pour que les applications mobiles puissent récupérer 

leur mise à jour. 

Pour cela il faut définir le répertoire dans lequel est copiée la 

mise à jour comme étant un répertoire virtuel. La définition d'un 

répertoire virtuel se définit au niveau du paramétrage du serveur 

Web (IIS, Apache, ...). 

À la fin de la création de l'installation au format CAB, WinDev 

Mobile propose automatiquement de mettre à jour l'installation 

sur le serveur de référence. 

WinDev Mobile génère 3 fichiers : 

• un fichier .cab qui contient l'installation de l'application 

mobile. 

• un fichier .cab qui contient le framework de WinDev Mobile. 

• un fichier .wx qui gère les versions. 

Remarque : 

Il est nécessaire que l'extension .wx soit reconnue dans les types 

MIME sur le serveur Web. L'ajout d'une extension comme type MIME 

se définit dans le paramétrage du serveur Web. 

Ces fichiers doivent être mis à jour sur le serveur. Il suffit d'indiquer 

les paramètres du serveur FTP sur lequel la mise à jour 

sera copiée. 

Mise à jour sur le terminal 

Au lancement de l'application mobile sur le terminal, l'application 

propose de vérifier si une mise à jour est disponible : le centre de 

contrôle des applications est alors automatiquement lancé. 

Ce centre de contrôle vérifie si une mise à jour est disponible et 

propose de l'installer. L’application est ainsi automatiquement 

mise à jour. 

Le centre de contrôle des applications est installé automatiquement 

sur le mobile en même temps que le framework WinDev Mobile. 

Remarque : 

En cas de modification de la structure de l’analyse, la modification 

automatique est automatiquement exécutée sur les fichiers de 

données des terminaux mobiles. 





Robot de surveillance 

Configurer la surveillance d'une 

application critique 

Pour mettre en place la surveillance d'une application WinDev, 2 

étapes sont nécessaires : 

• dans l’application, il faut signaler au robot que l’application 

est active. 

• dans le robot, il faut paramétrer un contrôle qui surveille régulièrement 

que l’application soit active. 

Paramétrage de l'application 

Pour signaler au robot que l'application est active, 

il suffit d'utiliser le composant RobotScheduler, livré 

en standard dans WinDev. 

Ce composant dispose de deux procédures permettant 

de signaler l'activité de l'application : 

• SignalerActivite : cette procédure permet de 

gérer de façon manuelle le signalement de l'activité 


Il est conseillé d'utiliser cette procédure si un gros 

traitement doit être surveillé sur une application qui 

n'est pas forcément exécutée en permanence. 

Il suffit d'appeler une fois la procédure avant le 

traitement, pour marquer le début du signalement, 

puis une seconde fois en fin de traitement, en indiquant 

au robot de ne plus surveiller l'application 

pour l'instant. 

Le robot de surveillance est une application qui surveille 

en permanence des éléments demandés : applications 

WinDev, serveurs Web, serveurs HyperFileSQL, ... 

Si une défaillance est détectée, le robot de surveillance 

déclenche alors automatiquement une alerte : 

• dans la messagerie de WinDev, 

• par email. 

Il est également possible de déclencher un exécutable 

spécifique lorsqu'un contrôle est en erreur. Cela permet 

par exemple d’envoyer un SMS, de prévenir par 

téléphone, voire même de relancer un serveur. 

Mise en place d'un contrôle 

d'application 

// Début de la surveillance par le 

robot 

// Si le traitement est trop long, 

// le robot le signalera 

SignalerActivite(… 

fRepExe()+["\"]+"Activite.ini",… 

"Activite", "JeFonctionne") 

// Traitement critique à surveiller 

// ... 

// Fin de la surveillance par le robot 

SignalerActivite(… 


"Activite", "JeFonctionne", Faux) 

La procédure SignalerActivite accepte en paramètre : 

• le chemin du fichier .ini. En effet, le robot, pour contrôler que 

l'application est toujours en activité, lit un fichier .ini. L'application 

doit simplement écrire régulièrement dans ce fichier .ini. 

• la section du fichier .ini. 

• le mot-clé du fichier .inI. 

• l'indicateur de début ou fin de surveillance : il suffit d'indiquer 

Vrai pour que le robot active la surveillance de l'application, Faux 

pour que le robot stoppe la surveillance. 

• SignalerActivite_Automatique : cette procédure permet de 

signaler de façon automatique que l'application est toujours 

active. 


Il est conseillé d'utiliser cette procédure pour surveiller qu'une 

application qui tourne en permanence soit toujours active. 

// Signalement de l'activité 

// toutes les 2 minutes 

SignalerActivite_Automatique(… 


"Activité","JeFonctionne", 120) 

La procédure SignalerActivite_Automatique accepte en paramètre 

: 

• le chemin du fichier .ini. 

• la section du fichier .ini. 

• le mot-clé du fichier .inI. 

• la temporisation entre deux signalements d'activité. Par exemple, 

pour que l'application signale son activité toutes les 2 minutes, il 

suffit d'indiquer 120 secondes. 

Le fichier .ini doit bien sûr être accessible aussi bien par l'application 

que par le robot de surveillance. 

Il est donc conseillé d'utiliser un répertoire partagé, de préférence 

sur le poste où tourne l'application. L'écriture dans un fichier .ini 

est en effet beaucoup plus rapide en local qu'en réseau. 

Paramétrage du contrôle du robot 

Pour paramétrer un contrôle dans le robot, il suffit d'utiliser le 

moniteur de surveillance. Ce moniteur est livré en standard avec 

WinDev. 

La création d'un contrôle est accessible via le menu contextuel 

de la table (clic-droit) ou par l'icone "Ajouter un contrôle" de la 

barre d'outils. 

Paramètres généraux 

Pour contrôler une application WinDev, il suffit de sélectionner 

comme type de contrôle "Activité d'une application WinDev". 

Il est possible de paramétrer les tranches horaires d’exécution, les 

jours d’exécution. Cela permet par exemple de mettre en place 

la surveillance d'application uniquement lorsque personne n'est 

sur le site (week-end, nuit). 

Enfin, il est possible de paramétrer le message d'erreur : 

• la gravité de l'erreur 

• les messages personnalisés. 

• les destinataires des messages. 

Notre astuce : 

Pensez à renseigner une "Solution/Aide" sur les contrôles critiques, 

en indiquant par exemple où se situe le serveur ou comment redémarrer 

l'application. Ces informations seront fournies à tous les 

destinataires dans le message d'erreur envoyé par le robot. 

Il est également possible de définir un programme à lancer pour 

solutionner le problème. Par exemple, dans le cas d'une surveillance 

d'une machine serveur, il est possible de lancer un exécutable 

charger de redémarrer le serveur. 

Paramètres spécifiques 

Dans les paramètres spécifiques, il convient d'indiquer les informations 

sur l'application. Ces informations permettent au robot 

d'envoyer un message clair en cas de problème : quelle application 

est en erreur ? sur quelle machine ? ... 

Ensuite, il est nécessaire d'indiquer les informations sur le fichier 

d'activité .ini où l'application écrit. Il suffit de renseigner les 

paramètres indiqués dans l'appel à la procédure SignalerActivite_ 

Automatique. 


Il est possible de désactiver temporairement un contrôle. Il suffit 

de décocher l'option "Contrôle activé" : cela peut servir en phase 

de maintenance du serveur, ou de debug d'application. 


Remarque : 

Le robot de surveillance permet de contrôler différents éléments 

: 

• serveur d'application WebDev, 

• serveur de base de données, 

• serveur NNTP, 

• serveur SMTP, 

• sites, 

• espace disque, 

• ... 

Le "délai entre deux contrôles" doit correspondre au délai passé 

en paramètre de la fonction SignalerActivite_Automatique dans 

l'application à surveiller. 


databinding 

Deux exemples concrets d'utilisation du 

DataBinding 

En version 14, WinDev propose le DataBinding entre 

les champs et les variables du code. 

Chaque champ peut être relié à une rubrique de fichier 

ou bien à une variable : une structure, un objet, … 

Le DataBinding permet d’éliminer simplement des 

centaines de lignes de code. 


Le projet utilisé pour illustrer ce sujet est "WD Databinding" , livré 

en standard dans WinDev. 

Remplissage de champs depuis 

une structure 

Liaison des champs 

Ensuite, il faut réaliser la fenêtre qui va afficher les informations 

de la structure. Pour qu'un champ donné affiche le contenu d'une 

variable de la structure, il est nécessaire de lier ce champ à cette 

variable. Cette opération doit être effectuée pour chaque champ 

correspondant à une variable de la strucutre. 

Pour lier un champ à une variable de structure, il suffit de : 

• ouvrir la fenêtre de description du champ sur l'onglet "Liaison"; 

par exemple, sur le champ "SAI_PRENOM". 

• sélectionner "Variables" parmis les types de liaison disponibles 

(fichier, requête, ...), 

• sélectionner la structure souhaitée. Dans l'exemple, il s'agit de 

gcvMaStructure, 

• sélectionner la variable à lier au champ; par exemple, sPrénom. 

Déclaration d'une structure 

Dans un premier temps, il convient de déclarer une structure 

permettant de stocker les informations souhaitées; dans la fenêtre 

de 'FEN_PRINCIPALE" de l'exemple, il s'agit des informations 

d'un contact. 

// Déclaration de la structure 

STCONTACT est une structure 

sNom est une chaîne 

sPrénom est une chaîne 

sDateNaissance est une chaîne 

sCommentaires est une chaîne 

FIN 

Il suffit alors de déclarer une variable globale de cette structure. 

C'est cette variable globale qui sera utilisée comme source du 

DataBinding. 

// Contact en cours 

gvcMaStructure est un STCONTACT 

Remarque : 

Dans l'exemple "WD Databinding", la déclaration de la structure 

et de la variable est faite en une seule fois. Cette syntaxe peut 

être utilisée uniquement si la structure est utilisée par une seule 

variable. 

gvcMaStructure est composée de 

sNom est une chaîne 

sPrénom est une chaîne 

sDateNaissance est une chaîne 

sCommentaires est une chaîne 

FIN 


Il est possible de créer automatiquement tous les champs d'une 

variable structure en une seule fois. Pour cela, il suffit de : 

• ouvrir l'explorateur de projet si nécessaire par le menu "Affichage 

.. Barre d'outils .. Explorateur de projet". 

• dérouler les informations de la fenêtre souhaitée. 

• sélectionner "Variables". 

• faire un Drag and Drop de la variable globale depuis l'explorateur 

directement dans la fenêtre. 

Remplissage des champs depuis la structure 

Une fois les champs liés à la variable structure, il suffit d'appeler 

la fonction WLangage SourceVersEcran (ou SourceVersPage s'il 

s'agit d'un projet WebDev). 


Cette procédure attend en paramètre : 

• le nom de la fenêtre contenant les champs à remplir, 

• le nom de la source pour laquelle les champs liés seront mis 

à jour. 

// Mise à jour des champs liés à gcvMaStructure 

SourceVersEcran(FEN_PRINCIPALE, … 

"gcvMaStructure") 

Remarque : 

Si de nouveaux membres apparaissent dans la structure, il suffit 

d'ajouter un champ dans la fenêtre et de le lier au nouveau membre. 

Aucune modification de code n'est nécessaire. 

Liaison de la table 

Ensuite, il faut lier la table à la variable tableau contenant les 

informations à afficher. 

Pour créer une table basée sur une variable de type tableau, il 

suffit de : 

• insérer un nouveau champ table (via le menu "Insertion .. Champ 

.. Table" par exemple). 

• indiquer que la table doit "Afficher des données d'une variable 

existante". 

• choisir la variable de type tableau qui contient les informations 

à afficher. 

• sélectionner les colonnes qui seront visibles dans la table. 


Remplissage de la structure depuis les champs 

La récupération dans la structure des informations contenues dans 

les champs s'effectue aussi simplement que le remplissage de ces 

champs. Il suffit d'appeler la fonction WLangage EcranVersSource 

(ou PageVersSouce s'il s'agit d'un projet WebDev). Cette procédure 

attend en paramètres : 

• le nom de la fenêtre contenant les champs à remplir, 

• le nom de la source pour laquelle les variables seront mises à 

jour. 

// Mise à jour de la structure gcvMaStructure 

EcranVersSource(FEN_PRINCIPALE, … 

"gcvMaStructure") 

Remplissage d'une table depuis 

une classe 

L'exemple de remplissage de table depuis une classe s'appuie 

sur la fenêtre "FEN_DATABINDING_CLASSES" de l'exemple "WD 

DataBinding". Le remplissage d'une zone répétée, d'une liste, etc. 

depuis une classe ou une structure s'effectue de la même façon 

que pour une table. 

Déclaration d'un tableau de classes 

Dans un premier temps, il convient de déclarer le tableau de 

classe qui servira de source à la table. Dans l'exemple, il s'agit du 

membre ListeContact de la classe CListeContact. 

// Tableau de CContact 

gclMaListeDeContacts est un tableau de … 

CContact dynamique 

Remarque : 

Pour lier une table existante à une variable tableau, il suffit 


• modifier, dans l'onglet "Contenu", la combo "Source parcourue" 

en indiquant la variable de type tableau à afficher. 

• modifier la combo "Valeur mémorisée" qui indique la variable 

mémorisée pour la ligne courante. 

• modifier la liaison de chaque colonne. 


Développement spécifique 

Développer une application WinDev pour 

une utilisation sur Asus EEE-Top 

L'EEE-Top ("Easy to learn, work and play") est un PC 

tout-en-un tactile commercialisé par Asus. 

Ce PC possède un écran 16/9 pour une résolution 

de 1377x768. L'ordinateur complet tient dans l'écran 

LCD. 

WinDev permet de développer facilement des applications 

pour ce périphérique. 


Le projet "WD Voyages CE", fourni avec ce support de cours, est 

un exemple d'application dédiée à une utilisation sur EEE-Top. Il 

est cependant possible de l'utiliser sur toute machine Windows. 

Conseils de développement 

L'EEE-Top est une plateforme spécifique qui nécessite de porter une 

attention particulière lors du développement et particulièrement 

au niveau de l'IHM. 

En effet, même si cette plateforme est fournie avec clavier et 

souris, l'utilisation principale qui en est faite est une utilisation 

tactile. Les conseils donnés ci-après sont donc essentiellement 

destinés aux applications 100% tactiles. 

Taille de la fenêtre 

Premier point à prendre en compte, la taille de l'écran. L'EEE-Top 

dispose d'un écran format 16/9 d'une résolution de 1366x768 pixels. 

Pour gérer cette taille d'écran dans un projet, deux possibilités 

sont offertes : 

1- soit le projet est destiné uniquement à générer une application 

pour EEE-Top. Dans ce cas, il est préférable de spécifier la taille 

préférentielle des fenêtres directement pour 

le projet. Pour cela, il suffit de : 

• ouvrir la fenêtre de description du projet, 

par le menu "Projet .. Description du 

projet". 

• cliquer sur le bouton "Taille des écrans" 

de l'onglet "Style". 

• saisir une taille d'écran personnalisée; 

dans notre cas 1366x768. 

• valider les modifications. 

De cette façon, chaque nouvelle fenêtre 

créée aura automatiquement les dimensions 

requises pour une application EEE-Top. 

2- soit le projet est destiné à générer différentes 

applications pour différentes plateformes. 

Dans ce cas, il est préférable de 

créer un modèle de fenêtres aux dimensions 

de l'EEE-TOP. Il suffit alors, à la création 

d'une nouvelle fenêtre, d'indiquer qu'elle 

est basée sur le modèle. 

Taille de la police 

L'affichage par défaut d'un EEE-Top est en 

grande police (120ppp, soit environ 125 % 

de la taille normale). Cela signifie que les 

polices peuvent paraître "légèrement plus 

grosses" sur l'EEE-Top par rapport aux polices 

du poste de développement. 

Il faut donc toujours garder à l'esprit ce 

"grossissement" lors de la définition des 

styles dans WinDev. 


Taille des boutons 

Lors d'une utilisation tactile, la précision du clic est largement 

moindre que lors d'une utilisation avec une souris ou un stylet. 

Les boutons de taille standard (80x24) et inférieurs sont donc à 

proscrire au maximum. 

L'utilisation de "gros" bouton est largement préférable. 

Saisie de texte 

Dans une utilisation 100% tactile, l'utilisateur ne dispose d'aucun 

clavier pour saisir des informations, effectuer des recherches, 

etc. 

Pour palier ce problème, WinDev dispose d'un composant livré en 

standard : le composant "WD Ecran Tactile". 

Le texte indicatif est disponible dans l'onglet "Aide" de la fenêtre 

de description du champ de saisie. 

Et pour le reste ... 

Hormis ces conseils pratiques pour "bien démarrer", le développement 

d'applications pour EEE-Top est tout à fait semblable à 

un développement classique : 

• toutes les fonctionnalités du WLangage sont disponibles. 

• l'utilisation d'une base HyperFileSQL Classic est possible. 

• ... 


Ce composant permet d'afficher différents types de clavier (alphabétique, 

numérique, complet) pour permettre la saisie sur écran 

tactile. 

Dans l'exemple "WD Voyages CE", le clavier est activé lors de l'entrée 

dans le champ de saisie de recherche. Il suffit alors de taper 

les premières lettres de la recherche : à chaque lettre tapée, 

l'affichage est filtré par rapport à la recherche en cours. 

Dans tous les cas, il est conseillé d'éviter au maximum la saisie 

par l'utilisateur dans ce type d'application: 

• la saisie par clavier virtuel est adaptée pour quelques caractères, 

mais reste non pratique pour saisir de longs textes. 

• le clavier virtuel (qui nécessite lui aussi de gros boutons) occupe 

une place non négligeable dans l'interface (environs 40% de l'écran 

en hauteur et toute la largeur). 

Il est préférable de proposer à l'utilisateur des choix prédéfinis, 

des filtres, par l'intermédiaire de champs sélecteurs, interrupteurs 

ou liste par exemple. 

L'idéal, dans un souci de confort et d'accessibilité, est que l'utilisateur 

arrive aux informations souhaitées en 4 ou 5 touches 

maximum. 

Texte indicatif 

Si l'utilisation d'un champ de saisie est indispensable, par exemple 

le champ de recherche d'activité dans notre application "WD 

Voyages CE", l'utilisation des textes indicatifs est recommandée. 

Le texte indicatif est ce petit libellé affiché dans le champ de 

saisie lorsque celui-ci est vide et qui disparaît automatiquement 

lors de l'entrée en saisie dans le champ. Il permet de donner une 

indication supplémentaire sur ce qui peut ou ce qui doit être saisi 

dans le champ. 

Dans le cas d'applications pour EEE-Top, le texte indicatif permet 

avantageusement de remplacer le libellé du champ de saisie pour 

offrir une IHM plus épurée et donc plus agréable. 


Géolocalisation 

Géolocaliser une flotte de téléphones 

mobiles 

Cette technologie consiste à repérer les antennes les plus proches du 

portable. Ensuite, la distance entre chaque antenne et le portable 

est déduite d’après la vitesse que mettent les données pour faire 

un aller-retour ce qui permet d'en déduire la position. 

Évidemment, le propriétaire du portable doit donner son accord 

préalable pour être localisé. Cet accord n’est à donner qu’une 

seule fois. 

Repérer le technicien le plus proche du lieu d'intervention, 

localiser un véhicule en panne, calculer un 

itinéraire optimisé, les besoins de géolocalisations 

sont importants. Une des solutions est d'utiliser la 

géolocalisation cellulaire, c'est-à-dire la localisation 

d'un téléphone portable. 

L'exemple présente la mise en œuvre de la solution 

de géolocalisation pour les mobiles Orange© par le 

service "Location API". 

Important : pour utiliser cette fonctionnalité, vous devez disposer 

d'un contrat avec la société Orange. Retrouvez plus de détails sur 

cette page : 

http://www.orangepartner.com/windev 


Le projet utilisé pour illustrer ce sujet est le composant "WD 

Geolocalisation en association avec Orange". Ce composant propose 

différentes méthodes permettant de localiser un téléphone 

mobile Orange. 

Le composant "WD Geolocalisation en association avec Orange" 

nécessite une clé. Cette clé est fournie par Orange lors de l'activation 

de ce service. 

Ce projet est présent sur le DVD fourni avec ce support de 

cours. 


Le système de géolocalisation utilisé est un service commercialisé 

par Orange. Ce service permet de localiser un portable donné où 

qu'il soit et ce partout en France. Bien sûr, le portable doit être 

allumé et avoir accès au réseau. 

Ce service fonctionne avec une précision de 50 à 150 mètres en 

ville et de 150 mètres à 3 kilomètres en zone rurale. 

La technologie utilisée s’appelle "Cell-ID", pour "localisation 

cellulaire". 

Utilisation du composant 

Dans le projet exemple, le composant de géolocalisation a déjà été 

intégré. Pour rappel, l'intégration d'un composant dans un projet 

est accessible via le menu "Atelier .. Composant .. Importer un 

composant dans le projet". 

Dans ce projet, la géolocalisation se déroule en deux étapes : 

• Saisie du numéro de téléphone à localiser dans le champ de 

saisie. 

• clic sur le bouton "Localiser" pour lancer la géolocalisation 

proprement dite. Une fois les coordonnées récupérées à l'aide du 

service Orange, le portable peut être positionné sur une carte, 

par exemple via Google Earth. 

Localisation du mobile 

La localisation du mobile s'effectue par la fonction 

DemandeLocalisation fournie par le composant. Cette procédure 

accepte en paramètres : 

• la clé d'identification fournie par orange pour utiliser le service 

de géolocalisation. Ce numéro est fourni par Orange lors de la 

souscription au service de géolocalisation. Cette clé est à renseigner 

dans la constante CLE_ORANGE de l'application. 

• le numéro de mobile qui doit être localisé. Ce numéro doit 

être au format "336xxxxxxxx" ("336" suivi des 8 derniers chiffres 

du numéro). 

// Demande la localisation du mobile 

// en indiquant la clé Orange 

DemandeLocalisation(… 

CLE_ORANGE,"336xxxxxxxx") 

Une fois le numéro demandé localisé, le service de géolocalisation 

renvoie la position du mobile sous la forme d'une latitude et d'une 

longitude. Ces coordonnées peuvent alors être récupérées par les 

fonctions getLatitude et getLongitude du composant. 

// Récupération de la latitude et longitude 

// du mobile localisé 

sLatitude = getLatitude() 

sLongitude = getLongitude() 

En cas d'erreur (ou de refus de géolocalisation), un message d'erreur 

clair peut être obtenu par la fonction getErreurInformation. 



Annexes 

TDF TECH 2009 - www.pcsoft.fr - I

Annexe A 

Quelques commandes du WLangage 

Attention : Le lexique ci-dessous n’est qu’un extrait des possibilités du langage de WinDev, WebDev et WinDev Mobile. La lecture 

des manuels fournis reste incontournable. Ne sont présentées ici que les commandes nécessaires à la bonne compréhension de cette 

formation. 

Commandes de gestion de fichiers 

Commande / Syntaxe 

But 

EcranVersFichier 

FichierVersEcran 

HAjoute(NomFichier) 

HCréationSiInexistant(NomFichier) 

HErreurDoublon() 

Renseigner le buffer fichier d’après les données saisies 

par l’utilisateur dans la fenêtre. 

Initialiser une fenêtre d’après les dernières valeurs lues 

dans le fichier. 

Ajouter dans le fichier l’enregistrement préparé en 

mémoire. 

Ouvrir le fichier en le créant à vide auparavant s’il 

n’existait pas sur disque. 

Tester le compte-rendu renvoyé par le moteur de base de 

données en cas de tentative de création de doublon. 

HErreurIntégrité() 

HFiltre(NomFichier,Clé,Valeur) 

HLitDernier(NomFichier, Clé) 

HLitPrécédent(NomFichier, Clé) 

HLitPremier(NomFichier,Clé) 

HLitRecherchePremier(NomFichier,... 

Clé, Valeur) 

Tester le compte-rendu renvoyé par le moteur de base de 

données en cas de tentative d’écriture d’enregistrement 

ne respectant pas les contraintes d’intégrité. 

Filtrer les enregistrements du fichier dont la clé indiquée 

correspond à la valeur choisie. 

Se positionner sur le dernier enregistrement du fichier 

selon la clé spécifiée et charger l’enregistrement en 

mémoire. 

Se positionner sur l’enregistrement précédent du fichier 


mémoire. 

Se positionner sur le premier enregistrement du fichier 


mémoire. 

Rechercher le premier enregistrement du fichier dont la 

clé indiquée correspond à la valeur choisie, puis charger 

l’enregistrement en mémoire. 

II - TDF TECH 2009 - www.pcsoft.fr

HLitSuivant(NomFichier,Clé) 

HModifie(NomFichier) 

HRaz(NomFichier) 

HSupprime(NomFichier) 

Se positionner sur l’enregistrement suivant du fichier 


mémoire. 

Réécrire l’enregistrement courant du fichier avec les 

valeurs stockées en mémoire. 

Remettre à zéro (réinitialiser) l’enregistrement du 

fichier. 

Supprimer l’enregistrement courant du fichier. 

Annexes 

Compte-rendu du moteur de bases 


HEnDehors(NomFichier) 

HTrouve(NomFichier) 

Valeur 

Renvoie Vrai si on tente de lire un enregistrement audelà 

du début ou de la fin du fichier. 

Renvoie Vrai après une recherche si la recherche a 

abouti. 

Autres commandes 

Commande / Syntaxe 

DateSys() 

Erreur(“Message”) 

ExécuteTraitement(Champ,... 

Traitement) 

HeureSys() 

Info(“Message”) 

Confirmer(“Question”) 

RAZ() 

RepriseSaisie(NomChamp) 

TableAffiche(NomTable, Position) 

ListeAjoute(NomListe, chaine) 

ListeSupprime(NomListe) 

But 

Récupérer la date système au format AAAAMMJJ. 

Afficher un message d’erreur. 

Exécuter le traitement d’un champ ou d’une fenêtre. 

Récupérer l’heure système au format HHMMSSCC. 

Afficher un message d’information. 

Poser une question à l’utilisateur (la réponse est un 

booléen) . 

Remettre à zéro (réinitialiser) tous les champs de 

l’écran. 

Interrompre le traitement en cours et positionner le curseur 

sur le champ spécifié. 

Réafficher un champ table fichier (à l’écran) d’après les 

données du fichier sur disque. 

Ajouter une ligne dans un champ liste ou combo. 

Supprimer une ligne de liste ou combo. 

Les commandes sont indiquées avec la syntaxe utilisée dans les exemples réalisés. 

Certaines fonctions acceptent d’autres paramètres ; se référer à l’aide en ligne pour plus de 

d’informations. 

TDF TECH 2009 - www.pcsoft.fr - III

Annexe B 

Les principales touches de raccourci 

La liste ci-dessous présente les touches de fonction et les combinaisons de touches permettant d’accéder directement à une fonctionnalité 

de WinDev. Cette liste n’est pas exhaustive. 

Important : Sous WinDev, dans l’éditeur de fenêtres, comme dans l’éditeur de code, il est possible d’accéder simplement aux différentes 

actions disponibles grâce au menu contextuel (Il suffit de faire un clic droit à la position de la souris). 

Principales touches de raccourcis de l’éditeur de fenêtres 

Touche 

F1 

F5 

F6 

CTRL 

CTRL+C, CTRL+V, CTRL+X 

CTRL+R 

SHIFT+F9 

But 

Aide en ligne. 

Visualiser l’ordre de saisie (ordre de tabulation). 

Visualiser le nom des champs. 

Permet de sélectionner plusieurs champs à la souris. 

Copier, Coller, Couper un champ, avec ses propriétés et son 

code associé. 

Affiche ou rend invisible les règles d’alignement. 

Tester l’IHM d’une fenêtre sans exécuter les traitements. 

Principales touches de raccourcis de l’éditeur de code 

Touche 

But 

F1 

F2 

F4 

F8 

F11 

CTRL+C, CTRL+V, CTRL+X 

Aide en ligne. 

Accéder au code d’une procédure en étant positionné sur le nom 

de la procédure auparavant (CTRL + F2 pour revenir). 

Créer une procédure locale (Shift + F4 pour créer une procédure 

globale). 

Liste des procédures locales (CTRL + F8 pour la liste des 

procédures globales). 

Liste des fichiers, requêtes et rubriques. 

Copier, Coller, Couper du code. 

CTRL + « / » (pavé numérique) Mettre en commentaire (CTRL + Shift + “ / ” pour enlever les 

commentaires). 

ALT + T 

Activer la pipette pour sélectionner le nom d’un champ d’une 

fenêtre. 

IV - TDF TECH 2009 - www.pcsoft.fr

TDF Tech 2009 Support de cours - Source : www.pcsoft-windev ...

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?