Chapitre 5 : Le WLangage et la programmation

WinDev propose un langage qui comporte classiquement des variables de plusieurs types, des opérateurs et des instructions qui offrent la possibilité d’écrire des procédures et des fonctions. Il dispose de plusieurs familles de fonctions standards pour faciliter la tâche du développeur. Parmi elles, les fonctions de dessin, les fonctions HTTP, les fonctions de gestion des plannings, des fenêtres, LDAP, SAP, Wi-Fi, etc.

Les instructions et les fonctions peuvent être écrites en français, en anglais ou même en chinois. Chaque nom de fonction a son équivalent.

Nous allons décrire synthétiquement ces éléments de manière à être capable de les utiliser pour les besoins courants.

Rappelons auparavant quelques principes sur l’utilisation de variables.

I. Variable, portée ou domaine de visibilité

Pour avoir un code le plus fiable possible, il convient de déclarer les variables qui vont être utilisées dans un traitement. Cela permet au compilateur de signaler l’inexistence de déclaration ou de vérifier que certaines opérations d’affectation ou d’emploi dans des fonctions, sont possibles.

Une variable a donc un type. Il est de bonne pratique d’initialiser la variable à sa déclaration. WinDev nous facilite la tâche en initialisant une variable à une valeur naturelle selon le type : zéro pour les numériques, une chaîne vide pour le type caractère ou chaîne de caractères.

Une fois déclarée, une variable a “un espace de vie” qui est plus ou moins étendu selon qu’en plus du type nous précisons que la variable est locale ou globale.

Une variable est par défaut locale ; c’est-à-dire qu’elle n’existe que dans le traitement dans lequel elle apparaît : section de traitement, procédure, fonction. Ainsi, si le traitement appelle une fonction, la variable ne sera pas connue du code de la fonction appelée. Le seul et le meilleur moyen est de passer cette variable en paramètre de la fonction.

Si la variable est déclarée comme globale, elle est accessible par les traitements déclenchés depuis le traitement où elle a été déclarée.

Pour déclarer des variables comme étant globales, le mot-clé Global doit être indiqué avant la liste des déclarations des variables concernées. De même, pour les déclarer locales, le mot-clé Local est à placer avant la liste correspondante.

Global 
CodeClient, NumFacture sont des entiers 
Local 
cNom, cPrenom sont des chaînes

Si une variable est déclarée globale dans le code d’initialisation d’un projet, elle est connue de tous les traitements du projet.

Si une variable est déclarée globale dans une fenêtre, elle est connue de tous les traitements découlant de cette fenêtre.

Les champs d’une fenêtre réagissent comme des variables globales pour la fenêtre.

Si une variable est appelée du même nom qu’une variable définie dans un traitement de plus haut niveau, la variable du traitement courant “masque”la variable de plus haut niveau. C’est le contenu de la variable du traitement en cours qui est utilisé.

Les constantes

WinDev fournit différents fichiers qui comportent des listes de constantes. Les constantes Windows sont déclarées dans le fichier WINCONST.wl. Les limites des différents types de variables de WinDev sont dans le fichierLIMITES.wl.

Voici un extrait d’un fichier WINCONST.wl :

// définition des constantes système windows pour SendMessage à 
utiliser en WLangage  
// utilisation : EXTERNE "WINCONST.wl" 
 
CONSTANT 
  WM_NULL                        = 0x0000 
  WM_CREATE                      = 0x0001 
  WM_DESTROY                     = 0x0002 
  WM_MOVE                        = 0x0003 
  WM_SIZE                        = 0x0005 
  WM_ACTIVATE                    = 0x0006 
  WA_INACTIVE    = 0 
  WA_ACTIVE      = 1 
  WA_CLICKACTIVE = 2 
  WM_SETFOCUS                    = 0x0007 
  WM_KILLFOCUS                   = 0x0008 
  WM_ENABLE                      = 0x000A 
  WM_SETREDRAW                   = 0x000B 
  WM_SETFONT                     = 0x0030 
  WM_GETFONT                     = 0x0031 
  WM_GETDLGCODE                  = 0x0087 
  WM_NCMOUSEMOVE                 = 0x00A0 
  WM_NCLBUTTONDOWN               = 0x00A1 
  WM_NCLBUTTONUP                 = 0x00A2 
  WM_NCLBUTTONDBLCLK             = 0x00A3 
  WM_NCRBUTTONDOWN               = 0x00A4 
  WM_NCRBUTTONUP                 = 0x00A5 
  WM_NCRBUTTONDBLCLK             = 0x00A6 
  WM_NCMBUTTONDOWN               = 0x00A7 
  WM_NCMBUTTONUP                 = 0x00A8 
  WM_NCMBUTTONDBLCLK             = 0x00A9 
  WM_KEYFIRST                    = 0x0100 
  WM_KEYDOWN                     = 0x0100 
  WM_KEYUP                       = 0x0101 
  WM_CHAR                        = 0x0102 
  WM_DEADCHAR                    = 0x0103 
  WM_SYSKEYDOWN                  = 0x0104 
  WM_SYSKEYUP                    = 0x0105 
  WM_SYSCHAR                     = 0x0106 
  WM_SYSDEADCHAR                 = 0x0107 
  WM_KEYLAST                     = 0x0108 
  WM_IME_STARTCOMPOSITION        = 0x010D 
  WM_IME_ENDCOMPOSITION          = 0x010E 
  WM_AFXLAST                     = 0x037F 
  WM_PENWINFIRST                 = 0x0380 
  WM_PENWINLAST                  = 0x038F 
  WM_USER                        = 0x0400 
 
FIN

Nous pouvons créer nos propres constantes par une déclaration de la forme :

Constante 
 CtEnCours=1 
 CtResilie=2 
Fin

Comme pour les variables, les constantes ne sont connues que des traitements déclenchés en dessous du traitement où elles ont été déclarées.

Si une variable est déclarée avec le même nom qu’une constante, c’est la variable qui est utilisée dans tout son domaine de visibilité. Elle masque la constante de même nom dans son espace.

L’intérêt d’utiliser une constante dans le code, au lieu d’une valeur, se manifeste s’il faut modifier la valeur initiale.

Avec l’emploi d’une constante il suffit de modifier la valeur dans l’instruction de déclaration, sinon cette valeur est à rectifier dans toutes les lignes de code où elle a été utilisée.

II. Les types de variable

WinDev propose des types simples de variables et des types avancés ou structurés.

Les types simples sont : booléen, entier, monétaire, réel, chaîne, buffer, date, heure, dateHeure, durée, variant, numérique.

Les types avancés comprennent les tableaux, les tableaux dynamiques, les tableaux fixes, les variables composées, les buffers dimensionnés, les structures et les structures particulières qui servent à décrire les fichiers, les relations et les rubriques, de manière temporaire.

Pour déclarer une ou des variables d’un même type, la syntaxe est la suivante :

<Variable1>, <Variable 2> sont des <Type de variable>

On peut initialiser une variable lors de la déclaration, sous la forme :

<Variable1> est un(e) <Type de variable> =<Valeur>

On ne peut pas initialiser plusieurs variables dans la ligne de déclaration. Seule, la dernière variable citée est initialisée si nous mettons une valeur au bout d’une ligne de déclaration avec plusieurs variables.

Les types ont des valeurs maximales et minimales ! Si une variable dépasse ces limites, un message d’erreur est généré en mode test mais en exécution, la valeur est fausse et il n’y a pas de message.

Les valeurs limites sont récapitulées dans le fichier personnel\externe\limites.wl.

Exemple de déclaration de variables de types simples

fic est un entier 
err est un booléen = Faux 
tmp est une chaîne = "\\ServeurVIC\Echange\VP\ftpcentral.txt" 
up  est un booléen 
res est une chaîne =""

Exemple de déclaration de variables de types avancés ou structurés

RequeteSelect est une Source de Données 
 
 
TabFichiersXML2 est un tableau de chaînes 
 
StructVirementPartielCartonReserve est une Structure 
    CartNumero est une chaîne 
    CartZone est un entier 
    CartAllee est une chaîne 
    CartVerticale est un entier 
    CartPlateau est un entier 
    CartQte est un entier 
    CartBoit est une chaîne 
FIN 
 
GF_TB_ListeCartonReserve est un tableau dynamique 
 
GF_TB_ListeCartonReserve = allouer un tableau de 
0 StructVirementPartielCartonReserve 
 
 
ConnexionSQL est une Connexion 
SI HOuvreConnexion(ConnexionSQL, NomUser, MdP, NomServeur, 
NomBase, hOledbSQLServer, hOLectureEcriture) = Faux ALORS 
    FinProgramme("L’ouverture de la connexion a échoué.") 
FIN

1. Booléen

Une variable de type booléen ne prend que deux valeurs : Vrai ou Faux. La valeur Faux vaut zéro. La valeur Vrai est différente de zéro.

Exemple

BValeur est un booléen

2. Entier

Les entiers de WinDev sont codés par défaut sur quatre octets, ce qui permet de manipuler des entiers assez grands avec le type de base.

Sinon, nous pouvons choisir les types suivants :

Entier

-2*109 à 2*109

Entier sur 1 octet

-128 à 127 (incluses)

Entier sur 2 octets

-32 768 à 32 767 (incluses)

Entier sur 8 octets

-9*1018 à +9*1018

Entier non signé

0 à 4*109

Entier sur 1 octet non signé

0 à 255

Entier sur 2 octets non signé

0 à 65 535

Entier sur 4 octets non signé

0 à 4*109

Entier sur 8 octets non signé

0 à 18*1018

Le type Entier Système est disponible et s’adapte à la taille gérée par le système. Il est de 4 octets en 32 bits et de 8 octets en 64 bits.

3. Monétaire

Le type monétaire est un type important dans WinDev car il garantit la précision des calculs jusqu’à six décimales. Il est codé sur 10 octets et les valeurs extrêmes vont de + à — 600 mille milliards environ.

Exemple

MMontant est un monétaire

4. Réel

WinDev propose des réels sur 4 octets avec six chiffres significatifs ou 8 octets avec 15 chiffres significatifs. On pourra préférer utiliser ce type si la précision des décimales n’est pas importante et pour économiser un peu de place.

5. Chaîne

Les types usuels sont le caractère, pour des chaînes d’un seul caractère ou le type chaîne qui a une longueur dynamique pouvant aller jusqu’à plusieurs millions d’octets.

D’autres types existent pour la compatibilité avec différents langages. La chaîne Ansi permet de manipuler les fichiers PDF, XML, RTF. La chaîne unicode qui permet de manipuler des caractères unicode uniquement.

Par défaut, une variable de type chaîne est de longueur nulle. Elle est vide.

6. Buffer

Ce type de variable définit une zone mémoire qui peut accueillir des valeurs binaires. C’est-à-dire que la variable peut avoir toutes les valeurs de zéro à 255. Dans ce type, la valeur zéro ne représente pas le chiffre zéro mais bien la première des 256 possibilités de codage qu’offre un octet. Le chiffre zéro est représenté par la valeur 48 (en notation décimale).

Il existe un type avancé, Buffer sur, qui permet de dimensionner ce type de variables.

7. Date, Heure, DateHeure, Durée

Le type Date facilite la gestion des dates. La date est stockée sous forme AAAAMMJJ. Les opérations d’ajout ou de retranchement de jour rendent des dates valides automatiquement. Le type Date confère trois propriétés, de type entier, aux variables de ce type : l’année, le mois, le jour.

La plage de dates gérée va de 01/01/0001 à 31/12/9999.

Exemple des propriétés du type Date

dDate est une Date = ’’20161210’’ 
Info("annee",ddate..annee) donne 2016 
Info("mois",ddate..mois) donne 12 
Info("jour",ddate..jour) donne 10

Par défaut, une variable Date est égale à la date du jour.

Le type Heure permet de gérer les heures de 00:00 à 23:59. Ce type a également des propriétés : heure, minute, seconde, milliseconde.

Exemple des propriétés du type Heure

Par exemple : hMonHeure est une heure = ’’20255912’’ 
Info("heure",hMonHeure..heure) donne 20 
Info("minute",hMonHeure..minute) donne 25 
Info("seconde",hMonHeure..seconde) donne 59 
Info("milliemes",hMonHeure..milliseconde) donne 12

Le type DateHeure a les propriétés des types Date et Heure et les propriétés PartieDate qui renvoie ou modifie la date et PartieHeure équivalente pour l’heure.

Le type Durée permet de gérer facilement des différences entre variables temporelles de type Date ou Heure. Une durée a les propriétés jour, heure, minute, seconde, milliseconde.

dDateDemainMidi est une DateHeure = 
EntierVersDate(DateVersEntier(DateSys())+1)+ 12000000 
dDateMaintenant est une DateHeure =DateSys()+HeureSys() 
// supposons avant midi, 10h 59 et 40 secondes pile. 
drDiciLa est une Durée = dDateDemainMidi-dDateMaintenant 
drDiciLa..Jour=1  
Info("ecart jour",drDiciLa..Jour) //donne 1 
drDiciLa..Heure=1 
Info("ecart heure", drDiciLa..Heure) //donne 1 
drDiciLa..Minute=0 
Info("ecart minute", drDiciLa..Minute) //donne 0 
drDiciLa..Seconde=20 
Info("ecart seconde", drDiciLa..Seconde) //donne 20 
drDiciLa..Milliseconde=0 
Info("ecart milliseconde", drDiciLa..Milliseconde) //donne 0

8. Numérique

Ce type permet de garantir une précision sur la partie décimale de valeurs réelles.

Un numérique gère 38 chiffres répartis entre 32 au maximum pour la partie entière et 6 au maximum pour la partie décimale. La précision est assurée sur 6 décimales.

