|
|
|
|
|
- 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
Eléments d'une classe : Enumérer et manipuler par programmation
Le WLangage propose plusieurs types de variable pour permettre l'énumération et la manipulation dynamique des éléments 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 éléments 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 { }.
Les différentes étapes pour énumérer et manipuler un objet sont les suivantes : - Récupération de la définition de l'objet à manipuler grâce à la fonction RécupèreDéfinition.
Exemple :
O est un cWord
Def est un Définition
Def = RécupèreDéfinition(O)
Trace(Def.Nom)
Trace(Def.FamilleDéfinition)
Trace(Def.Type)
- 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 :
Proc est une Description de procédure
POUR TOUT Proc DE Def.Procédure
Trace (Proc.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 procédure. - 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 :
Prop est une Description de Propriété
POUR TOUT Prop DE Def.Propriété
Trace (Prop.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 Propriété. Il est également possible d'utiliser la fonction PropriétéExiste pour savoir si une propriété spécifique existe bien dans une classe. - 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 :
Prop est une Description de Variable
POUR TOUT Var DE Def.Variable
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 un Définition
Def = RécupèreDéfinition(c)
p = Def.Procédure[1]
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:
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 un Définition
Def = RécupèreDéfinition(c)
var = Def.Variable[2]
Trace(var.Nom)
Trace("Version de Word: ",{c, var})
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 un Définition
def = RécupèreDéfinition(o)
Trace(def.Nom)
Trace(def.FamilleDéfinition)
Trace(defp.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
Trace({o,Var})
CAS 34
Trace("Dimension: ", {o,Var.Nom}..Occurrence)
CAS 36
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
Documentation également disponible pour…
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|