RAD Studio - Contributions [fr]

Méthodes (Delphi)

2023-05-24T14:14:20Z

Rrivero : RS-114150. Added static to Binding Methods enumeration

{{Parent|Classes et objets - Index}}
__TOC__
<ideTag id="reintroduce"></ideTag>
<ideTag id="overload"></ideTag>
<ideTag id="abstract"></ideTag>
<ideTag id="virtual"></ideTag>
<ideTag id="dynamic"></ideTag>
<ideTag id="register"></ideTag>
<ideTag id="pascal"></ideTag>
<ideTag id="cdecl"></ideTag>
<ideTag id="stdcall"></ideTag>
<ideTag id="safecall"></ideTag>
<ideTag id="platform"></ideTag>
<ideTag id="deprecated"></ideTag>
<ideTag id="library"></ideTag>
<ideTag id="inherited"></ideTag>
<ideTag id="Self"></ideTag>
<ideTag id="static"></ideTag>
<ideTag id="override"></ideTag>
<ideTag id="final"></ideTag>
<ideTag id="class"></ideTag>
<ideTag id="read"></ideTag>
<ideTag id="write"></ideTag>
<ideTag id="constructor"></ideTag>
<ideTag id="nill"></ideTag>
<ideTag id="if"></ideTag>
<ideTag id="destructor"></ideTag>
<ideTag id="message"></ideTag>
<ideTag id="DefaultHandler"></ideTag>
<ideTag id="Dispatch"></ideTag>
Une méthode est une procédure ou une fonction associée à une classe. Un appel de méthode spécifie l'objet (ou la classe si c'est une méthode de classe) sur lequel la méthode agit. Par exemple, SomeObject.Free appelle la méthode Free de SomeObject.

Cette rubrique couvre les sujets suivants :

* Déclarations et implémentations de méthodes
* Liaison de méthodes
* Surcharge de méthodes
* Constructeurs et destructeurs
* Méthodes de messages

==A propos des méthodes==