9. Variant

Ce type permet d’accueillir n’importe quel autre type de variable. Il permet également des interactions avec les objets ActiveX et la programmation OLE Automation.

La fonction TypeVar() permet de connaître le type de variable qui a été stocké dans un type Variant.

10. Constante Null

Cette constante permet :

• De savoir si une variante de type Variant est initialisée.
• D’affecter la valeur par défaut du type de la variable, 0 pour les numériques, une chaîne vide pour les chaînes.
• De supprimer une référence à un objet dynamique et de libérer l’espace mémoire correspondant si cet objet n’est plus référencé.
• D’initialiser une rubrique HFSQL avec la valeur par défaut indiquée dans la définition de la rubrique dans l’analyse.
• D’initialiser à vide un champ de saisie lorsque la case à cocher Null si vide est cochée dans l’ongletDétail de définition. Ceci permet de renvoyer un champ vide : il sera égal à Null. Cette valeur est détectée par le gestionnaire de requête qui ne tiendra pas compte de paramètres dont la valeur est Null.

11. Types de variable avancés

Les types avancés sont constitués par la composition de variables de types de base qui peuvent être manipulées globalement par un seul nom.

Ce sont les tableaux, les variables composées, les structures, les objets automation, les sources de données, les descriptions de fichier, les descriptions de liaison, les descriptions de rubriques et les polices.

a. Tableaux

Les tableaux sont évidemment très utiles, au moins pour gérer des groupes de cases à cocher ou des listes.

Un tableau peut être simple, fixe ou dynamique.

Le type simple est déclaré en taille, en indiquant le nombre d’éléments par dimension (jusqu’à dix dimensions). Le nombre d’éléments par dimension peut être modifié par la fonction Dimension. Celle-ci ne peut pas modifier le nombre de dimensions.

Ce type peut être utilisé dans une structure. Un tableau ne peut pas contenir de tableau.

Le type dynamique permet de créer un tableau avec un nombre d’éléments par dimension qui peut être calculé avant de dimensionner le tableau réellement. En fait, il convient de le déclarer sans dimension puis de l’allouer en mémoire avec les dimensions paramétrées.

Le tableau fixe a des dimensions qui ne pourront pas être modifiées lors de l’exécution. Ce type de tableau doit être employé pour correspondre avec des API.

Les syntaxes sont les suivantes :

TBS est un tableau de 5, 7, 3 monétaires // tableau simple avec 3 dimensions 
TBD est un tableau dynamique 
TBD = Allouer un tableau dynamique de 5, 7, 2 chaînes de caractères 
TBF est un tableau fixe de 3,3 entiers

Les tableaux peuvent être passés en paramètre à des fonctions ou procédures. Il suffit de donner le nom du tableau comme paramètre :

MaFonction(NomDuTableau).

Pour atteindre un élément d’un tableau, la syntaxe est la suivante :

mMontant=TBS[i,j,k]

ou

mMontant=TBS[i][j][k]

où i, j, k sont des entiers contenant le rang à atteindre sur la dimension.

Les éléments des tableaux peuvent être des objets définis par des classes dont les constructeurs ne doivent pas avoir de paramètre obligatoire.

b. Objets dynamiques

En général, la déclaration d’une variable réserve l’espace mémoire correspondant.

Avec les objets dynamiques comme les tableaux, les structures, les objets automation, nous pouvons différer la création en mémoire. Il y a donc l’étape de déclaration où nous précisons que la variable que nous définissons est de type dynamique. Son espace mémoire n’est pas alloué immédiatement.

Lorsque nous devons utiliser la variable, nous lui allouons l’espace désiré et nous la rendons disponible par l’instruction d’allocation.

Exemple d’utilisation d’un objet dynamique

MonTableau est un tableau dynamique // déclaration. Le mot dynamique avertit 
                                    // que la création est ultérieure. 
// Suite de traitement (sans sortir du traitement qui a déclaré  
// la variable, sinon elle est détruite). 
... 
// création réelle de l’objet 
MonTableau= allouer un tableau dynamique de 4,4 entiers

c. Variables composées et structures

Ces deux types sont du même genre. Le type Structure étend le type Variable composée car il admet des chaînes simples alors que le type Variable composée n’admet que des chaînes fixes, ASCII ou Pascal.

Le type Variable composée est à utiliser si une seule variable de ce type doit être utilisée. Si plusieurs doivent l’être, il est préférable d’utiliser le type structure.

Une variable composée sera plutôt déclarée dans le traitement l’utilisant, alors qu’une structure doit avoir une portée plus large et donc être déclarée au niveau du projet ou d’une fenêtre.

Les types admis comme membre d’une variable composée ou d’une structure diffèrent légèrement pour les chaînes et les objets.

Tableau des types autorisés :

Une variable composée ne peut pas être transmise à une fonction, alors qu’une structure peut l’être.

Nous ne pouvons pas effectuer des assignations de niveau global. Pour renseigner ou connaître les membres d’une variable composée ou d’une structure, nous devons les manipuler un par un.

Comme le tableau dynamique, la structure peut être déclarée dynamiquement.

Un tableau dynamique d’une structure doit être dimensionné immédiatement après la création de la variable du type de la structure.

Exemple de structure

// Déclaration d’une structure 
ModeleVoiture est une structure 
 Nom est une chaîne 
 Type est une chaîne 
 NbPlace est un entier 
 TTech est un tableau dynamique 
Fin 
// allocation de la structure en mode dynamique 
MonModele est un ModeleVoiture dynamique    // Déclaration de la variable 
MonModele=Allouer un ModeleVoiture    // Allocation de mémoire 
MonModele:TTech= allouer un tableau dynamique de 3 entiers  
// allocation du tableau. 
MonModele:nom=’’XYZ’’  // renseignement d’un membre 
MonModele:TTech[2]=9  // renseignement d’un élément 
Info("Mon modele "+ MonModele:nom+" a "+ MonModele:TTech[2]+" Cv ")

d. Objets automation

Un objet automation permet de gérer dans WinDev une liaison OLE avec Word, Excel ou tout autre serveur OLE.

Nous pouvons aussi le créer dynamiquement comme indiqué précédemment. Lors de l’allocation dynamique, le nom du serveur doit être indiqué, comme pour la déclaration statique.

Une fois l’objet déclaré et créé, nous pouvons utiliser les méthodes disponibles du serveur et leur indiquer les paramètres.

<NomObjetAutomation> est un objet automation <NomDuServeur> 
<NomObjetAutomation>>Methode(parametre)

Exemple d’utilisation d’un objet OLE automation

MonTexte est un objet automation Word.Application 
MonTexte>Documents>Open(NomDoc) // Ouvre le document NomDoc

e. Source de données

Une source de données permet d’affecter un identifiant à une requête ou à une vue.

Une fois créée, cette source de données se manipule comme le résultat d’une requête ou d’une vue, avec les ordres de gestion de fichier habituels.

