- Déclaration des combinaisons
- Activer ou désactiver les options d'une combinaison
- Lire les options d'une combinaison
- Passer une combinaison en paramètre à une procédure
- Saisie assistée
- Extension de combinaison
- Combinaisons prédéfinies
- Exclusions mutuelles
- Propriétés associées
- Fonctions WLangage disponibles
- Limites
Combinaison (Type de variable) En anglais : Combination
Une combinaison est un ensemble d'options. Une variable ou un paramètre formel de type combinaison peut être affectée avec aucune, une ou plusieurs options de la combinaison.
// Code de déclaration
// Déclarer une combinaison
TypeCombinaison est une Combinaison
CréationFic
LectureFic
EcritureFic
SuppressionFic
FIN
// Déclaration d'une variable de type Combinaison
ActionFichier est un TypeCombinaison
// Affectation de la variable
ActionFichier = LectureFic + EcritureFic
// ActionFichier = 0 // Désactive toutes les options
...
// Pour tester la valeur de la combinaison :
SI ActionFichier[EcritureFic] ALORS
// L'option EcritureFic est activée
SINON
// L'option EcritureFic n'est pas activée
FIN
Syntaxe
Déclarer une combinaison Masquer les détails
<Nom de la combinaison> est une Combinaison
<Options de la combinaison>
FIN
<Nom de la combinaison> : Nom de la combinaison à déclarer <Options de la combinaison> : Différentes options pouvant être prises par la combinaison. <FIN> : Fin de déclaration.
Déclarer une variable de type Combinaison Masquer les détails
<Nom de la variable> est une <Nom de la combinaison>
<Nom de la variable> : Nom de la variable de type Combinaison à déclarer. <Nom de la combinaison> : Nom d'une combinaison précédemment déclarée. Remarques Déclaration des combinaisons Une combinaison doit être déclarée dans : - Le code d'initialisation du projet pour être utilisable dans tous les traitements du projet (codes du projet, codes des fenêtres, codes des champs, procédures, ...).
- Le code de déclaration des globales d'une fenêtre pour être utilisable dans tous les traitements de la fenêtre (codes de la fenêtre, codes des champs présents dans la fenêtre, procédures locales, ...).
- Le code d'ouverture d'un état pour être utilisable dans tous les traitements de l'état (codes de l'état, codes des champs présents dans l'état, procédures locales, ...).
- Le code de déclaration de classe pour être utilisable dans la classe.
- Pour accéder à cette combinaison depuis une méthode de la classe, utilisez la syntaxe "::<Nom de la combinaison>".
- Pour accéder à cette combinaison depuis un code extérieur à la classe, utilisez la syntaxe "<Nom de la classe>::<Nom de la combinaison>".
- Le code de déclaration des collections de procédures pour être utilisable dans toutes les procédures de la collection.
Remarque : Une combinaison est toujours globale : - soit à un projet,
- soit à une fenêtre,
- soit à un état,
- soit à une classe.
Activer ou désactiver les options d'une combinaison Plusieurs syntaxes permettent d'activer ou de désactiver les options d'une combinaison. Quelques exemples : - Déclaration de la combinaison utilisée pour les exemples :
TypeCombinaison est une Combinaison
CréationFic
LectureFic
EcritureFic
SuppressionFic
FIN
// Déclaration d'une variable de type Combinaison
ActionFichier est un TypeCombinaison
- Désactivation de toutes les options :
Syntaxe :
<Variable Combinaison> = 0
Exemple :
- Activation d'une ou plusieurs options :
Syntaxe :
<Variable Combinaison> = Option 1
<Variable Combinaison>[Option 1] = Vrai
<Variable Combinaison> = Option 1 + Option 2
<Variable Combinaison>[Option 1 + Option 2] = Vrai
Exemples :
ActionFichier = LectureFic // Active une option
ActionFichier = LectureFic + EcritureFic // Active 2 options
ActionFichier[LectureFic] = Vrai // Active une option
ActionFichier[LectureFic + EcritureFic] = Vrai // Active 2 options
- Désactivation d'une ou plusieurs options :
Syntaxe :
<Variable Combinaison>[Option 1] = Faux
<Variable Combinaison>[Option 1 + Option 2] = Faux
Exemples :
ActionFichier[LectureFic] = Faux // Désactive une option
ActionFichier[LectureFic + EcritureFic] = Faux // Désactive 2 options
Lire les options d'une combinaison Plusieurs syntaxes permettent de connaître les options d'une combinaison. Quelques exemples : - Déclaration de la combinaison
TypeCombinaison est une Combinaison
CréationFic
LectureFic
EcritureFic
SuppressionFic
FIN
// Déclaration d'une variable de type Combinaison
ActionFichier est un TypeCombinaison
- Tester si toutes les options sont désactivées :
Syntaxe :
SI <Variable Combinaison> = 0
Exemples :
SI ActionFichier = 0 ALORS ...
- Tester si une option est activée :
Syntaxe :
SI <Variable Combinaison> = Option 1 ...
SI <Variable Combinaison>[Option 1] = Vrai ...
Exemples :
SI ActionFichier = LectureFic ALORS ...
SI ActionFichier[LectureFic] = Vrai ALORS ...
- Tester si plusieurs options sont activées :
Syntaxe :
SI <Variable Combinaison> = Option 1 + Option 2 ALORS ...
SI <Variable Combinaison>[Option 1 + Option 2] = Vrai ...
Exemples :
SI ActionFichier = LectureFic + EcritureFic ALORS ...
SI ActionFichier[LectureFic + EcritureFic] = Vrai ALORS ...
- Tester si au moins une option est activée :
Syntaxe :
SI <Variable Combinaison>[Option 1] OU <Variable Combinaison>[Option 2] ALORS ...
Exemples :
SI ActionFichier[LectureFic] OU ActionFichier[EcritureFic] ALORS ...
Passer une combinaison en paramètre à une procédure Une variable de type Combinaison peut être passée en paramètre à une procédure. Pour cela, utilisez la syntaxe suivante :
<Nom de la procédure>(<Nom de la variable de type Combinaison>)
Par exemple :
// Procédure avec un paramètre de type Combinaison
PROCÉDURE TypeFichier(p est TypeCombinaison)
// Appels avec un paramètre de type Combinaison
TypeFichier(LectureFic + EcritureFic)
TypeFichier(ActionFichier)
Saisie assistée La saisie assistée pour un paramètre de type Combinaison propose les différentes options de la combinaison. Extension de combinaison Une combinaison peut étendre les valeurs d'une ou plusieurs autres combinaisons en reprenant les options de celles-ci et en y ajoutant de nouvelles options. La syntaxe utilisée est la suivante :
<Nom de la combinaison> est une Combinaison
[Combinaison de base]
<Options supplémentaires de la combinaison>
FIN
où : - <Nom de la combinaison> : Nom d'une combinaison précédemment déclarée.
- Combinaison de base : Nom de la combinaison de base à utiliser.
- <Options supplémentaires de la combinaison> : Options supplémentaires à prendre en compte dans la combinaison.
Exemple :
TypeCombinaison est une Combinaison
CréationFic
LectureFic
EcritureFic
SuppressionFic
FIN
TypeCombinaisonAvancé est une Combinaison
[TypeCombinaison]
AutresAttributs
FIN
Combinaisons prédéfinies Plusieurs options sont combinables pour forcer une combinaison prédéfinie. Les options combinées doivent appartenir à la combinaison (ou à des combinaisons de base) La syntaxe utilisée est la suivante :
<Nom de la combinaison> est une Combinaison
<Option 1 de la combinaison>
<Option 2 de la combinaison>
<Option 3 de la combinaison> = <Option 1 de la combinaison> + <Option 2 de la combinaison>
FIN
Exemple :
TypeCombinaison est une Combinaison
CréationFic
LectureFic
EcritureFic
SuppressionFic
Lecture_Ecriture_Fic = LectureFic + EcritureFic
FIN
Exclusions mutuelles Il est possible de décrire des exclusions mutuelles entre des options d'une combinaison. Par exemple, une combinaison contient trois options : Option1, Option2 et Option3. Option2 et Option3 sont exclusives : - Option1 et Option2 peuvent être actives.
- Option1 et Option3 peuvent être actives.
- Option2 et Option3 ne peuvent pas être actives.
- Option1, Option2 et Option3 ne peuvent pas être actives.
La syntaxe à utiliser est la suivante :
<Nom de la combinaison> est une Combinaison
<Option 1 de la combinaison>
<Option 2 de la combinaison>
<Option 3 de la combinaison>
// Exclusions
<Option 2 de la combinaison> - <Option 3 de la combinaison>
FIN
Remarque : En combinant les extensions et les exclusions, il est possible d'obtenir pour les mêmes options : - un paramètre d'une fonction qui impose une exclusion,
- un paramètre d'une autre fonction qui n'impose aucune exclusion ou qui impose une exclusion différente.
Propriétés associées Les propriétés associées aux variables de type Combinaison sont les suivantes : | | | Nom | Permet de connaître le nom d'une variable de type Combinaison. | | Valeur | Permet de connaître la valeur associée d'une variable de type Combinaison. |
Fonctions WLangage disponibles Une combinaison peut être stockée dans une rubrique HFSQL ou dans un autre format de fichier. Selon les besoins, il peut être possible de stocker le nom (propriété Nom) ou la valeur de la combinaison (propriété Valeur). Les fonctions WLangage suivantes permettent de retrouver les caractéristiques d'une combinaison stockée :
Limites - Les combinaisons ne sont pas disponibles en compilation dynamique.
- Les combinaisons ne sont pas utilisables hors projet.
Documentation également disponible pour…
|
|
|
|