Au sein d'une déclaration de classe, les méthodes apparaissent comme des en-têtes de procédures ou de fonctions qui fonctionnent comme les déclarations '''forward'''. Quelque part après la déclaration de classe, mais à l'intérieur du même module, chaque méthode doit être implémentée par une déclaration de définition. Si; par exemple, la déclaration de TMyClass contient une méthode appelée DoSomething :

<source lang="delphi">
type
TMyClass = class(TObject)
...
procedure DoSomething;
...
end;
</source>

Une déclaration de définition pour DoSomething doit apparaître plus loin dans le module :

<source lang="delphi">
procedure TMyClass.DoSomething;
begin
...
end;
</source>

Si une classe peut être déclarée dans la section interface ou la section implementation d'une unité, les déclarations de définition des méthodes de classe doivent se trouver dans la section implementation.

Dans l'en-tête d'une déclaration de définition, le nom de la méthode est toujours qualifié par le nom de la classe à laquelle elle appartient. L'en-tête peut répéter la liste de paramètres depuis la déclaration de classe ; si c'est le cas, l'ordre, le type et le nom des paramètres doivent correspondre exactement et, si la méthode est une fonction, la valeur de retour doit aussi correspondre.

Les déclarations des méthodes peuvent inclure des directives spéciales qui ne sont pas utilisées par d'autres fonctions ou procédures. Les directives doivent apparaître uniquement dans la déclaration de classe et pas dans la déclaration de définition, et doivent toujours être dans l'ordre suivant :

'''reintroduce'''; '''overload'''; [[#Liaison de méthode|liaison]]; [[Procédures et fonctions (Delphi)#Conventions d'appel|convention d'appel]]; '''abstract'''; [[Déclarations et instructions (Delphi)#Directives de conseil|avertissement]]

Où :

* [[#Liaison de méthode|liaison]] correspond à '''static''', '''virtual''', '''dynamic''' ou '''override''' ;
* [[Procédures et fonctions (Delphi)#Conventions d'appel|convention d'appel]] correspond à '''register''', '''pascal''', '''cdecl''', '''stdcall''', or '''safecall''';
* [[Déclarations et instructions (Delphi)#Directives de conseil|avertissement]] correspond à '''platform''', '''deprecated''' ou '''library'''. Pour plus d'informations sur ces directives d'avertissement (de conseil), voir [[Déclarations et instructions (Delphi)#Directives de conseil|Directives de conseil]].

Toutes les directives {{Delphi}} sont listées dans [[Eléments syntaxiques fondamentaux (Delphi)#Directives|Directives]].

===Inherited===

Le mot réservé '''inherited''' joue un rôle particulier dans l'implémentation de comportements polymorphiques. Il peut apparaître dans une définition de méthode avec ou sans identificateur à la suite.

Si '''inherited''' est suivi par le nom d'un membre, il représente un appel de méthode normal ou une référence à une propriété ou à un champ, sauf que la recherche du membre référencé commence avec l'ancêtre immédiat de la classe de la méthode englobante. Par exemple, quand l'instruction :

<source lang="delphi">
inherited Create(...);
</source>

apparaît dans la définition d'une méthode, elle appelle la méthode Create héritée.

Quand '''inherited''' est utilisé sans être suivi d'un identificateur, il désigne la méthode héritée portant le même nom que la méthode en cours ou, si la méthode en cours est un gestionnaire de message, le gestionnaire de message hérité pour le même message. Dans ce cas, '''inherited''' ne prend pas de paramètres explicites, mais transmet à la méthode héritée les paramètres utilisés pour l'appel de la méthode englobante. Par exemple :

<source lang="delphi">
inherited;
</source>

apparaît fréquemment dans l'implémentation des constructeurs. Cette instruction appelle le constructeur hérité avec les mêmes paramètres que ceux transmis au descendant.

===Self===

Au sein de l'implémentation d'une méthode, l'identificateur '''Self''' référence l'objet dans lequel la méthode est appelée. Voici, par exemple, l'implémentation de la méthode Add de TCollection dans l'unité Classes :

<source lang="delphi">
function TCollection.Add: TCollectionItem;
begin
Result := FItemClass.Create(Self);
end;
</source>

La méthode Add appelle la méthode Create de la classe référencée par le champ FItemClass, qui est toujours un descendant de TCollectionItem. TCollectionItem.Create ne prend qu'un seul paramètre de type TCollection, donc Add le transmet à l'objet instance de TCollection où Add est appelée. Cela est illustré dans le code suivant :

<source lang="delphi">
var MyCollection: TCollection;
...
MyCollection.Add // MyCollection is passed to the
// TCollectionItem.Create method
</source>

'''Self''' est utile pour diverses raisons. Par exemple, un identificateur de membre déclaré dans un type classe peut être redéclaré dans le bloc de l'une des méthodes de la classe. Dans ce cas, vous pouvez accéder à l'identificateur du membre d'origine en utilisant Self.Identifier.

Pour plus d'informations sur '''Self''' dans les méthodes de classe, voir "Opérateurs de classes" dans [[Références de classes|Références de classes]].

==Liaison de méthode==

Les liaisons de méthodes peuvent être '''statiques''' (par défaut), '''virtuelles''' ou '''dynamiques'''. Les méthodes virtuelles et dynamiques peuvent être redéfinies et elles peuvent être abstraites. Ces désignations jouent un rôle quand une variable d'un type classe contient une valeur d'un type classe descendant. Elles déterminent quelle implémentation est activée lors de l'appel d'une méthode.

===Méthodes statiques===

Par défaut les méthodes sont statiques. Quand une méthode statique est appelée, le type déclaré (à la compilation) de la variable classe ou objet utilisé dans l'appel de la méthode détermine l'implémentation à activer. Dans l'exemple suivant, les méthodes Draw sont statiques :

<source lang="delphi">
type
TFigure = class
procedure Draw;
end;

TRectangle = class(TFigure)
procedure Draw;
end;
</source>

Etant donné ces déclarations, le code suivant illustre l'effet de l'appel d'une méthode statique. Dans le second appel à Figure.Draw, la variable Figure référence un objet de classe TRectangle, mais l'appel invoque l'implémentation de Draw dans TFigure, car le type déclaré de la variable Figure est TFigure :

<source lang="delphi">
var
Figure: TFigure;
Rectangle: TRectangle;

begin
Figure := TFigure.Create;
Figure.Draw; // calls TFigure.Draw
Figure.Destroy;
Figure := TRectangle.Create;
Figure.Draw; // calls TFigure.Draw

TRectangle(Figure).Draw; // calls TRectangle.Draw

Figure.Destroy;
Rectangle := TRectangle.Create;
Rectangle.Draw; // calls TRectangle.Draw
Rectangle.Destroy;
end;
</source>

===Méthodes virtuelles et dynamiques===

Pour rendre une méthode '''virtuelle''' ou '''dynamique''', incluez la directive '''virtual''' ou '''dynamic''' dans sa déclaration. Les méthodes dynamiques et virtuelles, à la différence des méthodes statiques, peuvent être redéfinies dans les classes descendantes. Quand une méthode redéfinie est appelée, le type réel (à l'exécution) de la classe ou de l'objet utilisé dans l'appel de la méthode, et non pas le type déclaré de la variable, détermine l'implémentation à activer.

Pour redéfinir une méthode, redéclarez-la avec la directive '''override'''. Une déclaration '''override''' doit correspondre à la déclaration de l'ancêtre dans l'ordre et le type de ses paramètres, ainsi que dans son type de résultat (le cas échéant).

Dans l'exemple suivant, la méthode Draw déclarée dans TFigure est redéfinie dans deux classes descendantes :

<source lang="delphi">
type
TFigure = class
procedure Draw; virtual;
end;

TRectangle = class(TFigure)
procedure Draw; override;
end;

TEllipse = class(TFigure)
procedure Draw; override;
end;
</source>

Etant donné ces déclarations, le code suivant illustre l'effet de l'appel d'une méthode virtuelle via une variable dont le type réel change à l'exécution :

<source lang="delphi">
var
Figure: TFigure;

begin
Figure := TRectangle.Create;
Figure.Draw; // calls TRectangle.Draw
Figure.Destroy;
Figure := TEllipse.Create;
Figure.Draw; // calls TEllipse.Draw
Figure.Destroy;
end;
</source>

Seules les méthodes '''virtuelles''' et '''dynamiques''' peuvent être redéfinies. Par contre, toutes les méthodes peuvent être surchargées ; voir [[#Surcharge des méthodes|Surcharge des méthodes]].

====Méthodes finales====

Le compilateur {{Delphi}} prend aussi en charge le concept de méthodes virtuelles et dynamiques '''finales'''. Les déclarations des méthodes finales ont la forme suivante :

function|procedure FunctionName; virtual|dynamic; final;

Ici, la syntaxe <code>virtual|dynamic</code> (deux mots clé et le symbole <code>|</code> entre les mots clés) est utilisée pour spécifier qu'un seul des mots clés '''virtual''' ou '''dynamic''' doit être utilisé. Seul le mot clé '''virtual''' ou '''dynamic''' n'a de sens; le symbole de tuyau lui-même doit être supprimé.

Seul le mot clé '''final''' est appliqué à une méthode virtuelle ou dynamique, aucune classe descendante ne peut redéfinir cette methode. L'usage du mot clé '''final''' est une décision de conception importante qui permet de définir l'utilisation de la classe. Il peut aussi donner au compilateur des conseils lui permettant d'optimiser le code produit.

<blockquote>'''Remarque :''' Les mots clés '''virtual''' ou '''dynamic''' doivent être écrits avant le mot clé '''final'''.</blockquote>

'''Exemple'''
<source lang="delphi">
type
Base = class
procedure TestProcedure; virtual;
procedure TestFinalProcedure; virtual; final;
end;

Derived = class(Base)
procedure TestProcedure; override;
//Ill-formed: E2352 Cannot override a final method
procedure TestFinalProcedure; override;
end;
</source>

====Comparaison des méthodes virtuelles et des méthodes dynamiques====

Dans {{Delphi}} pour Win32, d'un point de vue sémantique, les méthodes virtuelles et les méthodes dynamiques sont équivalentes. Toutefois, elles diffèrent dans l'implémentation de la répartition de l'appel de méthode à l'exécution : les méthodes virtuelles optimisent la rapidité alors que les méthodes dynamiques optimisent la taille du code.

En général, les méthodes virtuelles constituent la manière la plus efficace d'implémenter un comportement polymorphique. Les méthodes dynamiques sont utiles quand une classe de base déclare de nombreuses méthodes pouvant être redéfinies qui sont héritées par de nombreuses classes descendantes d'une application, mais rarement redéfinies.

<blockquote>'''Remarque :''' N'utilisez les méthodes dynamiques que s'il existe un avantage clair et visible de le faire. Utilisez habituellement les méthodes virtuelles.</blockquote>

====Redéfinition ou dissimulation====

Si une déclaration de méthode spécifie le même identificateur de méthode et la même signature de paramètre qu'une méthode héritée, sans spécifier '''override''', la nouvelle déclaration masque ou dissimule simplement la méthode héritée sans la redéfinir. Les deux méthodes existent alors dans la classe descendante, où le nom de méthode est lié statiquement. Par exemple :

<source lang="delphi">
type
T1 = class(TObject)
procedure Act; virtual;
end;

T2 = class(T1)
procedure Act; // Act is redeclared, but not overridden
end;

var
SomeObject: T1;

begin
SomeObject := T2.Create;
SomeObject.Act; // calls T1.Act
end;
</source>

====Reintroduce====

La directive '''reintroduce''' supprime les avertissements du compilateur informant qu'une méthode virtuelle précédemment déclarée est masquée. Par exemple :

<source lang="delphi">
procedure DoSomething; reintroduce; // The ancestor class also
// has a DoSomething method
</source>

Utilisez '''reintroduce''' quand vous voulez masquer une méthode virtuelle héritée par une nouvelle méthode.

====Méthodes abstraites====

Une méthode abstraite est une méthode virtuelle ou dynamique n'ayant pas d'implémentation dans la classe où elle est déclarée. Son implémentation est déléguée à une classe descendante. Les méthodes abstraites doivent être déclarées en spécifiant la directive '''abstract''' après '''virtual''' ou '''dynamic'''. Par exemple :

<source lang="delphi">
procedure DoSomething; virtual; abstract;
</source>

Vous ne pouvez appeler une méthode '''abstraite''' que dans une classe ou une instance d'une classe dans laquelle la méthode a été redéfinie.

==Méthodes de classe==

La plupart des méthodes sont appelées méthodes d'instance, car elles opèrent sur une instance individuelle d'un objet. Une méthode de classe est une méthode (autre qu'un constructeur) qui agit sur des classes et pas sur des objets. Il existe deux types de méthodes de classe : les méthodes de classe ordinaires et les méthodes statiques de classe.

===Méthodes de classe ordinaires===

La définition d'une méthode de classe doit commencer par le mot réservé '''class'''. Par exemple :

<source lang="delphi">
type
TFigure = class
public
class function Supports(Operation: string): Boolean; virtual;
class procedure GetInfo(var Info: TFigureInfo); virtual;
...
end;
</source>

La déclaration de définition d'une méthode de classe doit aussi commencer par '''class'''. Par exemple :

<source lang="delphi">
class procedure TFigure.GetInfo(var Info: TFigureInfo);
begin
...
end;
</source>

Dans la déclaration de définition d'une méthode de classe, l'identificateur '''Self''' représente la classe où la méthode est appelée (ce peut être un descendant de la classe dans laquelle elle est définie). Si la méthode est appelée dans la classe C, alors '''Self''' est de type class of C. Vous ne pouvez donc pas utiliser '''Self''' pour accéder à des champs d'instance, des propriétés d'instance et des méthodes normales (objet). Vous pouvez utiliser '''Self''' pour appeler les constructeurs ou d'autres méthodes de classe, ou pour accéder aux propriétés de classe et aux champs de classe.

Une méthode de classe peut être appelée via une référence de classe ou une référence d'objet. Quand elle est appelée via une référence d'objet, la classe de l'objet devient la valeur de '''Self'''.

===Méthodes statiques de classe===

Comme les méthodes de classe, les méthodes statiques de classe peuvent être accessibles sans une référence d'objet. A la différence des méthodes de classe ordinaires, les méthodes statiques de classe n'ont pas de paramètre '''Self'''. Elles ne peuvent pas accéder aux membres d'instance. Elles peuvent toujours accéder aux champs de classe, aux propriétés de classe et aux méthodes de classe. En outre, contrairement aux méthodes de classe, les méthodes statiques de classe ne peuvent pas être déclarées '''virtual'''.

Pour rendre une méthode de classe statique, ajoutez le mot '''static''' à leur déclaration, par exemple :

<source lang="delphi">
type
TMyClass = class
strict private
class var
FX: Integer;

strict protected
// Note: Accessors for class properties
// must be declared class static.
class function GetX: Integer; static;
class procedure SetX(val: Integer); static;

public
class property X: Integer read GetX write SetX;
class procedure StatProc(s: String); static;
end;
</source>

Comme pour une méthode de classe, vous pouvez appeler une méthode statique de classe par l'intermédiaire du type de la classe (par exemple, sans référence d'objet), comme suit :

<source lang="delphi">
TMyClass.X := 17;
TMyClass.StatProc('Hello');
</source>

==Surcharge des méthodes==

Une méthode peut être redéclarée en utilisant la directive '''overload'''. Dans ce cas, si la méthode redéclarée a une signature de paramètre différente de celle de son ancêtre, elle surcharge la méthode héritée sans la cacher. L'appel de la méthode dans une classe descendante active l'implémentation qui correspond aux paramètres de l'appel.

Si vous surchargez une méthode virtuelle, utilisez la directive '''reintroduce''' quand vous la redéclarez dans les classes descendantes. Par exemple :

<source lang="delphi">
type
T1 = class(TObject)
procedure Test(I: Integer); overload; virtual;
end;

T2 = class(T1)
procedure Test(S: string); reintroduce; overload;
end;
...

SomeObject := T2.Create;
SomeObject.Test('Hello!'); // calls T2.Test
SomeObject.Test(7); // calls T1.Test
</source>

Dans une classe, vous ne pouvez pas publier plusieurs méthodes surchargées portant le même nom. La maintenance des informations de type à l'exécution requiert un nom unique pour chaque membre '''publié''' :

<source lang="delphi">
type
TSomeClass = class
published
function Func(P: Integer): Integer;
function Func(P: Boolean): Integer; // error
...
</source>

Les méthodes qui servent de spécificateurs de '''lecture''' ou d''''écriture''' de propriétés ne peuvent pas être surchargées.

L'implémentation d'une méthode surchargée doit répéter la liste des paramètres depuis la déclaration de classe. Pour davantage d'informations sur la surcharge, voir [[Procédures et fonctions (Delphi)#Surcharge de procédures et de fonctions|Surcharge de procédures et de fonctions]] dans [[Procédures et fonctions (Delphi)|Procédures et fonctions (Delphi)]].