Si une nouvelle requête utilise la même variable, l’espace occupé doit être libéré par la première requête.

<NomSource> est une source de donnees 
HexecuteRequete(<NomSource>, <Nomrequete>) 
// traitement 
HannuleDeclaration(<NomSource>)

f. Description de fichier, de relation, de rubrique

Ces types permettent de créer temporairement des fichiers et leurs liaisons, comme s’ils avaient été décrits dans l’analyse.

Les fichiers et leurs liaisons sont physiquement créés respectivement par les fonctionsHDecritFichier et HDecritLiaison. La fonction HDecritRubrique valide la description de chaque rubrique.

Ceci permet de créer des fichiers temporaires.

Exemple de création d’un fichier Client

MonFichier est une Description de Fichier 
MonFichier..Nom="CLIENT" 
MonFichier..Type=hFichierNormal 
MonFichier..CryptageFic=hCryptageStandard 
//... Autres propriétés 
 
// Description des rubriques 
CodeCli est une Description de Rubrique 
CodeCli..Nom="Code" 
CodeCli..Type=hRubTexte    // hRubText constante de WinDev 
CodeCli..Taille=5 
...                      // Autres propriétés des rubriques 
HDécritRubrique(MonFichier,CodeCli) 
// Autres rubriques 
... 
// Validation du fichier 
HDécritFichier(MonFichier)

Lors de la compilation, WinDev vérifie l’existence des identifiants. Si, dans le code, nous utilisons le mot CLIENT pour manipuler le fichier créé, le compilateur va indiquer une erreur car au moment de la compilation, CLIENT n’est pas un fichier, en supposant que ce nom n’est pas celui d’un fichier décrit dans l’analyse. Il le deviendra à l’exécution.

Pour pouvoir manipuler le fichier CLIENT comme un autre décrit dans l’analyse, il faut le déclarer comme ressource externe pour le compilateur en employant le mot-clé EXTERNE.

EXTERNE CLIENT 
Hlit(CLIENT)      // La compilation ne déclenchera pas d’erreur 
                  //car le nom est déclaré.

g. Police

Le type Police permet de créer des polices de caractères dynamiquement.

Les opérateurs

Les opérateurs sont les symboles qui décrivent une opération particulièreentre opérandes constitués de variables ou de champs.

WinDev propose les opérateurs classiques logiques, arithmétiques et de comparaison. Il propose sous une forme particulière des opérateurs binaires, de comparaison, d’indirection, d’adresse, de chaîne de caractères.

1. Opérateurs logiques

Les opérateurs logiques sont ET, OU, PAS. ET est le produit logique, OU l’addition, et PAS la négation, c’est-à-dire le résultat inverse de l’expression niée. D’un point de vue mathématique, ces opérateurs sont commutatifs. C’est-à-dire que A ET B est équivalent à B ET A.

Nous rappelons les règles :

• Vrai ET Vrai : donne Vrai ;
• Vrai ET Faux : donne Faux ;
• Faux ET Faux : donne Faux ;
• Vrai OU Vrai : donne Vrai ;
• Vrai OU Faux : donne Vrai ;
• Faux OU Faux ; donne Faux ;
• PAS Vrai : donne Faux.

Les variables numériques peuvent être testées directement en sachant que si elles ont la valeur 0, elles rendent un résultat égal à Faux. La valeur 0 est équivalent à Faux.

Il est plus rapide d’exécuter :

SI nNombre ALORS

Que

SI nNOMBRE=0 ALORS

Les variables caractères ne prenant pas la valeur numérique 0 ne peuvent pas être utilisées directement avec les opérateurs logiques.

ET et OU ont la même priorité. Il faut donc utiliser les parenthèses pour bien regrouper les conditions voulues :

A ET B OU C : donne le résultat de A ET B comparé à C.

A ET (B OU C) : donne le résultat entre A et le résultat entre B OU C.

2. Opérateurs arithmétiques

Ce sont les opérateurs classiques et leurs formes héritées du C :

• + : addition
• – : soustraction
• * : multiplication
• / : division
• ++ : incrément de 1 de la valeur (j++ <=> j=j+1), j++ est plus rapide
• — : décrément de 1 de la valeur (j — <=> j=j-1)
• += : addition puis affectation (j+=3 <=> j=j+3)
• -= : soustraction puis affectation (j-=3 <=> j=j-3)
• ˆ : élévation à la puissance

3. Opérateurs binaires

Les opérateurs binaires sont constitués de fonctions de WinDev. Depuis Windev 14, des opérateurs peuvent être utilisés à la place des fonctions.

• ET binaire équivaut à & (et commercial)
• OU binaire équivaut à |
• NON binaire équivaut à ~ (tilde)
• OU exclusif binaire équivaut à ||

Ces fonctions comparent des valeurs bit par bit et renvoient le résultat correspondant à la valeur composée par le résultat.

Exemple

ETBinaire(6,2) ou 6&2

La valeur 6, en binaire s’écrit : 110 (1*22+1*2+0*2).

La valeur 2, s’écrit 010.

Le ET binaire en comparant deux à deux les bits donne : 010 en binaire, soit 2 en base 10.

Donc ETBinaire(6,2) donne 2.

4. Opérateurs de comparaison

WinDev propose les opérateurs classiques en les complétant ou en permettant une simplification d’écriture. Le résultat des comparaisons est un booléen.

Opérateurs d’égalité :

• = : Égalité stricte
• ~= : Égalité souple
• ~~ : Égalité très souple

Opérateurs de comparaison :

• < > : Différent
• <= : Inférieur ou égal
• >= : Supérieur ou égal
• < : Strictement inférieur
• > : Strictement supérieur

Les égalités souple et très souple s’utilisent pour les chaînes de caractères pour tenir compte ou pas des minuscules et des majuscules, des lettres minuscules accentuées, des blancs avant ou après, des espaces et ponctuations à l’intérieur des chaînes (égalité très souple seulement).

L’égalité très souple peut être utilisée lors de la recherche sur clé. Pour cela, la rubrique de clé doit avoir été configurée avec les options sensibilité à la casse, à l’accentuation, à la ponctuation.

Résultat de comparaison de chaîne de caractères

’’Chaîne’’=’’CHAINE’’=>Faux 
’’Chaîne’’~=’’CHAINE’’=>Vrai 
’’ Chaîne ’’~=’’CHAINE’’=>Vrai 
’’C’est une chaîne’’~=’’c’est une chaine’’=>Vrai 
’’Version 11.0’’~~’’Version 11’’=> Vrai

Intervalle de comparaison :

Valeur1<X<Valeur2 : strictement compris entre les bornes exclues.

Valeur1<=X<=Valeur2 : compris entre les bornes incluses.

Valeur1<X<=Valeur2 ou Valeur1<=X<Valeur2 : compris entre, avec la borne inférieure exclue puis avec la borne supérieure exclue.

5. Opérateurs sur chaînes de caractères

WinDev utilise l’opérateur + et += pour concaténer des chaînes de caractères, c’est-à-dire les mettre bout à bout.

La concaténation avec option permet de construire des chaînes complexes avec ces opérateurs.

L’exemple ci-dessous permet de construire une liste de noms de clients séparés par un séparateur.

sListeClients est une chaîne 
 
POUR CHAQUE Client  
    sListeClients+=[";"]+Client.Nom 
FIN

L’opérateur [[ ]] permet de manipuler les caractères présents entre les rangs indiqués :

TEST[[10]] renvoie le dixième caractère de la variable TEST.

TEST[[10 à 16]] renvoie du 10ème au 16ème.

Les syntaxes suivantes sont utilisables pour la récupération ou l’assignation.

NomVariable[[Position]] 
NomVariable[[RangDebut à RangFin]] 
NomVariable[[RangDebut à ]] // donne tous les caractères à partir de RangDebut. 
NomVariable[[à RangFin]] // donne tous les caractères du 1er jusqu’au RangFin. 
NomVariable[[RangDebut sur Nombre]]    // donne tous les caractères à partir 
                                       // de RangDebut sur la longueur  
                                       // indiquée par Nombre.

Le premier caractère d’une chaîne a le rang 1.

6. Opérateurs sur adresse

L’opérateur & renvoie l’adresse d’une variable sous la forme d’un entier.

Il renvoie l’adresse de tout type de variables mais il ne renvoie pas l’adresse de champs de fenêtre ou de rubriques de fichier car celle-ci peut changer à tout moment.

nAdresse=&<NomDeVariable> 
nAdresse est un entier 
cc est une chaîne 
nAdresse=&cc // renvoie l’adresse du premier caractère de la chaîne.

7. Opérateurs d’indirection

Cet opérateur permet de construire le nom d’un champ, d’une rubrique ou d’une variable dynamiquement et de récupérer le contenu de cet objet. Le nom de l’objet est placé entre accolade : {}.

Indirection simple

Le nom de l’objet est sous forme de chaîne de caractères.

{’’Nom’’}=’’WinDev’’  
// Le champ de nom Nom est chargé avec la valeur ’’WinDev’’

c’est équivalent à :

Nom=’’WinDev’’

Indirection avec variable

Dans ce mode, le nom de champ ou de rubrique est construit dynamiquement et cela permet de récupérer la valeur ou de l’affecter sans connaître à l’avance le nom. C’est cette forme qui est utilisable dans des algorithmes.

Voici un exemple d’utilisation de l’indirection pour changer les attributs de champs :

NomDeChamp est une chaîne 
NomDeChamp=’’DateNais’’ 
RendInvisible(NomDeChamp) 
 
Fonction RendInvisible(cChamp) 
{cChamp}..etat=invisible      // {cChamp} correspond au champ DateNais 
Retour

L’indirection fonctionne avec toute expression : un tableau, une propriété, un champ table, un objet, l’accès à un membre…

8. Opérateurs d’échange

L’opérateur <=> permet d’échanger le contenu de deux variables de type simple. Cela évite de faire deux assignations.

i est un entier = 1

n est un entier = 2

m est un entier = 0

i <=> n

est équivalent à :

m = i

i = n

n = m

WinDev évite de passer explicitement par une variable intermédiaire.

9. Opérateurs divers

Nous décrivons rapidement les autres opérateurs :

• Les parenthèses () : séparent les conditions, les paramètres de fonction ou procédure.
• Les crochets simples [] : utilisés pour les indices de tableaux.
• La virgule , : sépare les variables dans les lignes de déclaration, sépare les paramètres.
• Le point-virgule ; : sépare des instructions saisies sur une même ligne.
• Les deux-points : : permettent d’accéder aux membres et méthodes des objets. S’ils sont doublés, ils donnent accès aux membres et méthodes globales d’une classe.
• Le point . : permet d’accéder aux sous-éléments d’un élément plus important : un champ d’une fenêtre, une rubrique de fichier. Par exemple : client.code
• Le double point .. : permet d’accéder aux propriétés d’un élément : champ, fenêtre, état, fichier, rubrique (voir les propriétés de ces éléments dans la documentation).
• Le triple point … : indique que la ligne de code se poursuit à la ligne suivante. Il suffit de l’indiquer à la fin de la ligne qui se poursuit sur la suivante.
• La double barre // : indique le début d’un commentaire. Elle peut être placée sur la même ligne qu’une instruction, à sa suite.

Les instructions du WLangage

WinDev propose les structures de code classiques suivantes :

Instructions avec condition :

• SELON
• SI

Instructions répétitives :

• BOUCLE
• POUR
• POUR TOUT
• TANTQUE

Instructions de débranchement :

• GOTO
• RETOUR
• SORTIR
• CONTINUER
• RENVOYER

1. Instruction SELON

Cette instruction permet d’exécuter le code qui correspond à un cas particulier. La condition prend des valeurs. Le mot-clé CAS est suivi de la valeur à considérer. Le mot AUTRE(S)CAS permet de traiter les valeurs qui ne sont pas considérées spécifiquement.

Cette instruction correspond au DO CASE/ENDCASE de certains langages.

Nous pouvons bien sûr placer un autre SELON dans un ou plusieurs des cas à traiter. La valeur de la condition peut être numérique, caractère, chaîne, booléen, réel. Il convient d’adapter la valeur pour les cas attendus.

SELON   
CAS <VALEUR 1 DE LA CONDITION> : <ACTION 1>  // code très court 
CAS <VALEUR 1 DE LA CONDITION> :  // le : est facultatif 
  <1 ère ligne code à exécuter> 
  <n ème ligne de code à exécuter> 
CAS <VALEUR 3>, <VALEUR4>, <VALEUR 6> : 
  < lignes de code> 
CAS <VALEUR 5>, <VALEUR 8> 
  < lignes de code> 
 
AUTRES CAS :  // facultatif, mais  
    // toujours à la fin 
FIN 
SELON CHOIX  // CHOIX vaut de 1 à 3 
  CAS 1 : Ouvre(Fenetre1) 
  CAS 2 : Ouvre(Fenetre2) 
  CAS 3 : RETOUR 
FIN

2. Instruction SI

Cette instruction permet l’exécution de code si la condition est satisfaite.

Le code peut être écrit sur la même ligne que ALORS ou SINON mais il doit tenir sur la ligne, quitte à la prolonger avec le triple point.

L’indentation n’est pas obligatoire mais c’est une bonne technique pour améliorer la lisibilité du programme.

Si la condition comporte des membres liés par des ET ou OU, elle est entièrement testée même si le premier membre donne un résultat qui dispenserait d’évaluer la suite de la condition.

SI  CONDITION ALORS 
<Action si condition vraie> 
[SINON]                  // SINON est optionnel 
<Action si condition fausse> 
[FIN]                    // FIN obligatoire si le code n’est pas sur la 
                       // ligne des mots-clés ALORS et SINON 
SI nCHOIX=1 ET cTypeUser=’’ADMIN’’ ALORS 
  Info(’’Vous n’êtes pas autorisé’’) 
SINON 
  Ouvre(FenParam) 
FIN

3. Instructions simples : SORTIR, RETOUR, RENVOYER, CONTINUER

Les instructions SORTIR, RETOUR, RENVOYER permettent de quitter une itération. Elles sont en général liées à une condition d’exécution.

RENVOYER et RETOUR ne peuvent pas être employées dans le même traitement. RENVOYER et RETOUR peuvent être employées pour terminerdes fonctions. RENVOYER permet de terminer une fonction en donnant une valeur de retour à la fonction. RETOUR marque seulement la fin de la fonction ou de la procédure.

L’instruction CONTINUER permet de passer à l’itération suivante du même bloc d’itération sans exécuter le code placé entre cette instruction et la fin de la boucle. SORTIR permet de quitter une boucle et de passer à l’instruction immédiatement après la boucle.

4. Instruction BOUCLE

Cette instruction itère sans fin. Il faut tester une condition qui fera exécuter une instruction GOTO,SORTIR, RETOUR, ou RENVOYER.

BOUCLE 
<Action> 
SI condition1 ALORS SORTIR        // Va directement à la ligne qui suit FIN 
 <ACTION> 
SI condition2 ALORS CONTINUER     // Va directement à FIN et remonte à BOUCLE 
<ACTION> 
FIN

5. Instruction GOTO

Cette instruction provoque le débranchement à une étiquette. Le nom de l’étiquette est donnée dans l’instruction GOTO et elle doit être dans le même traitement. Elle ne peut pas être à l’intérieur d’une instruction itérative ou SELON.

GOTO <NomEtiquette> 
... 
<NomEtiquette> : 
<Code après étiquette>

6. Instruction POUR

Cette instruction effectue un bloc de code pour un nombre d’itérations ayant une valeur de départ et une valeur de fin par pas de 1 par défaut ou spécifié.

Le pas est constant et entier. Les instructions SORTIR, RETOUR, RENVOYER permettent de sortir de l’itération. L’instruction CONTINUER permet d’éviter du code à l’intérieur de l’itération. Cela correspond à une instruction GOTO FIN.

La variable de contrôle garde sa valeur courante lors de la sortie. Elle vaut la valeur finale + le pas si l’itération va jusqu’à la fin.

POUR <Variable de contrôle> = <Valeur initiale> A <Valeur finale> [PAS <n>] 
<Code> 
FIN

7. Instruction POUR TOUT

Cette instruction permet de parcourir un fichier dans sa totalité, selon une clé ou en appliquant un filtre. Elle simplifie l’écriture d’un traitement classique.

Les instructions d’avancement dans le fichier et de test de fin sont automatiquement gérées.

POUR TOUT <NomFichier> // parcours complet

Ou

POUR TOUT <NomFichier> SUR <NomClef> // parcours complet en fonction de la clef

Ou

POUR TOUT <NomFichier>... //avec filtre 
AVEC <Rubrique> <Operateur> <Valeur pour rubrique> 
  <code> 
FIN

Voici un exemple de remplissage d’une liste avec les enregistrements d’un fichier :

POUR TOUT FILIERE SUR FILIERE  
  ListeAjoute(ListeFiliere,FILIERE.FILIERE, FILIERE.INTITULE) 
FIN

8. Instruction TANTQUE

Ce bloc itère tant qu’une condition est vraie. Le code n’est exécuté que si la condition est vraie au début de l’itération.

TANTQUE <condition> 
  <Code> 
FIN

Les mots réservés

Outre les mots des instructions que nous venons de voir, le WLangage possède les mots réservés suivants :

• Allouer
• Externe
• MoiMême
• Null
• Libérer
• MaFenetre
• MonEtat
• STOP
• MaSource
• MonParent
• Modulo
• MonChampPopup

1. Allouer

Ce mot-clé permet de définir en mémoire des objets dynamiques ou des tableaux.

2. Externe

Ce mot a deux fonctions :

• Il permet de déclarer au compilateur que l’objet est une référence externe qui existera au moment de l’exécution (voir la description du type Description de Fichier dans la section Les types de variable — Types de variable avancés de ce chapitre).
• Il permet d’importer un fichier contenant du code. Le code du fichier sera considéré comme faisant partie du code qui importe ce fichier. Cela permet d’utiliser un même code dans différents endroits, notamment pour déclarer des constantes.

La syntaxe du premier sens est :

EXTERNE <Nom de la reference>

La syntaxe du second sens est :

EXTERNE ’’Nom du fichier’’

3. Libérer

Ce mot-clé permet de récupérer l’espace mémoire utilisé par des objets dynamiques.

4. MaFenetre, MaSource, MonEtat, MoiMeme, MonParent, MonChampPopup

Ces mots-clés ont la même fonction : rendre indépendante la programmation de la référence à un objet du type correspondant au mot-clé.

Par exemple, si un même code doit être exécuté à l’initialisation de différents champs, au lieu d’indiquer le nom du champ, nous utiliserons le mot-clé MoiMême dans ce code. Ainsi, le code est indépendant du champ dans lequel il s’exécute, car le mot-clé MoiMeme prendra le nom du champ en cours au moment de l’exécution du code.

C’est le même principe avec MaFenêtre. Ce mot-clé doit particulièrement être utilisé dans les fenêtres qui sont sœurs dans le cas de fenêtres MDI ou non modales, ouvertes par la fonction MDIOuvre ouOuvreSoeur. En effet, ces fonctions affectent un alias à chaque fenêtre qui n’est pas connu à l’avance. L’utilisation du mot-clé MaFenêtre résout ce problème car il désignera toujours la fenêtre active au moment de l’exécution du code.

MaFenêtre permet de manipuler la fenêtre en cours.

MaSource permet de manipuler la source de données en cours.

MonEtat permet de manipuler l’état en cours.

MoiMeme permet de manipuler le champ en cours.

MonParent permet de manipuler le superchamp courant.

MonChampPopup permet de manipuler le champ ouvrant la fenêtre popup en cours.

5. Modulo

Ce mot-clé renvoie le reste d’une division entière. Modulo est un mot-clé et une fonction.

6. Null

Ce mot-clé permet de tester l’existence d’objets dynamiques, d’indiquer qu’un paramètre ne doit pas être utilisé, de comparer une valeur à zéro ou encore qu’une variable de type Variant ne contient pas de valeur.

7. STOP

Cette instruction invoque le débogueur lors des tests, lorsque l’exécution arrive à cette instruction.

L’autre méthode d’invocation est de placer, sur l’éditeur de code, un point d’arrêt dans la marge, en face de la ligne à laquelle nous voulons arrêter le programme, en cliquant au début de la ligne.

Procédures et fonctions

