Indirection operators

ONLINE HELP
WINDEV, WEBDEV AND WINDEV MOBILE

Version:

Home | Sign in | English

This content has been translated automatically. Click here to view the French version.

Help / WLanguage / WLanguage syntax / Operators

When should indirection be used?
Identifying the current object
Indirection on a structure
Using the indirection on the paths in an XML document
Limitations
Indirections in Java

WINDEV

WEBDEV

WINDEV Mobile

Others

See also

Indirection operators

In french: Opérateurs d'indirection

Operators { and operators } operators are used to access a field, variable, class member or data file item by dynamically constructing the name of the field, variable, class member or item.

The { and } operators present several benefits:

Passing as parameter the name of a control, variable, class member or item.
Building the name of a control, variable, class member or item programmatically.

Indirections cannot be performed local variables. Indirections can only be performed on global variables only. An indirection on a local variable of a process will trigger an "unknown element" error.

Example

// Indirection simple 
{"NOM"} = NomCli		// Est équivalent à NOM=NomCli 
{"NOM"} = {"CL.NOMCLI"}	// Est équivalent à NOM=CL.NOMCLI 
{"FENCLI.NOM"} = NomCli	// Est équivalent à FENCLI.NOM=NomCli 
{"FENCLI"+".NOM"} = NomCli	// Est équivalent à FENCLI.NOM=NomCli 

// Indirection typée
{"Nom",indControl} = NomCli

// Indirection avec un nom de fichier de données dans une variable
nNomFic is string = "Client"
{nNomFic + ".Nom"} = "Durand"
HAdd({nNomFic})

// Indirection dans une procédure 
NomChamp is string
NomChamp = "SAI_SAISIE1"			// SAI_SAISIE1 est le nom du champ 
// Appel d'une procédure rendant un champ invisible 
Rend_Invisible(NomChamp)

PROCEDURE Rend_Invisible(NChamp)
{NChamp}..State = Invisible

// Indirection avec variable 
NomAlias is string
NomAlias = PreviousWin()
// NOM est le nom du champ 
// NomCli est la valeur à affecter 
{NomAlias+".NOM"} = NomCli 
Abrev is string
NomRub is string
{Abrev+"."+NomRub} = NomCli 
{Abrev+"."+NomRub} = {NomChamp}

// Déclaration d'une classe avec deux membres 
Maclasse is Class
Membre1 is string
Membre2 is string
// Affichage de la valeur d'un membre 
PROCEDURE GLOBAL AfficheMembre(Numéro)
// Récupération de la valeur du membre global choisi
Valeur is string = {"::Membre"+Numéro}
Info(Valeur)

c is cWord
var is Variable Description
Def is Definition

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

Trace(var.Name) // Affiche le nom de la variable
Trace("Version de Word: ",{c, var}) // Affiche la version de Word

Syntax

Simple indirection Hide the details

{ <Expression> }

<Expression>: Character string

Expression used to identify the control, the variable or the item to use. The element is sought:
among the variables,
according to the number of dots found in the name:
0 point: search among fields, then HFSQL items.
1 point: search through HFSQL fields, then query parameters.
greater than 1 point: search among fields.
among the special elements kept for compatibility (_Tabx for example, ...).
A WLanguage error occurs if this expression corresponds to an empty string ("").

Indirection on a class member Hide the details

{ <Expression> }

<Expression>: Character string

Expression used to identify the class member.
If the member is:
global, use the following syntax: {" :: MemberName"}
is not global, use the following syntax: {" : MemberName"}
A WLanguage error occurs if this expression corresponds to an empty string ("").

Indirection on a class member Hide the details

{ <Class> , <Member> }

<Class>: Character string

Class instance

<Member>: Character string or Variable Description variable

Corresponds to:
the member name,
a variable of type Variable Description.

Indirection by specifying the element type (optimizes the execution speed) Hide the details

{ <Expression>, <Type> }

<Expression>: Character string

Expression used to identify the control, the variable or the item to use. A WLanguage error occurs if this expression corresponds to an empty string ("").