==Constructeurs==

Un constructeur est une méthode spéciale qui crée et initialise des instances d'objet. La déclaration d'un constructeur ressemble à celle d'une procédure, sauf qu'elle commence par le mot '''constructor'''. Exemples :

<source lang="delphi">
constructor Create;
constructor Create(AOwner: TComponent);
</source>

Les constructeurs doivent utiliser la convention d'appel '''register''' par défaut. Bien que la déclaration ne spécifie pas de valeur de retour, un constructeur renvoie une référence à l'objet qu'il a créé ou qui est appelé.

Une classe peut avoir plusieurs constructeurs mais doit en avoir au moins un. L'habitude veut qu'on appelle le constructeur Create.

Pour créer un objet, appelez la méthode constructeur sur un type classe. Par exemple :

<source lang="delphi">
MyObject := TMyClass.Create;
</source>

Cette instruction alloue le stockage pour le nouvel objet, définit la valeur de tous les champs ordinaux sur zéro, assigne '''nil''' à tous les champs de type pointeur ou de type classe, et une chaîne vide à tous les champs chaîne. Les autres actions spécifiées dans l'implémentation du constructeur sont effectuées ensuite. Généralement, les objets sont initialisés en fonction des valeurs transmises comme paramètres au constructeur. Enfin, le constructeur renvoie une référence à l'objet qui vient d'être créé et initialisé. Le type de la valeur de retour est le même que le type classe spécifié dans l'appel du constructeur.

Si une exception est déclenchée lors de l'exécution d'un constructeur invoqué sur une référence de classe, le destructeur Destroy est appelé automatiquement pour détruire l'objet inachevé.

Quand un constructeur est appelé en utilisant une référence d'objet (au lieu d'une référence de classe), il ne crée pas d'objet. Le constructeur agit à la place sur l'objet spécifié, en n'exécutant que les instructions de l'implémentation du constructeur et renvoie ensuite une référence à l'objet. Un constructeur est typiquement invoqué sur une référence d'objet en conjonction avec le mot réservé '''inherited''' afin d'exécuter un constructeur hérité.

Voici un exemple du type classe et de son constructeur :

<source lang="delphi">
type
TShape = class(TGraphicControl)
private
FPen: TPen;
FBrush: TBrush;
procedure PenChanged(Sender: TObject);
procedure BrushChanged(Sender: TObject);
public
constructor Create(Owner: TComponent); override;
destructor Destroy; override;
...
end;

constructor TShape.Create(Owner: TComponent);
begin
inherited Create(Owner); // Initialize inherited parts
Width := 65; // Change inherited properties
Height := 65;
FPen := TPen.Create; // Initialize new fields
FPen.OnChange := PenChanged;
FBrush := TBrush.Create;
FBrush.OnChange := BrushChanged;
end;
</source>

Généralement, la première action d'un constructeur est d'appeler le constructeur hérité afin d'initialiser les champs hérités de l'objet. Le constructeur initialise ensuite les champs introduits dans la classe descendante. Comme un constructeur efface toujours le stockage alloué à un nouvel objet, tous les champs contiennent au départ zéro (pour les types ordinaux), '''nil''' (types pointeur et classe), chaîne vide (types chaîne) ou Unassigned (variants). Il n'est donc pas nécessaire que l'implémentation du constructeur initialise les champs sauf ceux devant contenir une valeur non nulle ou non vide.

Quand il est invoqué par le biais d'un identificateur de type classe, un constructeur déclaré comme '''virtual''' est équivalent à un constructeur statique. Quand ils sont combinés avec des types référence de classe, les constructeurs virtuels permettent une construction polymorphique des objets, c'est-à-dire la construction d'objets dont le type est inconnu à la compilation. (Voir [[Références de classes|Références de classes]].)

==Destructeurs==

Un destructeur est une méthode spéciale qui détruit l'objet à l'endroit de son appel et libère sa mémoire. La déclaration d'un destructeur ressemble à celle d'une procédure, mais elle commence par le mot '''destructor'''. Exemple :

<source lang="delphi">
destructor SpecialDestructor(SaveData: Boolean);
destructor Destroy; override;
</source>

Les destructeurs sur Win32 doivent utiliser la convention d'appel '''register''' par défaut. Même si une classe peut avoir plusieurs destructeurs, il est conseillé que chaque classe redéfinisse la méthode Destroy héritée et ne déclare pas d'autres destructeurs.

Pour appeler un destructeur, vous devez référencer une instance d'objet. Par exemple :

<source lang="delphi">
MyObject.Destroy;
</source>

Lors de l'appel d'un destructeur, les actions spécifiées dans l'implémentation du destructeur sont d'abord exécutées. Typiquement, cela consiste à détruire les objets incorporés et à libérer les ressources allouées par l'objet. Ensuite, le stockage alloué à l'objet est libéré.

Voici un exemple d'implémentation d'un destructeur :

<source lang="delphi">
destructor TShape.Destroy;
begin
FBrush.Free;
FPen.Free;
inherited Destroy;
end;
</source>

Typiquement, la dernière action de l'implémentation d'un destructeur est l'appel du destructeur hérité afin de détruire les champs hérités de l'objet.

Quand une exception est déclenchée lors de la création d'un objet, Destroy est appelée automatiquement afin de libérer l'objet inachevé. Cela signifie que Destroy doit être préparé à libérer des objets partiellement construits. Comme un constructeur définit les champs d'un nouvel objet sur zéro ou sur des valeurs vides avant d'effectuer d'autres actions, les champs de type classe ou pointeur d'un objet partiellement construit sont toujours définis sur '''nil'''. Un destructeur doit donc tester les valeurs '''nil''' avant d'agir sur des champs de type classe ou pointeur. L'appel de la méthode '''Free''' (définie dans TObject) au lieu de Destroy, permet de tester facilement les valeurs '''nil''' avant de détruire un objet.

==Constructeurs de classes==

Un constructeur de classe est une méthode de classe spéciale qui n'est pas accessible aux développeurs. Les appels des constructeurs de classes sont automatiquement insérés par le compilateur dans la section d'initialisation de l'unité où la classe est définie. Normalement, les constructeurs de classes sont utilisés pour initialiser les champs statiques de la classe ou effectuer un type d'initialisation, nécessaire avant que la classe ou toute instance de classe puisse fonctionner correctement. Bien que le même résultat puisse être obtenu en plaçant le code d'initialisation de la classe dans la section ''initialization'', les constructeurs de classes ont l'avantage d'aider le compilateur à déterminer les classes qui doivent être incluses dans le fichier binaire final et celles qui doivent être retirées.

L'exemple suivant illustre la façon habituelle d'initialiser les champs de classes :

<source lang="delphi">
type
TBox = class
private
class var FList: TList<Integer>;
end;

implementation

initialization
{ Initialize the static FList member }
TBox.FList := TList<Integer>.Create();

end.
</source>

Cette méthode a un gros désavantage : même si une application peut inclure l'unité dans laquelle '''TBox''' est déclaré, elle ne peut jamais réellement utiliser la classe '''TBox'''. Dans l'exemple en cours, la classe TBox est incluse dans le binaire résultant, car elle est référencée dans la section initialization. Pour alléger ce problème, considérons l'utilisation des constructeurs de classes :

<source lang="delphi">
type
TBox = class
private
class var FList: TList<Integer>;
class constructor Create;
end;

implementation

class constructor TBox.Create;
begin
{ Initialize the static FList member }
FList := TList<Integer>.Create();
end;

end.
</source>

Dans ce cas, le compilateur vérifie si TBox est réellement utilisé quelque part dans l'application, et en cas d'utilisation, un appel au constructeur de classe est ajouté automatiquement à la section initialization de l'unité.

'''Remarque :''' Même si le compilateur fait attention à l'ordre d'initialisation des classes, l'ordre peut devenir aléatoire dans certains scénarios complexes. Cela se produit quand le constructeur d'une classe dépend de l'état d'une autre classe qui, à son tour, dépend de la première classe.

'''Remarque :''' Le constructeur de classe relatif à un enregistrement ou une classe générique peut s'exécuter plusieurs fois. Le nombre exact de fois que le constructeur de classe est exécuté dans ce cas dépend du nombre de versions spécialisées du type générique. Par exemple, le constructeur de classe pour une classe ''TList<String>'' spécialisée peut s'exécuter plusieurs fois dans la même application.

==Destructeurs de classes==

Les destructeurs de classes sont l'opposé des constructeurs de classes, dans le fait qu'ils réalisent la finalisation de la classe. Les destructeurs de classes présentent les mêmes avantages que les constructeurs de classes, à l'exception des fonctions de ''finalisation''.

L'exemple suivant est construit sur l'exemple présenté dans les constructeurs de classes et il introduit la routine de finalisation :

<source lang="delphi">
type
TBox = class
private
class var FList: TList<Integer>;
class constructor Create;
class destructor Destroy;
end;

implementation

class constructor TBox.Create;
begin
{ Initialize the static FList member }
FList := TList<Integer>.Create();
end;

class destructor TBox.Destroy;
begin
{ Finalize the static FList member }
FList.Free;
end;

end.
</source>

'''Remarque :''' Le destructeur de classe relatif à un enregistrement ou une classe générique peut s'exécuter plusieurs fois. Le nombre exact de fois que le destructeur de classe est exécuté dans ce cas dépend du nombre de versions spécialisées du type générique. Par exemple, le destructeur de classe pour une classe ''TList<String>'' spécialisée peut s'exécuter plusieurs fois dans la même application.

==Méthodes de messages==

Les méthodes de messages implémentent des réponses à des messages répartis dynamiquement. La syntaxe des méthodes de messages est supportée sur toutes les plates-formes. <f s="vcl" t="span" />La VCL utilise des méthodes de messages pour répondre aux messages Windows. <f e="vcl" t="span" />

Une méthode de message est créée en incluant la directive '''message''' dans une déclaration de méthode, suivie d'une constante entière comprise entre 1 et 49151 qui spécifie l'identificateur du message. <f s="vcl" t="span" /> Pour les méthodes de messages des contrôles VCL, la constante entière peut être l'un des identificateurs de messages Win32, avec les types d'enregistrements correspondants, dans l'unité Messages. <f e="vcl" t="span" /> Une méthode de message doit être une procédure qui n'attend qu'un seul paramètre '''var'''.

Par exemple :

<source lang="delphi">
type
TTextBox = class(TCustomControl)
private
procedure WMChar(var Message: TWMChar); message WM_CHAR;
...
end;
</source>

Une méthode de message n'a pas besoin d'inclure la directive '''override''' pour redéfinir une méthode de message héritée. En fait, il n'est pas nécessaire de spécifier le même nom de méthode ou type de paramètre que la méthode qu'elle redéfinit. L'identificateur du message détermine seul les messages auxquels la méthode répond et s'il s'agit d'une redéfinition.

===Implémentation des méthodes de messages===

L'implémentation d'une méthode de message peut appeler la méthode de message héritée, comme dans l'exemple suivant :

<source lang="delphi">
procedure TTextBox.WMChar(var Message: TWMChar);
begin
if Message.CharCode = Ord(#13) then
ProcessEnter
else
inherited;
end;
</source>

L'instruction '''inherited''' effectue une recherche arrière dans la hiérarchie des classes et invoque la première méthode de message ayant le même identificateur que la méthode en cours, et lui transmet automatiquement l'enregistrement message. Si aucune classe ancêtre n'implémente de méthode de message pour l'identificateur spécifié, '''inherited''' appelle la méthode DefaultHandler définie initialement dans TObject.

L'implémentation de DefaultHandler dans TObject rend simplement le contrôle sans rien faire. En redéfinissant DefaultHandler, une classe peut implémenter sa propre gestion par défaut des messages. Sous Win32, la méthode DefaultHandler pour les contrôles appelle DefWindowProc de l'API Win32.

===Répartition des messages===

Les gestionnaires de messages sont rarement appelés directement. A la place, les messages sont répartis sur un objet en utilisant la méthode Dispatch héritée de TObject :

<source lang="delphi">
procedure Dispatch(var Message);
</source>

Le paramètre Message transmis à Dispatch doit être un enregistrement dont la première entrée est un champ de type '''Word''' contenant un identificateur de message.

Dispatch effectue une recherche arrière dans la hiérarchie des classes, en commençant par la classe de l'objet où elle est appelée, et invoque la première méthode de message pour l'identificateur qui lui a été transmis. Si aucune méthode de message n'est trouvée pour l'identificateur donné, Dispatch appelle DefaultHandler.

==Voir aussi==

*[[Classes et objets (Delphi)|Classes et objets (Delphi)]]
*[[Champs (Delphi)|Champs (Delphi)]]
*[[Propriétés (Delphi)|Propriétés (Delphi)]]
*[[Déclarations de types imbriqués|Déclarations de types imbriquées]]
*[[Références de classes|Références de classes]]
*[[Exceptions (Delphi)|Exceptions (Delphi)]]
*[[Surcharge d'opérateurs (Delphi)|Surcharge d'opérateurs (Delphi)]]
*[[Assistances de classes et d'enregistrements (Delphi)|Assistances de classes et d'enregistrements (Delphi)]]
* [[Procédures et fonctions (Delphi)|Procédures et fonctions (Delphi)]]
* [[Contrôle des programmes (Delphi)|Contrôle des programmes (Delphi)]]

{{DEFAULTSORT:Methodes (Delphi)}}
[[Category:Delphi]]
[[Category:Guide du langage Delphi]]
[[Category:AMMigrate]]

[[en:Methods (Delphi)]]
[[de:Methoden (Delphi)]]
[[ja:メソッド（Delphi）]]

Concepteur de fiches

2022-12-19T15:17:22Z

Rrivero : RS-115132. Removed HTML Designer Section

{{Parent|Introduction à RAD Studio}}

<f s="radstudio" />
Le '''Concepteur de fiches''' (ou Concepteur) est affiché automatiquement quand vous créez ou éditez une fiche, telle qu'une {{f|radstudio|[[Application Fiches VCL|application Fiches VCL]] ou une}} [[Application HD multi-périphérique|Application HD multi-périphérique]].
Le '''Concepteur de fiches''' s'exécute automatiquement quand vous créez une application graphique qui utilise un fichier fiche : un fichier <code>.dfm</code> ou <code>.fmx</code>.
<f e="radstudio" />
<f s="appmethod" />
Le '''Concepteur de fiches''' (ou Concepteur) est affiché automatiquement quand vous créez ou éditez une fiche, telle qu'une [[Application HD multi-périphérique|Application HD multi-périphérique]].
Le '''Concepteur de fiches''' s'exécute automatiquement quand vous créez une application graphique qui utilise un fichier fiche (un fichier <code>.fmx</code>).
<f e="appmethod" />
Pour attribuer la focalisation au '''Concepteur de fiches''' quand un projet visuel est ouvert dans l'EDI, cliquez sur l'onglet '''Conception''' en bas de la fenêtre d'édition principale :
[[Image:CodeDesignHistoryTabs.jpg|Onglets Code, Conception et Historique]]

L'apparence et les fonctionnalités du Concepteur peuvent changer selon le type de fiche que vous créez ou éditez. Par exemple, si vous utilisez un élément HTML, vous pouvez afficher [[Utilisation de l'éditeur de balise HTML|l'éditeur de balise HTML]] dans le Concepteur en sélectionnant '''Voir > Editeur de balise'''.

==Fenêtre Concepteur de fiches==

<f s="radstudio" />
'''{{FM}} et la VCL ont des Concepteurs de fiches différents et des fiches différentes : '''
Voici la '''fiche multi-périphérique (FireMonkey)''' et la '''fiche VCL''' telles qu'elles apparaissent (séparément) dans le '''Concepteur de fiches''', lorsque vous créez une [[Application multi-périphérique|application multi-périphérique]] ou une [[Application Fiches VCL|application Fiches VCL]] :

 

{| border="1" frame="hsides" rules="rows"
|- valign="top"
|
'''Fiche multi-périphérique'''
|
[[Image:multidevice form.png|link=|Fiche multi-périphérique]]
|- valign="top"
|
'''Fiche VCL'''   
|
[[Image:vcl form.png|link=|Fiche VCL]]
|}

Les deux fiches semblent différentes, car une fiche VCL est une fiche Windows native, alors qu'une fiche multi-périphérique est indépendante de la plate-forme et est dessinée de façon personnalisée par les outils {{FM}}. Par exemple, une fiche VCL affiche les boutons Windows standard pour les commandes Minimiser, Redimensionner et Fermer. Une fiche multi-périphérique apparaît par défaut avec la vue '''maître''', qui est indépendante de la plate-forme. Une application multi-périphérique peut cibler toutes les plates-formes disponibles alors que la VCL cible uniquement Windows.

Malgré ces différences visuelles, le '''Concepteur de fiches''' fonctionne presque de la même façon pour {{FM}} et la VCL. Voici une différence : certaines commandes de [[#Menu contextuel|menu contextuel]] diffèrent entre {{FM}} et la VCL.
<f e="radstudio" />
<f s="appmethod" />
Voici une '''fiche multi-périphérique''' telle qu'elle apparaît dans le '''Concepteur de fiches''', lorsque vous créez une [[Application multi-périphérique|application multi-périphérique]] :

{| border="1" frame="hsides" rules="rows"
|- valign="top"
|
'''Fiche multi-périphérique'''
|
[[Image:FireMonkeyForm.png|Fiche multi-périphérique]]
|}

<f e="appmethod" />

==Sélecteur de style==

[[File:style selector.png|link=]]

Le Concepteur de fiches multi-périphériques inclut un '''sélecteur de style''' qui choisit le style de plate-forme de conception de base utilisé dans la vue '''maître'''. Les styles sont basés sur les plates-formes qu'une application multi-périphérique peut cibler :

* Windows
* macOS
* iOS
* Android

Sélectionnez le style de la vue '''maître''' à la conception pour afficher toutes les propriétés associées au style/plate-forme sélectionné. Par exemple, si vous voulez définir la propriété '''StyleLookup''' d'un [[lib_fr:FMX.StdCtrls.TButton|TButton]] pour un périphérique Android, sélectionnez le style '''Android''' ; notez que les options disponibles dans le menu déroulant de '''[[Inspecteur d'objets|l'inspecteur d'objets]]''' pour la propriété '''StyleLookup''' contiennent des sélections pour un périphérique Android.

==Sélecteur de vue==

Le '''Concepteur de fiches''' multi-périphérique inclut un '''sélecteur de vue''', un menu déroulant montrant toutes les vues '''disponibles''' qui représentent différents périphériques, tels que des périphériques iOS, Android, Windows et macOS spécifiques. Dès que vous sélectionnez les vues dans la liste '''Disponibles''' pour votre projet, ces dernières sont ajoutées à la liste '''Créées'''. Voir '''[[Utilisation des vues FireMonkey|Utilisation des vues {{FM}}]]'''.

[[File:view selector.png|link=]]

Le '''sélecteur de vue''' fournit les contrôles suivants :

{| border="1" frame="hsides" rules="rows"
|-
! ''' Icône '''
! ''' Description '''
|-
| style="text-align: left; vertical-align: top;" |
[[File:ViewSelectorMenu.png]]
| style="text-align: left; vertical-align: top;" |
Sélectionne la vue en cours à partir d'une liste déroulante de vues.

Vous pouvez ajouter une ou plusieurs vues à votre projet en cliquant simplement sur les vues de la liste '''Disponibles'''. Voir [[Ajout de vues à votre projet multi-périphérique|Ajout de vues à votre projet multi-périphérique]].

Vous pouvez également créer des vues personnalisées et les ajouter au '''sélecteur de vue'''. Voir [[Ajout d'une vue personnalisée au sélecteur de vue|Ajout d'une vue personnalisée au sélecteur de vue]].
|-
| style="text-align: left; vertical-align: top;" |
[[File:RemoveViewIcon.png]] '''Retirer une vue'''
| style="text-align: left; vertical-align: top;" |
Retire la vue en cours. Un dialogue de '''confirmation''' apparaît.

La vue est retirée du code.
|-
| style="text-align: left; vertical-align: top;" |
[[File:RotateCurrentView.png]] '''Faire pivoter la vue en cours'''
| style="text-align: left; vertical-align: top;" |
Fait pivoter la vue en cours de 90 degrés dans le sens des aiguilles d'une montre. Disponible uniquement pour les vues mobiles (indisponible pour les vues de bureau).
|-
| style="text-align: left; vertical-align: top;" |
[[File:HideShowFormFrame.png]] '''Afficher ou masquer le cadre de la fiche'''
| style="text-align: left; vertical-align: top;" |
Masque le cadre d'une vue sélectionnée (ou affiche le cadre s'il était auparavant masqué).
|}

==Composants visuels==

Vous pouvez ajouter des composants visuels à votre fiche {{f|radstudio|multi-périphérique ou VCL}} {{f|appmethod|multi-périphérique}} en faisant glisser les composants sélectionnés de la '''[[Palette d'outils|palette d'outils]]''' (située dans la section inférieure droite de l'EDI) sur la fiche. Ce sont les composants qui seront visibles par l'utilisateur final au moment de l'exécution. Les objets disponibles sur la '''palette d'outils''' changent dynamiquement selon le type d'application ou de fiche que vous concevez.

La '''[[Palette d'outils|palette d'outils]]''' inclut des contrôles tels que des boutons, des libellés, des barres d'outils et des zones de liste pour chacune des diverses catégories d'outils ; des types d'applications si vous travaillez au niveau projet, par exemple des experts DLL, des applications console ou logo ; des contrôles web, des éléments HTML et des composants de données quand vous travaillez sur une application web.

Les propriétés et événements des composants visuels et non visuels du Concepteur de fiches peuvent être visualisés et définis en utilisant '''[[Inspecteur d'objets|l'inspecteur d'objets]]'''.

==Composants non visuels==

Les composants non visuels tels qu'un [[lib_fr:FMX.Types.TCustomTouchManager.GestureManager|GestureManager]] sont attachés à la fiche, mais ils ne sont visibles que pendant la conception ; ils ne sont pas visibles par l'utilisateur final à l'exécution. Vous pouvez utiliser les composants non visuels pour réutiliser des groupes d'objets de base de données ou système ou pour isoler des parties de votre application qui gèrent la connexion de base de données ou des règles métier.

L'EDI vous permet de [[Masquer les composants non visuels|masquer ou d'afficher]] les composants non visuels à la conception.