Les procédures ou fonctions permettent de regrouper un traitement particulier réutilisable plusieurs fois et qui peut être paramétré.

Il n’y a pas de distinction particulière entre une procédure et une fonction. Seule, la fonction peut renvoyer une valeur.

Nous utiliserons dans la suite indifféremment le mot fonction ou procédure.

Les procédures peuvent être globales au projet ou locales dans une fenêtre ou un état.

1. Procédures globales

Pour définir des procédures globales, c’est-à-dire pour qu’elles soient utilisables depuis n’importe quel traitement du projet, il faut créer la procédure comme étant une procédure globale soit par le menuInsertion de l’éditeur de code, soit via le volet Code.

Les procédures globales sont stockées dans une collection de procédures. Il y a une collection par défaut, mais nous pouvons ajouter des collections de procédures qui contiendraient des fonctions regroupant le savoir développer ou des outils déjà codés. Il y aurait ainsi la collection de procédures d’outils et la collection de procédures propres au projet.

Les collections sont des fichiers dont l’extension est WDG.

2. Procédures locales

Les procédures locales ne sont utilisables que dans les fenêtres ou états dans lesquels elles ont été écrites.

Si une procédure n’est utilisée que dans une fenêtre, il convient de la déclarer comme locale dans cette fenêtre. Seules celles employées dans différents traitements du projet sont à indiquer en procédure globale.

Les procédures d’une fenêtre fille ne peuvent pas être appelées par la fenêtre mère, ni par les éventuelles fenêtres sœurs.

3. Déclaration des procédures et appel

La syntaxe d’une procédure est la suivante :

Sans paramètre :

PROCEDURE NomDeProcedure() 
<Corps de la procédure>

Avec paramètres :

PROCEDURE NomDeProcédure([Local] Param1 obligatoire [est un <Type>], ..,  
[Local] Parami obligatoire [est un <Type>],[Local] Paramn facultatif  
[est un <Type>] = <Valeurn>,..., [Local] Paramp facultatif [est un <Type>] =  
<Valeurp>) 
<Corps de la procédure>

C’est la même chose avec les fonctions en remplaçant le mot-clé Procédure par Fonction.

Sans paramètre :

FONCTION NomDeFonction() 
<Corps de la fonction>

Avec paramètres :

FONCTION NomDeFonction([Local] Param1 obligatoire [est un <Type>], .., 
[Local] Parami obligatoire [est un <Type>],[Local] Paramn facultatif 
[est un <Type>] = <Valeurn>,..., [Local] Paramp facultatif [est un 
<Type>] = <Valeurp>) 
<Corps de la fonction>

Les paramètres obligatoires doivent précéder les paramètres facultatifs. Ceux-ci sont indiqués avec une valeur par défaut après le signe =.

Les fonctions se terminent par RETOUR ou utilisent RENVOYER pour retourner une valeur.

La syntaxe d’appel est différente selon que l’on attend ou pas un résultat.

Sans attente de résultat :

NomProcedure (liste de paramètres séparés par des virgules) ou NomFonction (liste de paramètres séparés par des virgules).

Avec attente de résultat :

Variable=Fonction(liste de paramètres séparés par des virgules)

Dans ce cas, la différence entre une procédure et une fonction est visible ; en effet, nous ne pouvons pas écrire sous cette forme l’utilisation d’une procédure.

Dans ce cas également, une ou plusieurs instructions RENVOYER sont utilisées dans la fonction. Le résultat retourné par la fonction doit être du même type que la variable utilisée pour recueillir la valeur.

4. Passage de paramètre par valeur ou par adresse (référence)

Il y a deux méthodes pour passer des paramètres :

• Par valeur : dans ce cas, seule la valeur est communiquée à la fonction. La variable dont la valeur est fournie ne peut pas être modifiée par la fonction. Elle reste inchangée dans le programme appelant. La variable passée par valeur est placée entre parenthèses dans le code.
• Par adresse ou référence : dans ce cas, si le paramètre est modifié dans la fonction, la valeur de la variable est modifiée également pour le programme appelant. La variable est passée par son nom.

Passage par valeur :

Mafonction( (VarParValeur))

Passage par adresse :

MaFonction(VarParAdresse)

5. Documentation automatique et aide à la saisie

WinDev propose automatiquement une forme de documentation de la fonction. Cette forme permet notamment de présenter les paramètres.

Avec cette forme, lorsqu’un développeur veut utiliser la procédure, les mécanismes d’assistance à la saisie exploitent la documentation pour aider le développeur à indiquer les bons paramètres.

6. Collection de procédures

Les procédures globales sont contenues dans un fichier d’extension WDG. Chaque projet contient au moins une collection. Le fichier peut être vide. Un projet peut utiliser plusieurs collections. On peut ainsi mettre des fonctions dans un fichier particulier pour partager un ensemble de fonctionnalités.

Gestion des exceptions

La gestion des exceptions permet de débrancher le fonctionnement du programme vers une partie de code spécifique déterminée par une sorte de jalon qui est consigné par le processus au cours de l’exécution dudit programme.

Quand une exception survient, le processus recherche le dernier jalon franchi et s’y reporte pour exécuter le code de traitement d’exception qui lui est associé. Si le code tient compte de l’exception qui a provoqué le déroutement, la partie correspondante peut être exécutée et l’exception est contrôlée. Si ce n’est pas le cas, c’est le mécanisme général de WinDev qui est activé et le programme se termine avec le message d’erreur standard de WinDev.

Quand il n’y a pas eu d’exception, le bloc n’est pas exécuté et le déroulement du programme se poursuit avec les instructions suivantes du bloc. Par contre, quand une exception survient, le code du bloc est exécuté et le code situé après aussi !

Il faut donc bien prévoir les actions du traitement d’exception pour ne pas repartir dans le code qui le suivrait. En général il faut retourner en saisie de champ par la fonction RepriseSaisie ou EcranPremier, ou bien quitter l’élément, champ, fenêtre, traitement, par RETOUR ou RENVOYER.

Nous pouvons empiler les traitements d’exception.

Nous ne pouvons pas les déclarer dans une séquence de code en boucle.

Nous pouvons déclarer un contrôle d’exception au niveau du projet puis en déclarer par fenêtre, par champ ou précisément à l’intérieur du code par le mécanisme des exceptions spécifiques.

Lorsqu’une exception survient, c’est le dernier traitement d’exception qui devient l’instruction active.

Certaines exceptions peuvent être rectifiées et l’exécution du programme peut reprendre à l’instruction qui a provoqué l’exception.

Les exceptions traitent des erreurs de programmation et pas des erreurs d’exécution. Ainsi, les erreurs qui surviennent au moment de la lecture ou de l’écriture d’un fichier ou de l’exécution d’un ordre SQL ont leur propre technique de contrôle gérée par les fonctions Herreur() ou SqlInfoGene().

Nous pouvons reprendre l’exécution avec la fonction RepriseSaisie() qui permet de replacer l’exécution du programme sur un champ de la fenêtre.

La fonction ExceptionActive() peut être utilisée pour réactiver le bloc de gestion d’exception qui vient d’être parcouru. Un bloc parcouru une fois n’est plus apte à gérer une nouvelle exception dans son champ d’application à moins de le ranimer par cette fonction.

Nous pouvons forcer l’exécution du code de contrôle par la fonction ExceptionDéclenche(). Dans ce cas, nous pouvons définir jusqu’à 1000 exceptions, numérotées de 1 à 1000. Ce sont des exceptions utilisateurs.

La fonction ExceptionInfo() fournit le code de l’erreur au traitement de contrôle (voir l’exemple).

Déclaration générale

Ce type de déclaration se place principalement dans les traitements d’initialisation des éléments WinDev : projet, fenêtre, champ.

Quand il est défini au début d’un traitement, le contrôle n’existe plus à la fin du traitement où il a été défini.

QUAND EXCEPTION 
// traitement de l’exception 
FIN

Déclaration spécifique

La déclaration spécifique s’emploie pour contrôler du code localement.

QUAND EXCEPTION Dans 
// code pouvant provoquer une exception 
Faire 
// Traitement de l’exception 
FIN

Exemple dans la section Déclaration d’une fenêtre

// Déclaration du bloc de gestion d’exception 
QUAND EXCEPTION 
  SELON ExceptionInfo(errCode) 
    Cas 1 
        // Traitement 1 
    Cas n 
        // Traitement n 
    Autres cas 
      Info(’’Erreur inconnue ’’+ ExceptionInfo(errCode)’’) 
      RepriseSaisie(errElement)    // retour au champ d’où provient l’erreur 
  FIN 
FIN 
// Suite du code de la partie déclaration de la fenêtre.

Accès FTP

Parmi les familles de fonctions proposées par le WLangage, une famille de fonctions permet la gestion du FTP (File Transfer Protocol).

La connexion à un serveur FTP se fait par la fonction FTPConnecte(). Cette fonction renvoie un résultat qui permet de valider la connexion. Ce résultat est un entier correspondant à l’identifiant de la connexion. Il est égal à -1 en cas d’échec et à 0 lors de la première connexion.

La connexion FTP peut être sécurisée par les protocoles suivants :

• SFTP : FTP sécurisé par un tunnel SSH.
• FTPS : FTP sécurisé selon le protocole SSL avec chiffrement implicite.
• FTPES : FTP sécurisé selon le protocole SSL avec chiffrement explicite.

La déconnexion au serveur se fait par la fonction FTPDeconnecte().

L’exemple ci-dessous permet d’effectuer une connexion anonyme au serveur FTP :

IDConnexionFTP est un entier 
IDConnexionFTP = FTPConnecte("atmprdlbp.victeal.int") 
//traitement à réaliser 
FTPDéconnecte(IDConnexionFTP)

L’exemple suivant permet d’effectuer une connexion passive sur le port 2001 :

IDConnexionFTP est un entier 
IDConnexionFTP = FTPConnecte("atmprdlbp.victeal.int",
"NomUtilisateur","MotDePasse",2001,Vrai) 
//traitement à réaliser 
FTPDéconnecte(IDConnexionFTP)

L’envoi d’un fichier sur un serveur FTP se fait par la fonction FTPEnvoie(). Cette fonction retourne un résultat qui correspond à Vrai si l’envoi est correctement réalisé et à Faux en cas d’échec.

ResultatEnvoi est un booléen 
// Transfert du fichier "C:\MesDocuments\CLIENTS.xml" 
// dans le répertoire "/Clients" sur le serveur FTP 
ResultatEnvoi = FTPEnvoie(IDConnexionFTP, "C:\MesDocuments\CLIENTS.xml", 
"/Clients")

La récupération d’un fichier d’un serveur FTP vers le poste utilisateur se fait par la fonctionFTPRécupère(). Cette fonction récupère un résultat qui correspond à Vrai si l’envoi est correctement réalisé et à Faux en cas d’échec.

ResultatRecuperation est un booléen 
// Récupération du fichier /Clients/CLIENTS.xml présent sur le serveur FTP 
// dans le répertoire "C:\MesDocuments" sur le poste en cours  
ResultatRecuperation = FTPRécupère(IDConnexionFTP, "/Clients/CLIENTS.xml", 
"C:\MesDocuments")

D’autres fonctions de gestion du FTP sont utilisées dans les exemples de la section Exemples de traitements opérationnels en WLangage, plus loin dans ce chapitre.

Gestion des e-mails

Les fonctions et propriétés du WLangage permettent l’envoi d’e-mails de façon simple.

La gestion des e-mails peut se faire en utilisant les protocoles SMTP (Simple Mail Transfer Protocol) et POP3 mais également par des fonctions spécifiques qui permettent de manipuler les données de messagerie.

Exemple, la fonction EmailOuvreSessionOutlook() permet l’accès à Outlooket à ses éléments (e-mails, contacts, tâches, rendez-vous et dossiers).

Nous illustrons, ci-dessous, l’utilisation des fonctions e-mails en utilisant le type EmailSessionSMTP qui permet d’accéder à un serveur de messagerie en utilisant le protocole SMTP afin d’envoyer des e-mails.

// Ouverture d’une session SMTP 
MaSession est un EmailSessionSMTP 
MaSession..AdresseServeur = "mail.victeal.int" 
" 
MaSession..Nom = "" 
MaSession..MotDePasse = "" 
 
MonMessage est un objet Email 
partie est une chaîne 
 
 
EmailRAZ(MonMessage) // initialise toutes les variables 
 
// Expéditeur du message 
MonMessage..Expediteur = "NoReply@victeal.com" 
MonMessage..AdresseExpéditeur = "david.vandevelde@victeal.net" 
MonMessage..Sujet = "Activation fichier clients : Alerte 1" 
MonMessage..Message = "Bonjour, "+RC +RC 
MonMessage..Message = MonMessage..Message  + "Le fichier client 
sera activé ce jour." 
 
MonMessage..Destinataire[1] = "catherine.dupont@victeal.fr" 
MonMessage..Destinataire[2] = "emeline.dumatin@victeal.fr" 
MonMessage..Destinataire[3] = "arnaud.durant@victeal.fr" 
MonMessage..Cc[1] = "xavierpecheur@victeal.com" 
MonMessage..Cc[2] = "dvandevelde@victeal.com" 
 
SI EmailEnvoieMessage(MaSession, MonMessage) = Faux ALORS 
    erreur_traitement("L’envoi de l’e-mail Alerte 1 a échoué.") 
FIN

La fonction EmailEnvoieMessage(), utilisée avec le protocole SMTP envoie directement le message au serveur.

La fonction EmailEnvoieMessage() peut également être utilisée par l’intermédiaire du logiciel Outlook ou Lotus Notes ou par l’intermédiaire du client MS Exchange.

Si l’extrait vous a plu, retrouvez le livre ici.