<Type>: Constant

Constant used to specify the type of sought element:
indControl Element sought among the controls and the groups.
indConnection Element sought among the connections.
indReport Element sought among the reports.
indWindow Element sought among the windows.
indFile Item searched for in data files.
indGPW Element sought among the elements of user groupware (used to retrieve the initial status of controls).
indLink Element sought among the links.
indQueryParameter Element sought among the parameters of queries.
indItem Element sought among the items.
indVariable Element sought among the variables.
The element is only sought within the global variables.
indPage Element sought among the pages.

Remarks

When should indirection be used?

The indirection can be used for example:

To access the value of an element (control, variable, item, ...):
```
{s_NomChamp} = 10
ValeurChamp = {s_NomChamp}
```
To use a property:
```
{s_NomChamp}..Height = 10
```

To programmatically handle a column of a Table control:

{s_NomColonne, indControl}[Numéro_Ligne] = 10

To handle a table column:

{s_NomTable + "." +s_NomColonne, indControl}[Numéro_Ligne] = 10

Identifying the current object

To identify the current object, use the following keywords:

MySelf: the current control
MyWindow: the current window
MyPage: the current page
This keyword is not available.
MyReport: the current report
This keyword is not available.
MySource: the current data source.
MyFile: the data file that triggered the current trigger.

Indirection on a structure

An indirection cannot contain an access to a structure or to a class instance. However, the following syntax can be used:

{<Variable structure>}: member

Using the indirection on the paths in an XML document

The indirection operators can be used to build the path of an element in an XML document.

Example:

sDocXML is string = [
	<?xml version="1.0" encoding="UTF-8"?>
	<Document>
	<InfoVersion>
	<Version>21</Version>
	<Millesime>2016</Millesime>
	</InfoVersion>
	</Document>
]

xmlExemple is xmlDocument = XMLOpen(sDocXML, fromString)

sParam is string = "WinDev_Param"

// Lecture directe d'une information ...
Trace(xmlExemple.Document.InfoVersion.Version) 

// Lecture avec une partie du chemin XML contenu dans une variable
// (idem si rubrique d'un fichier, paramètre d'une fenêtre, méthode, ...)
sParamètre is string = "InfoVersion"
Trace ({"xmlExemple.Document." + sParamètre + ".Version"})

Limitations

The indirection operator allows you to find an element by its name.

Therefore, the following operations are not allowed in an indirection:

access to a member of a class instance or structure other than the current class instance (operators: and:: ).
access to a subelement in a control or array ([] operator).
access to a substring ([[]] operator).
access to a property (.. operator).
indirection ({ } operator).
call to a procedure or to a method of Automation object.
declaring a variable.

Remarks:

Access operators on an element (operators: and [] and [[]] and . ) can be used on the element obtained by indirection. For example:
{ <indirection> }: member

{ <indirection> } [index]

{ <indirection> } [[ index ]]

{ <indirection> }..property
To call a procedure identified by its name, use Execute or ExecuteProcess.
To combine these operations dynamically, you have the ability to use the dynamic compilation (see Compile).

Indirections in Java

Indirections are not supported by local variables.

Related Examples:

Unit examples (WINDEV): The indirections

[ + ] Handling indirections via the { and } operators.
The { and } operators are used to access a control or a file item by dynamically building the control name or the item name.
This program, powered by WINDEV, implements the indirection mechanism on the window controls to manage the "Undo-Redo" and "Cut-Copy-Paste" features in a generic way.

Unit examples (WEBDEV): The indirections

[ + ] This example explains how to use the indirections on a variable.

You will notice that the indirections are available for the controls, the items, the links, etc. The principle is identical to the one presented in this example.

Unit examples (WINDEV Mobile): The indirections

[ + ] Using the indirection { and } operators.
The { and } operators are used to access a control or a file item by dynamically building the control name or the item name.
This example implements the indirection mechanism on the window controls to manage the "Undo-Redo" and "Cut-Copy-Paste" features in a generic way.