PC SOFT

DOCUMENTATION EN LIGNE
DE WINDEVWEBDEV ET WINDEV MOBILE

  • Présentation
  • Comment le faire ?
  • Manipulations grâce à ExécuteTraitement et aux opérateurs d'indirection
  • Utilisation de la fonction ExécuteTraitement
  • Utilisation des opérateurs d'indirection { ... }
  • Exemple
WINDEV
WindowsLinuxUniversal Windows 10 AppJavaEtats et RequêtesCode Utilisateur (MCU)
WEBDEV
WindowsLinuxPHPWEBDEV - Code Navigateur
WINDEV Mobile
AndroidWidget AndroidiPhone/iPadApple WatchUniversal Windows 10 AppWindows Mobile
Autres
Procédures stockées
Présentation
Le WLangage propose plusieurs types de variable pour permettent l'énumération et la manipulation dynamique des objets d'une classe. Un développeur maîtrisant la Programmation Orientée Objet (POO) peut ainsi créer des méthodes entièrement paramétrées qui s'adaptent aux objets contenus dans une classe.
Il est possible d'énumérer :
Lors de cette énumération, il est par exemple possible de récupérer :
  • le nom de l'élément.
  • le type de l'élément.
Par exemple :
  • il est possible de récupérer le nom d'une méthode pour l'appeler en utilisant la fonction ExécuteTraitement.
  • il est possible de récupérer le nom et le type d'une variable pour connaître ou affecter sa valeur en utilisant les opérateurs d'indirection { }.
Versions 21 et supérieures
Universal Windows 10 App Cette fonctionnalité est disponible en mode Universal Windows 10 App.
Apple Watch Cette fonctionnalité est disponible en mode Apple Watch.
Nouveauté 21
Universal Windows 10 App Cette fonctionnalité est disponible en mode Universal Windows 10 App.
Apple Watch Cette fonctionnalité est disponible en mode Apple Watch.
Universal Windows 10 App Cette fonctionnalité est disponible en mode Universal Windows 10 App.
Apple Watch Cette fonctionnalité est disponible en mode Apple Watch.
Comment le faire ?
Les différentes étapes pour énumérer et manipuler un objet sont les suivantes :
  1. Récupération de la définition de l'objet à manipuler grâce à la fonction RécupèreDéfinition.
    Exemple :
    O est un cWord    // Instanciation de la classe CWord
    Def est une Définition // Déclaration d'une variable de type Définition

    Def = RécupèreDéfinition(O)  // Récupération de la définition de l'objet O dans la variable Def

    Trace(Def..Nom)  // Affichage du nom de l'objet
    Trace(Def..FamilleDéfinition)
    Trace(Def..Type) // Affichage du type de l'objet
  2. Récupération de la liste des méthodes. Une boucle de type "POUR TOUT" permet de lire la propriété ..Procédure de la variable de type Définition. Cette propriété correspond à un tableau contenant toutes les procédures contenues dans l'objet décrit.
    Exemple :
    // Déclaration de la variable qui contiendra la description d'une procédure
    Proc est une Description de Procédure  

    // Liste des procédures (ou méthodes) de l'objet Def
    POUR TOUT Proc DE Def..Procédure
            Trace (Proc..Nom)  // Affiche le nom de la procédure trouvée
    FIN

    D'autres propriétés sont accessibles en utilisant la propriété ..NomPropriété sur l'objet. Pour plus de détails, consultez Description de Procédure.
  3. Récupération de la liste des propriétés. Une boucle de type POUR TOUT permet de lire la propriété ..Propriété. Cette propriété correspond à un tableau contenant toutes les propriétés contenues dans l'objet décrit.
    Exemple :
    // Déclaration d'une variable qui contiendra la description d'une propriété
    Prop est une Description de Propriété  

    // Liste des propriétés de l'objet Def
    POUR TOUT Prop DE Def..Propriété  
            Trace (Prop..Nom)  // Affiche le nom de la propriété trouvée
    FIN

    D'autres propriétés sont accessibles en utilisant la propriété ..NomPropriété sur l'objet. Pour plus de détails, consultez Description de Propriété.
    Versions 18 et supérieures
    Il est également possible d'utiliser la fonction PropriétéExiste pour savoir si une propriété spécifique existe bien dans une classe.
    Nouveauté 18
    Il est également possible d'utiliser la fonction PropriétéExiste pour savoir si une propriété spécifique existe bien dans une classe.
    Il est également possible d'utiliser la fonction PropriétéExiste pour savoir si une propriété spécifique existe bien dans une classe.
  4. Récupération de la liste des variables. Une boucle de type POUR TOUT permet de lire la propriété ..Variable. Cette propriété correspond à un tableau contenant toutes les variables de l'objet décrit.
    Exemple :
    // Déclaration de la variable qui contiendra la description d'une variable
    Prop est une Description de Variable  

    // Liste des variables de l'objet Def
    POUR TOUT Var DE Def..Variable  
    // Affiche le nom et le type de la Variable trouvée
    Trace (Var..Nom, Var..Déclaration..Type, Var..Définition..Nom)
    FIN

    D'autres propriétés sont accessibles en utilisant la propriété ..NomPropriété sur l'objet. Pour plus de détails, consultez Description de Variable.