==Menu contextuel==

Lorsque vous cliquez avec le bouton droit sur une fiche dans le '''Concepteur de fiches''', le menu contextuel est affiché. {{f|radstudio|Les commandes de menu contextuel sont disponibles à la fois pour la VCL et {{FM}}, sauf indication contraire dans le tableau suivant.}}

:'''Remarque :''' Cette section couvre seulement les éléments du menu contextuel disponibles lors de l'édition d'une fiche. Pour les modules de données, voir [[Création et modification de modules de données standard#Menu contextuel des modules de données|Menu contextuel des modules de données]].

{| border="1" frame="hsides" rules="rows"
|-
! '''Elément'''
! '''Description'''
|- valign="top"
|
Editeur d'éléments

(certains composants {{FM}})
|
Ouvre le '''Concepteur d'éléments''' avec la focalisation sur le contrôle sélectionné.
|- valign="top"
|
Ajouter un élément

(certains composants {{FM}})
|
Vous permet d'ajouter un élément au contrôle sélectionné sur la fiche. Par exemple, si vous ajoutez un contrôle [[lib_fr:FMX.Edit.TEdit|TEdit]] sur une fiche multi-périphérique, vous pouvez cliquer avec le bouton droit sur le contrôle TEdit, sélectionner '''Ajouter un élément''' et ajouter un glyphe incorporé tel que TPasswordEditButton.
|- valign="top"
|
Edition
|
Effectuez une sélection parmi les sous-commandes d'édition suivantes, qui s'appliquent au contenu du Concepteur de fiches :
* Annuler
* Couper
* Copier
* Coller
* Supprimer
* Tout sélectionner
|- valign="top"
|
Contrôle
|
Contrôle les couches d'avant-plan et d'arrière-plan du contrôle sélectionné. Choisissez parmi les sous-commandes suivantes :
* [[Mettre en avant-plan|Mettre en avant-plan]]
* [[Mettre en arrière-plan|Mettre en arrière-plan]]
|- valign="top"
|
[[Expert LiveBindings|Expert LiveBindings]]

(seulement si activé dans '''Outils > Options > LiveBindings''')
|
Ouvre '''[[Expert LiveBindings|l'expert LiveBindings]]'''.
|- valign="top"
|
[[Concepteur LiveBindings|Lier visuellement...]]
|
Ouvre le '''[[Concepteur LiveBindings|Concepteur LiveBindings]]'''.
|- valign="top"
|
Position
|
Définit l'alignement, la taille et l'échelle du contrôle sélectionné. Choisissez parmi les sous-commandes suivantes :
* [[Aligner sur la grille|Aligner sur la grille]].
* Aligner. Ouvre la boîte de dialogue [[Alignement (Concepteur de fiches)|Alignement]].
* Taille. Ouvre la boîte de dialogue [[Taille|Taille]]. {{f|radstudio|
* Echelle. Ouvre la boîte de dialogue [[Echelle|Echelle]] (disponible uniquement pour les fiches VCL). }}
|- valign="top"
|
[[Basculer les enfants|Basculer les enfants]]
|
Inverse les enfants de droite et de gauche. Choisissez parmi les sous-commandes suivantes :
* Tous -- inverse tous les éléments sur la fiche
* Sélectionnés -- inverse seulement les éléments sélectionnés
|- valign="top"
|
Ordre de tabulation
|
Invoque la boîte de dialogue [[Ordre de tabulation|Ordre de tabulation]].
|- valign="top"
|
Ordre de création

(composants non visuels)
|
Ouvre la boîte de dialogue [[Ordre de création|Ordre de création]].
|- valign="top"
|
[[Masquer les composants non visuels|Masquer les composants non-visuels]]
|
Vous permet de [[Masquer les composants non visuels|masquer ou d'afficher]] les composants non-visuels au moment de la conception.
|- valign="top"
|
[[Revenir aux valeurs héritées|Revenir aux valeurs héritées]]
|
Réinitialise les propriétés, les méthodes et les événements du contrôle sélectionné sur les valeurs du contrôle de la classe de base. Voir [[Revenir aux valeurs héritées|Revenir aux valeurs héritées]].
|- valign="top"
|
Ajouter au référentiel
|
Ouvre la boîte de dialogue [[Ajouter au référentiel|Ajouter au référentiel]].
|- valign="top"
|
[[Voir comme texte|Voir comme texte]]
|
Ouvre le fichier fiche en cours au format texte dans la fenêtre [[Editeur de code|Editeur de code]]. Voir [[Voir comme texte|Voir comme texte]].
|- valign="top"
|
[[DFM texte ou FMX texte|FMX texte]]{{f|vcl| 
(fiches multi-périphériques) 
 
[[DFM texte ou FMX texte|DFM texte]] 
(fiches VCL)}}
|
Enregistre le fichier fiche au format texte (activé) ou au format binaire (désactivé). Voir [[DFM texte ou FMX texte|DFM texte ou FMX texte]].
|- valign="top"
|
Modifier le style par défaut 
Modifier un style personnalisé

(contrôles de bureau {{FM}})
|
Ouvre le '''[[Concepteur de styles FireMonkey|Concepteur de styles FireMonkey]].'''

Pour de plus amples informations, voir [[Personnalisation des applications FireMonkey avec les styles|Personnalisation des applications FireMonkey avec les styles]].
|- valign="top" {{fr|vcl}}
|
Tester le dialogue

(VCL seulement)
|
Pour tous les dialogues VCL modaux, teste le dialogue. Ainsi, si vous cliquez avec le bouton droit sur un OpenDialog sur le Concepteur de fiches et sélectionnez '''Tester le dialogue''', la boîte de dialogue d'ouverture de fichiers standard est affichée.
|}

==Touches de raccourci sur le Concepteur de fiches==

Vous pouvez utiliser les touches de raccourci suivantes pour déplacer ou redimensionner les composants sur le Concepteur de fiches.

{|
|-
!'''Raccourci'''
!'''Action'''
|-
|
<code>Ctrl + Zone de sélection de la souris</code>
|
Sélectionne tous les contrôles enfant du contrôle parent qui sont localisés dans la zone sélectionnée avec la souris.
|-
|
<code>Maj + Sélection de la souris</code>
|
Sélectionne plusieurs contrôles simultanément. Enfoncez la touche Maj lorsque vous cliquez sur les différents contrôles à sélectionner.
|-
|
<code>Ctrl + Touche fléchée</code>
|
Déplace lentement le composant sélectionné
|-
|
<code>Ctrl + Maj + Touche fléchée</code>
|
Déplace le composant plus rapidement
|-
|
<code>Tab</code> ou <code>Touche fléchée </code>
|
Modifie la focalisation parmi les composants
|-
|
<code>Maj + Touche fléchée </code>
|
Modifie la taille du composant
|-
|
<code>Echap </code>
|
Sélectionne le composant parent
|-
|
<code>Ctrl + Tab </code>
|
Accède à l'onglet Edition suivant
|-
|
<code>Ctrl + Maj + Tab</code>
|
Accède à l'onglet Edition précédent
|}

==Voir aussi==

* [[Options du Concepteur de fiches|Options du Concepteur de fiches]]
* [[Tutoriel mobile : Utilisation d'un composant Bouton avec différents styles (iOS et Android)|Tutoriel mobile : Utilisation d'un composant Bouton avec différents styles (iOS et Android)]]

<f s="appmethod" />

* [[Présentation de l'EDI - Index (tutoriel de l'EDI)|Présentation de l'EDI]]
* [[Ajout de composants avec le Concepteur de fiches (tutoriel de l'EDI)|Ajout de composants à une fiche]]
* [[Editeur de code|Editeur de code]]

<f e="appmethod" />

* [[Utilisation des vues FireMonkey|Utilisation des vues FireMonkey]]

<f s="radstudio" />

* [[Présentation de l'EDI|Présentation de l'EDI]]
* [[Editeur de code|Editeur de code]]
* [[Démarrage d'un projet - Présentation|Démarrage d'un projet - Présentation]]
* [[Ajout de composants à une fiche|Ajout de composants à une fiche]]
* [[Définition des propriétés et des événements|Définition des propriétés et des événements]]
* [[Directives de conception (VCL seulement)|Directives de conception (VCL seulement)]]
* [[Utilisation de directives du Concepteur avec des composants VCL|Utilisation de directives du Concepteur avec des composants VCL]]
* [[Prendre un instantané de votre fiche (VCL seulement)|Prendre un instantané de votre fiche (VCL seulement)]]
* [[Aperçu du positionneur de fiches|Aperçu du positionneur de fiches]]

<f e="radstudio" />

* [[Aperçu multi-périphérique|Aperçu multi-périphérique]]
* [https://www.youtube.com/watch?v=XELph3rB25Y&index=8&list=PLwUPJvR9mZHikVu-FgmXg2ajAagF8OPgh YouTube : FireUI Multi-Device Designer (EN)]

[[Category:Delphi]]
[[Category:C++]]
[[Category:Utilisation de RAD Studio]]
[[Category:AMMigrate]]

[[en:Form Designer]]
[[de:Formular-Designer]]
[[ja:フォームデザイナ]]

FireMonkey 3D

2022-09-30T19:27:17Z

Rrivero : RS-78784. Removed TVideo3D component

{{Parent|Guide des applications FireMonkey}}

==Initiation au 3D==

{{FM}} présente les vues 2D des objets en espace 3D. Un [[lib_fr:FMX.Viewport3D.TViewport3D|TViewport3D]] affiche le contenu 3D dans une autre forme 2D, tandis qu'un [[lib_fr:FMX.Forms3D.TForm3D|TForm3D]] commence par le contenu 3D. 2D et 3D peuvent être [[#Mélange 2D et 3D|imbriqués]].

{{FM}} 3D utilise les bibliothèques spécifiques aux plates-formes, comme suit :

* Pour Windows, la bibliothèque '''Direct3D''' (partie de DirectX ; fournie dans la portée d'unité [[lib_fr:Winapi|Winapi]])
* Pour Mac, la bibliothèque '''OpenGL''' (fournie dans la portée d'unité Macapi)

===Objets 3D===

{{FM}} fournit plusieurs types d'objets 3D :

* Formes 3D primitives comme [[lib_fr:FMX.Objects3D.TCube|TCube]], [[lib_fr:FMX.Objects3D.TSphere|TSphere]] et [[lib_fr:FMX.Objects3D.TCone|TCone]].
* [[lib_fr:FMX.Objects3D.TMesh|TMesh]] pour les objets 3D complexes.
* Objets 2D extrudés en 3D, comme [[lib_fr:FMX.Objects3D.TText3D|TText3D]]. Les objets extrudés ont trois côtés : l'avant, avec la forme 2D originale ; l'arrière, une image miroir de cette forme, et ''l'axe'' de l'extrusion entre eux.
* Objets 2D plats en espace 3D, comme [[lib_fr:FMX.Layers3D.TImage3D|TImage3D]] et [[lib_fr:FMX.Layers3D.TTextLayer3D|TTextLayer3D]].

Les objets sont positionnés en espace 3D avec les coordonnées X, Y et Z en utilisant un [[lib_fr:FMX.Types3D.TPosition3D|TPosition3D]]. En plus de la hauteur et de la largeur, ils ont aussi une [[lib_fr:FMX.Controls3D.TControl3D.Depth|profondeur]]. Les objets 2D plats en espace 3D sont arbitrairement fins avec une profondeur codée en dur de 0,01. Les objets 3D ont la [[lib_fr:FMX.Controls3D.TControl3D.RotationAngle|rotation 3D]] et la [[lib_fr:FMX.Controls3D.TControl3D.Scale|mise à l'échelle]]. La position, la taille, la rotation et la mise à l'échelle sont toutes relatives au point central de l'objet.

Comme avec les contrôles 2D, tout contrôle 3D de {{FM}} peut être le parent de tout autre contrôle 3D. La rotation et la position d'un enfant sont relatives à son parent. Le déplacement ou la rotation d'un parent repositionnera sa sous-arborescence de composants. [[lib_fr:FMX.Layers3D.TLayout3D|TLayout3D]] peut être utilisé comme un autre parent commun pour organiser les autres objets.

Tandis que les objets 2D arrangés sur une surface 2D nécessitent la notion d'ordre Z pour déterminer leur disposition, les objets de l'espace 3D sont ordonnés intrinsèquement, ainsi quand ils sont vus à partir d'un point d'observation donné, les objets proches occluent les objets lointains dans la même ligne de vue.

===Caméras===

Chaque vue d'espace 3D est contrôlée par une ''caméra''. La position et l'orientation (rotation 3D) de la caméra déterminent ce que vous voyez. Il y a toujours la ''caméra de conception'' utilisée dans le Concepteur de fiches, et par défaut à l'exécution. Elle est directement située au-dessus de l'axe Z négatif (vers l'axe Y négatif), perpendiculaire au plan X-Z, avec un angle légèrement vers le bas, afin que la position 0,0,0 soit au centre de la vue. Pour utiliser une caméra différente, définissez la propriété UsingDesignCamera du [[lib_fr:FMX.Viewport3D.TViewport3D.UsingDesignCamera|TViewport3D]] ou du [[lib_fr:FMX.Forms3D.TCustomForm3D.UsingDesignCamera|TForm3D]] sur False, et assignez un [[lib_fr:FMX.Controls3D.TCamera|TCamera]] à la propriété Camera. Une scène peut avoir plusieurs caméras. Après l'affectation d'une autre caméra à la propriété Camera, vous devez appeler Repaint manuellement.

Le volume visible est un ''champ de vue'', avec le plan proche légèrement en face de la caméra. Toute chose entre la caméra et cet avant-plan est coupée de la vue. L'angle du ''champ de vue'' est fixé verticalement : rendre la fenêtre / fiche plus haute rend chaque chose plus grande, tandis que la rendre plus large en montre plus sur les côtés. Les unités de la position et de la taille sont relatives à l'échelle du champ de vue.

====Projection d'écran====

En plus de la vue d'un objet (ou de l'absence de vue) déterminé par la caméra, un objet peut aussi être défini pour être vu quel que soit l'endroit où la caméra pointe, comme les indicateurs de statut fixes dans les jeux 3D. Cela est réalisé en changeant la propriété [[lib_fr:FMX.Controls3D.TControl3D.Projection|Projection]] de la valeur par défaut '''Camera''' en '''Screen''', afin que :

* Avec Position.Z à zéro :
** XY 0,0 est le coin supérieur gauche, comme en 2D. La position 3D reflète toujours la position du centre de l'objet, pas sa position supérieure gauche comme en 2D.
** Les dimensions Hauteur, Largeur et Profondeur sont rendues en pixels, peu importe comment le champ de vue est mis à l'échelle.
** Puisque les unités sont rendues en pixels, les dimensions d'un objet utilisant la projection d'écran sont plus grandes que lors de l'utilisation de la projection de caméra afin d'apparaître à la même taille.
** L'objet apparaît légèrement derrière l'avant-plan de découpage du champ de vue. Les objets utilisant la projection de caméra ont un petit intervalle où ils peuvent apparaître devant les objets projetés à l'écran avant d'être découpés par l'avant-plan.
* Avec Position.Z supérieur à zéro (loin de la visionneuse) :
** La taille rendue est plus petite.
** La réduction de la vue éloigne l'objet, le rendant même plus petit.
** L'agrandissement de la vue rapproche l'objet, le rendant plus grand.
* Avec Position.Z inférieur à zéro (vers la visionneuse) :
** La taille rendue est plus grande.
** La réduction de la vue rapproche l'objet, le rendant même plus grand.
** En le rapprochant trop (en réduisant la vue ou en définissant Position.Z directement), l'objet se déplacera au-delà de l'avant-plan du champ de vue, provoquant ainsi sa disparition.
** L'agrandissement de la vue éloigne l'objet, le rendant plus petit.

Dans le Concepteur de fiches, changer la projection d'un objet recalcule sa position afin qu'il ne se déplace pas, et ajuste aussi la taille.

====Perche de caméra====

La visualisation d'un objet ou d'une scène à partir de n'importe quelle direction, contrôlée par l'utilisateur, est une application 3D courante. Bien que vous pouvez calculer la position et l'orientation afin d'obtenir l'angle de caméra adéquat, il est plus facile de créer une perche de caméra virtuelle :

# Créez un objet invisible, tel qu'un [[lib_fr:FMX.Objects3D.TDummy|TDummy]], au même emplacement que l'objet d'intérêt, ou au centre de la scène.
# Créez le TCamera en tant qu'enfant de l'objet.
## Définissez sa Position sur la distance désirée sur l'un des axes.
## Si nécessaire, définissez sa propriété RotationAngle afin que la caméra pointe le long de l'axe vers l'emplacement. Assurez-vous que la caméra n'est pas à 180 degrés.
# Vous pouvez maintenant faire une rotation de la caméra autour de l'objet, simplement en changeant la propriété RotationAngle de l'objet dummy. La caméra maintient la distance exacte et pointe automatiquement directement vers le centre.
# L'ajout d'une lumière en tant qu'enfant de la caméra maintiendra la distance et l'orientation de la lumière quand la caméra se déplace.

===Luminosité===

En général, un objet 3D est une masse noire commune, à moins qu'il ne comporte des lumières. Un ou plusieurs objets [[lib_fr:FMX.Controls3D.TLight|TLight]] définissent la lumière dans l'espace 3D, selon leur propriété [[lib_fr:FMX.Controls3D.TLight.LightType|LightType]] :

; Directional
: La lumière directionnelle est constante, à partir d'un angle donné. La lumière du soleil est un peu analogue : elle provient de très loin, ainsi pour n'importe quel endroit localisé sur la terre -- à quelques mètres près, pas des kilomètres -- tous les éléments sont éclairés de la même façon. La position d'une lumière directionnelle n'a pas de rapport avec son effet. Sa position est pertinente si vous essayez de cliquer dessus dans le Concepteur de fiches. Ce qui compte c'est la direction des points de lumière, définie par sa propriété '''RotationAngle''', et la propriété '''RotationAngle''' de ses parents.
; Point
: Une lumière ponctuelle ressemble à une ampoule nue. Il rayonne dans toutes les directions, et diminue d'intensité avec la distance. Son '''RotationAngle''' est sans effet. Ce qui compte c'est sa position, qui est affectée par la position et la rotation de ses parents.
; Spot
: Une lumière projetée dépend à la fois de la position et de la rotation, et diminue d'intensité avec la distance.

Les objets 2D plats en espace 3D ne nécessitent pas de lumière, et ne sont pas affectés par la lumière. Ils apparaissent comme d'habitude avec une perspective 3D ajoutée.

===Matériaux===

La surface d'un objet {{FM}} 3D est définie par sa propriété ''material''. Les matériaux {{FM}} 3D sont basés sur les shaders. Cela permet une variation illimitée de luminosité et de matériaux dans une application. La liste des matériaux disponibles se trouve dans la [[Palette d'outils|Palette d'outils]] sous la catégorie '''Matériaux'''. Chaque objet {{FM}} 3D dispose de la propriété [[lib_fr:FMX.Objects3D.TShape3D.MaterialSource|MaterialSource]], qui lie une source de matériau à l'objet en cours. Pour conserver une bibliothèque de matériaux, utilisez [[lib_fr:FMX.MaterialSources.TMaterialBook|TMaterialBook]]. Pour utiliser un matériau unique, la source peut être liée à autant d'objets que nécessaire.

Les objets extrudés ont les propriétés [[lib_fr:FMX.Objects3D.TExtrudedShape3D.MaterialShaftSource|MaterialShaftSource]] et [[lib_fr:FMX.Objects3D.TExtrudedShape3D.MaterialBackSource|MaterialBackSource]] supplémentaires. Chacune est de type [[lib_fr:FMX.MaterialSources.TMaterialSource|TMaterialSource]].

Pour contrôler comment un matériau d'objet apparaît sous l'influence de la lumière, liez-le à un [[lib_fr:FMX.MaterialSources.TLightMaterialSource|TLightMaterialSource]] :

* La couleur [[lib_fr:FMX.MaterialSources.TLightMaterialSource.Emissive|Emissive]] détermine si une surface émet sa propre lumière, ou brille. La valeur par défaut est null (noir, opacité zéro) : les objets ne brillent pas normalement, et requièrent la lumière pour être vus. En définissant une couleur, les surfaces sans lumière apparaissent avec cette couleur. En cas d'éclairage, la couleur Emissive est mélangée aux autres couleurs résultant de la lumière.
* La couleur [[lib_fr:FMX.MaterialSources.TLightMaterialSource.Ambient|Ambient]] fournit une couleur de base aux surfaces afin qu'elles puissent être vues. Dans le monde réel, la lumière se reflète sur une surface à partir de nombreuses directions ; mais dans une scène 3D il serait difficile de définir toute cette lumière. Ainsi la couleur Ambient est activée par toute lumière de l'espace. Sans lumière, elle est sans effet. La surface est coloriée de façon assez uniforme dans cette couleur. Avec une lumière directionnelle -- qui n'a pas à pointer à la surface -- tout semble plat. Avec les lumières ponctuelles et projetées, la couleur s'atténue avec la distance.
* La couleur [[lib_fr:FMX.MaterialSources.TLightMaterialSource.Diffuse|Diffuse]] interagit directement avec la lumière, y compris l'angle de l'incidence. Sans lumière, elle est sans effet. Il est courant de définir '''Ambient''' et '''Diffuse''' sur la même couleur.
* La couleur [[lib_fr:FMX.MaterialSources.TLightMaterialSource.Specular|Specular]] simule une surface brillante, en reflétant la lumière à un angle spécifique, au lieu de diffuser la lumière dans de nombreux angles. Sans lumière, '''Specular''' est sans effet. La valeur par défaut est la couleur blanche pour reflèter la lumière sans altérer sa couleur.

==Mélange 2D et 3D==

Les objets 3D doivent être placés dans un conteneur 3D. Un objet 3D (tel que TCube) ne sera pas rendu s'il est placé directement dans un conteneur 2D (tel que TForm), mais il sera affiché dans la [[Vue Structure|vue Structure]] en tant que contrôle enfant. Inversement, un objet 2D (tel que TButton) ne sera pas rendu s'il est placé directement dans un conteneur 3D (tel que TForm3D), mais il sera aussi affiché dans la [[Vue Structure|vue Structure]] en tant que contrôle enfant. Deux classes permettent le mélange imbriqué de contenus 2D et 3D :

* [[lib_fr:FMX.Layers3D.TLayer3D|TLayer3D]] est un objet 3D qui contient un contenu 2D. Il ressemble à une feuille rectangulaire qui réside dans un espace 3D.
* [[lib_fr:FMX.Viewport3D.TViewport3D|TViewport3D]] est un objet 2D qui contient un contenu 3D. Comme TForm3D, c'est une "fenêtre" dans un espace 3D.

Vous pouvez imbriquer ces conteneurs. Par exemple, vous pouvez avoir une hiérarchie d'objets telle que :

* TForm3D
** TCube
** TLayer3D
*** TButton
*** TViewport3D
**** TCube

De plus, quelques classes hébergent directement du contenu 2D dans un espace 3D :

* TTextLayer3D affiche du texte.
* TImage3D affiche des images bitmap.

==Importation de modèles 3D==

Le framework {{FM}} offre le support d'importation des modèles 3D. Le modèle 3D peut être rendu seulement dans un conteneur 3D. Pour importer un modèle 3D, utilisez des objets [[lib_fr:FMX.Objects3D.TModel3D|TModel3D]]. Vous trouverez [[lib_fr:FMX.Objects3D.TModel3D|TModel3D]] dans la [[Palette d'outils|Palette d'outils]]. Pour charger un objet, utilisez la propriété [[lib_fr:FMX.Objects3D.TModel3D.MeshCollection|MeshCollection]] du [[lib_fr:FMX.Objects3D.TModel3D|TModel3D]]. Les fichiers 3D supportés sont '''.obj''', '''.dae''' et '''.ase'''.

Les modèles sont importés et affichés avec la texture. En l'absence de lumière sur la scène, la texture n'est pas visible. Un modèle importé est manipulable d'une façon élémentaire (rotation, déplacement, mise à l'échelle et redimensionnement) comme tout autre objet 3D.

L'affichage correct d'un modèle chargé dépend de la cohérence et de la correction du fichier chargé.

==Voir aussi==

* [[Conception d'applications FireMonkey|Conception d'applications FireMonkey]]
* [[Application 3D multi-périphérique|Expert Application {{FM}} 3D]]
* [[Tutoriel : Création d'une application 3D FireMonkey|Tutoriel : Création d'une application 3D FireMonkey]]
* [[Tutoriel : Comment utiliser les caméras dans une application FireMonkey 3D|Tutoriel : Comment utiliser les caméras dans une application FireMonkey 3D]]
* [[Experts de création de composants et d'applications multi-périphériques FireMonkey|Experts de création de composants et d'applications multi-périphériques FireMonkey]]
* [[Guide de prise en main FireMonkey - Création d'une application 3D|Guide de prise en main FireMonkey - Création d'une application 3D]]

==Exemples de code==

* Exemple [[samp_en:FMX.AnimationDemoHD Sample|{{FM}} HD Animation]]
* Exemple [[samp_en:FMX.AnimationDemo3D Sample|{{FM}} 3D Animation]]
* Exemple [[samp_en:FMX.Gyroscope Sample|{{FM}} Gyroscope]]
* Exemple [[samp_en:FMX.Arrows3D Sample|{{FM}} 3D Arrows]]
* Exemple [[samp_en:FMX.FirstApp3D Sample|{{FM}} First App3D]]
* Exemple [[samp_en:OpenGL Multicolor Tetrahedron (C++)|OpenGL Multicolor Tetrahedron (C++)]]

[[Category:XE3]]
[[Category:FMX]]
[[Category:AMMigrate]]

[[en:FireMonkey 3D]]
[[de:FireMonkey 3D]]
[[ja:FireMonkey 3D]]

Tutoriel mobile : Définition de votre environnement de développement sur un PC Windows (iOS)

2022-08-17T19:46:11Z

Rrivero : RS-114036. Updated screenshots and path names (Captures d'écran et noms de chemin mis à jour)

{{Parent|Tutoriels mobiles : Développement d'applications mobiles (iOS et Android)}}

Avant de commencer ce tutoriel, il est recommandé de lire et suivre le tutoriel suivant :

* '''[[Tutoriel mobile : Définition de votre environnement de développement sur le Mac (iOS)|Tutoriel mobile : Définition de votre environnement de développement sur le Mac (iOS)]]'''

__TOC__

Une application {{FM}} destinée à la plate-forme cible iOS peut être testée initialement sur le '''simulateur iOS''' disponible sur le Mac. La deuxième moitié du processus de test consiste à utiliser la plate-forme cible '''Périphérique iOS''' et requiert un périphérique iOS test connecté au Mac.

: {{Note| Sur les périphériques iOS, vous pouvez exécuter à la fois des applications Delphi et C++. Toutefois, le '''simulateur iOS''' n'étant pas pris en charge par '''BCCIOSARM''', seuls les périphériques iOS sont supportés pour C++.}}

Pour déployer une application iOS sur votre périphérique iOS ou sur un simulateur iOS à des fins de débogage et de test, {{Product}} utilise '''[[PAServer, l'application serveur Platform Assistant|Platform Assistant]]''' ; vous devez [[Installation de Platform Assistant sur un Mac|l'installer]] et [[Exécution de Platform Assistant sur un Mac|l'exécuter]] sur le Mac. Votre environnement de développement matériel et logiciel doit présenter la configuration illustrée à la figure suivante. {{Product}} s'exécute sur un PC sous Windows. Votre PC doit être connecté à un Mac exécutant '''[[PAServer, l'application serveur Platform Assistant|Platform Assistant]]''' et équipé des versions appropriées de '''[[Installation de Xcode sur un Mac|Xcode]]''' et du SDK iOS (pour le développement iOS). Pour exécuter les apps iOS sur un périphérique iOS, ce dernier doit être connecté au Mac via un câble USB.

[[File:Win2Mac2iOSDevice.png|650px]]

Cette section décrit les étapes de configuration de votre environnement de développement '''après''' la configuration de votre environnement sur votre Mac.

==Configuration de votre environnement {{Product}}==

Vous devez exécuter les étapes de configuration suivantes pour préparer le développement iOS avec {{Product}}.

===[[Créer un profil de connexion|Créer un profil de connexion]] pour le Mac===

# Dans l'EDI {{Product}}, ouvrez '''Outils > Options > Déploiement > [[Gestionnaire de profils de connexion|Gestionnaire de profils de connexion]]''':
# Cliquez sur '''Ajouter''' :
#: [[Fichier:Connection_profile_manager.png|500px]] 
# Vous voyez maintenant l'expert [[Créer un profil de connexion|Créer un profil de connexion]]. Définissez le nom du profil de connexion, par exemple "Mon Mac". Assurez-vous de sélectionner '''macOS''' comme plate-forme, puis cliquez sur '''Next''':
#: [[Fichier:Create a connection profile.png|500px]] 
# Dans la page '''Informations sur la machine distante''', définissez le nom ou l'adresse IP du Mac hôte, le numéro de port à utiliser (le port par défaut 64211 fonctionne en général) et un mot de passe facultatif (si vous souhaitez utiliser un mot de passe).
#: [[Fichier:Remote machine information.png|500px]] 
# Cliquez sur '''Tester connexion''' et assurez-vous que le profil de connexion fonctionne sans erreur (vous devez recevoir le message '''"La connexion à <nom d'hôte> sur le port <numéro de port> a réussi"''').
# Si l'opération '''Tester connexion''' réussit, cliquez sur le bouton '''Terminer''', sinon vérifiez les paramètres et essayez à nouveau. 

===[[Ajout d'un SDK macOS ou iOS|Ajouter un SDK]] au système de développement pour le périphérique iOS connecté au Mac===

# Ouvrez {{Menu|Outils > Options > Déploiement > [[Gestionnaire de SDK|Gestionnaire de SDK]]}}.
#: [[Fichier:Add sdk.png|500px]] 
# Cliquez sur '''Ajouter'''.
# Sur la boîte de dialogue '''Ajouter un nouveau SDK''', sélectionnez '''Périphérique iOS 32 bits''' ou '''Périphérique iOS 64 bits''' comme plate-forme.
#: [[Fichier:Add new SDK.png]] 
# Une fois la plate-forme sélectionnée, l'EDI remplit un profil (comme "Mon Mac") et la zone de liste déroulante relative à la version SDK par la liste des versions SDK disponibles sur la machine exécutant le serveur Platform Assistant :
#: [[Fichier:SDK profile selection.png]] 
# Cliquez sur '''OK''' pour ajouter le nouveau SDK sélectionné.
# Une fois l'opération terminée, cliquez sur '''Fermer''' pour fermer la boîte de dialogue.

==Voir aussi==

* [[Tutoriel mobile : Création d'une application pour les plates-formes mobiles (iOS et Android)|Tutoriel mobile : Création d'une application pour les plates-formes mobiles (iOS et Android)]]
* [[Tutoriel mobile : Définition de votre environnement de développement sur le Mac (iOS)|Tutoriel mobile : Définition de votre environnement de développement sur le Mac (iOS)]]
* [[Travailler avec un Mac et un PC|Travailler avec un Mac et un PC]]
* [[Exécution de votre application iOS sur un périphérique iOS|Exécution de votre application iOS sur un périphérique iOS]]
* [[Exécution de votre application iOS sur le simulateur iOS|Exécution de votre application iOS sur le simulateur iOS]]
* [[Prérequis de plate-forme FireMonkey|Prérequis de plate-forme FireMonkey]]
* [[Création d'une app iOS|Création d'une app iOS]]
* [[Développement d'applications macOS|Développement d'applications macOS]]
* [[Création d'une application FireMonkey|Création d'une application FireMonkey]]
* Pages Apple developer.apple.com
** [http://developer.apple.com/library/ios/navigation/ iOS Developer Library (EN)]
** [http://developer.apple.com/library/ios/navigation/index.html?section=Resource+Types&topic=Getting+Started iOS Developer Library: Getting Started (EN)]
** [http://developer.apple.com/devcenter/ios/index.action iOS Dev Center (EN)]
** [https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/AppDistributionGuide/LaunchingYourApponDevices/LaunchingYourApponDevices.html Lancement de votre app sur des périphériques (EN)]
** [https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/AppDistributionGuide/Introduction/Introduction.html Preparing Your iOS App for Distribution in the App Store (EN)]
** [http://developer.apple.com/iad/ iAd Network (EN)]

{{DEFAULTSORT:Tutoriel mobile : Definition de votre environnement de developpement sur un PC Windows (iOS)}}
[[Category:Delphi]]
[[Category:FMX]]
[[Category:IOS]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Mobile Tutorial: Set Up Your Development Environment on Windows PC (iOS)]]
[[de:Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Windows-PC (iOS)]]
[[ja:モバイルチュートリアル：Windows PC に開発環境をセットアップする（iOS）]]

Fichier:SDK profile selection.png

2022-08-17T19:44:22Z

Rrivero :

SDK profile selection screenshot

Fichier:Add new SDK.png

2022-08-17T19:43:03Z

Rrivero :

Profile selection at new SDK screenshot

Fichier:Add sdk.png

2022-08-17T19:34:47Z

Rrivero :

add sdk screenshot

Fichier:Remote machine information.png

2022-08-17T19:30:19Z

Rrivero :

Remote machine information screenshot

Fichier:Create a connection profile.png

2022-08-17T19:27:23Z

Rrivero :

Createa connection profile screenshot

Fichier:Connection profile manager.png

2022-08-17T19:19:05Z

Rrivero :

Connection Profile Manager Screenshot