Manipulations grâce à ExécuteTraitement et aux opérateurs d'indirection

Utilisation de la fonction ExécuteTraitement

La fonction ExécuteTraitement permet d'appeler le code d'un événement associé à un objet.
Par exemple, le code suivant provoque l'appel du code de clic du bouton Valider :
ExécuteTraitement(BoutonValider, trtClic)
Pour exécuter une méthode de classe, il suffit d'utiliser une variable de type "Description de Procédure" avec la fonction ExécuteTraitement.
Par exemple :
c est un BalloonTip
p est une Description de Procédure
Def est une Définition

Def = RécupèreDéfinition(c)
// Récupère la première procédure de l'objet BalloonTip
p = Def..Procédure[1]  

// Exécute la procédure représentée par p de l'objet c
ExécuteTraitement(c, p)

Utilisation des opérateurs d'indirection { ... }

Les opérateurs { } d'indirection permettent de manipuler le contenu d'une variable par un adressage indirect : le nom de l'objet à adresser est contenu dans une variable.
La syntaxe est la suivante :
{Variable_contenant_nom_Objet, TypeVariable}
où TypeVariable est une constante du langage commençant par indXXX.
Exemple:
// Remplit le champ "SAI_VILLE" avec la valeur "Montpellier"
NomChamp est une chaîne
NomChamp = "SAI_VILLE"
{NomChamp, indChamp} = "Montpellier"
Pour manipuler un membre d'une méthode de classe, il suffit de passer dans les { } :
  • l'instance de la classe
  • une variable de type Description de Variable ou le nom du membre.
Par exemple:
c est un cWord
var est une Description de Variable
Def est une Définition

Def = RécupèreDéfinition(c)
// Récupère la 2ème variable de la classe : version de Word
var = Def..Variable[2]

Trace(var..Nom) // Affiche le nom de la variable
Trace("Version de Word: ",{c, var})  // Affiche la version de Word
Exemple
L'exemple de code ci-dessous permet d'énumérer toutes les procédures, propriétés et variables contenus dans une classe. Dans cet exemple, la classe cWord est issue de l'exemple "WD Pilotage de Word" (fourni dans les exemples de WINDEV).
o est un cWord
def est une Définition
def = RécupèreDéfinition(o)

Trace(def..Nom)
Trace(def..FamilleDéfinition)
Trace(def..Type)

Proc est une Description de Procédure
Prop est une Description de Propriété
Var est une Description de Variable

Trace("--------------- Procédures --------------------")
POUR TOUT Proc DE def..Procédure
Trace(Proc..Global, Proc..Hérité, Proc..Nom, Proc..Virtuel)
FIN

Trace("--------------- Propriétés --------------------")
POUR TOUT Prop DE def..Propriété
Trace(Prop..Déclaration, Prop..Définition, Prop..Ecriture, ...
Prop..Global, Prop..Hérité, Prop..Lecture, Prop..Nom, Prop..Virtuel)
FIN

Trace("--------------- Variables --------------------")
POUR TOUT Var DE def..Variable
Trace(Var..Nom, Var..Définition..Type, Var..Définition..Nom)
SELON Var..Définition..Type
CAS 1, 4, 8, 19
// Affichage de la valeur de la variable par indirection
Trace({o,Var})  
CAS 34 // tableau
Trace("Dimension: ",{o,Var..Nom}..Occurrence)
CAS 36 // structure
v est une Description de Variable
Trace("Structure "+Var..Définition..Nom)
Trace("........................................................")
POUR TOUT v DE Var..Définition..Variable
Trace(v..Nom, v..Définition..Type, v..Définition..Nom)
FIN
Trace("........................................................")
AUTRE CAS

FIN
Trace("======================================================================")
FIN
Version minimum requise
  • Version 16
Documentation également disponible pour…
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire